/**
 * 统一错误处理器
 * 
 * 优化：
 * 1. 统一错误处理策略：记录、上报、恢复、降级
 * 2. 错误分类：致命、可恢复、警告
 * 3. 错误恢复机制：自动重试、降级方案
 */ "use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: Object.getOwnPropertyDescriptor(all, name).get
    });
}
_export(exports, {
    get ErrorHandler () {
        return ErrorHandler;
    },
    get ErrorHandlingStrategy () {
        return ErrorHandlingStrategy;
    },
    get getDefaultErrorHandler () {
        return getDefaultErrorHandler;
    },
    get setDefaultErrorHandler () {
        return setDefaultErrorHandler;
    }
});
const _utils = require("../../utils");
const _errors = require("../../utils/errors");
function _define_property(obj, key, value) {
    if (key in obj) {
        Object.defineProperty(obj, key, {
            value: value,
            enumerable: true,
            configurable: true,
            writable: true
        });
    } else {
        obj[key] = value;
    }
    return obj;
}
var ErrorHandlingStrategy = /*#__PURE__*/ function(ErrorHandlingStrategy) {
    /**
   * 记录错误（日志）
   */ ErrorHandlingStrategy["LOG"] = "LOG";
    /**
   * 上报错误（监控服务）
   */ ErrorHandlingStrategy["REPORT"] = "REPORT";
    /**
   * 尝试恢复错误
   */ ErrorHandlingStrategy["RECOVER"] = "RECOVER";
    /**
   * 降级处理
   */ ErrorHandlingStrategy["FALLBACK"] = "FALLBACK";
    /**
   * 忽略错误
   */ ErrorHandlingStrategy["IGNORE"] = "IGNORE";
    return ErrorHandlingStrategy;
}({});
let ErrorHandler = class ErrorHandler {
    /**
   * 设置监控服务
   */ setMonitoring(monitoring) {
        this.monitoring = monitoring;
    }
    /**
   * 处理错误
   * 
   * @param error - 错误对象
   * @param context - 错误上下文
   * @returns 错误处理结果
   */ async handleError(error, context) {
        // 标准化错误对象
        const normalizedError = _errors.errorUtils.normalizeError(error);
        // 创建包含上下文信息的错误对象（由于 context 是只读的，需要创建新对象）
        const errorWithContext = context ? new _errors.FrameworkError(normalizedError.message, normalizedError.type, normalizedError.severity, {
            code: normalizedError.code,
            originalError: normalizedError.originalError,
            context: {
                ...normalizedError.context,
                ...context
            },
            recoverable: normalizedError.recoverable
        }) : normalizedError;
        // 确定处理策略
        const strategies = this.determineStrategies(errorWithContext);
        // 执行处理策略
        const handled = await this.executeStrategies(errorWithContext, strategies);
        // 尝试恢复错误
        let recoveredValue;
        let recoverable = false;
        if (handled && errorWithContext.recoverable && this.config.recoveryOptions) {
            const recoveryResult = await this.attemptRecovery(errorWithContext);
            recoverable = recoveryResult.recoverable;
            recoveredValue = recoveryResult.value;
        }
        return {
            handled,
            recoverable,
            recoveredValue,
            strategies,
            error: errorWithContext
        };
    }
    /**
   * 确定错误处理策略
   */ determineStrategies(error) {
        // 1. 检查错误类型对应的策略
        if (this.config.typeStrategies[error.type]) {
            return this.config.typeStrategies[error.type];
        }
        // 2. 检查错误严重程度对应的策略
        if (this.config.severityStrategies[error.severity]) {
            return this.config.severityStrategies[error.severity];
        }
        // 3. 使用默认策略
        return this.config.defaultStrategies;
    }
    /**
   * 执行处理策略
   */ async executeStrategies(error, strategies) {
        let handled = false;
        for (const strategy of strategies){
            try {
                switch(strategy){
                    case "LOG":
                        this.logError(error);
                        handled = true;
                        break;
                    case "REPORT":
                        await this.reportError(error);
                        handled = true;
                        break;
                    case "RECOVER":
                        // 恢复策略在 handleError 中统一处理
                        handled = true;
                        break;
                    case "FALLBACK":
                        // 降级策略在 attemptRecovery 中处理
                        handled = true;
                        break;
                    case "IGNORE":
                        // 忽略错误，不做任何处理
                        handled = true;
                        break;
                }
            } catch (strategyError) {
                _utils.logger.warn(`错误处理策略 ${strategy} 执行失败:`, strategyError);
            }
        }
        return handled;
    }
    /**
   * 记录错误
   */ logError(error) {
        const errorInfo = _errors.errorUtils.extractErrorInfo(error);
        // 根据错误严重程度选择日志级别
        switch(error.severity){
            case _errors.ErrorSeverity.CRITICAL:
            case _errors.ErrorSeverity.HIGH:
                _utils.logger.error('错误:', errorInfo);
                break;
            case _errors.ErrorSeverity.MEDIUM:
                _utils.logger.warn('警告:', errorInfo);
                break;
            case _errors.ErrorSeverity.LOW:
                _utils.logger.info('信息:', errorInfo);
                break;
        }
        // 开发环境显示详细错误信息
        if (this.config.showDetailedErrorsInDev && process.env.NODE_ENV === 'development') {
            const detailedError = _errors.errorUtils.formatErrorForDev(error);
            console.error(detailedError);
        }
    }
    /**
   * 上报错误
   */ async reportError(error) {
        if (!this.monitoring) {
            _utils.logger.debug('监控服务未配置，跳过错误上报');
            return;
        }
        try {
            this.monitoring.captureError(error, {
                severity: error.severity,
                type: error.type,
                code: error.code,
                context: error.context
            });
        } catch (reportError) {
            _utils.logger.warn('错误上报失败:', reportError);
        }
    }
    /**
   * 尝试恢复错误
   */ async attemptRecovery(error) {
        const options = this.config.recoveryOptions;
        if (!options) {
            return {
                recoverable: false
            };
        }
        const maxRetries = options.maxRetries ?? 3;
        const retryDelay = options.retryDelay ?? 1000;
        const exponentialBackoff = options.exponentialBackoff ?? true;
        const shouldRetry = options.shouldRetry ?? (()=>true);
        // 如果有降级方案，先尝试降级
        if (options.fallback) {
            try {
                const fallbackValue = await Promise.resolve(options.fallback());
                _utils.logger.info('错误已通过降级方案恢复');
                return {
                    recoverable: true,
                    value: fallbackValue
                };
            } catch (fallbackError) {
                _utils.logger.warn('降级方案执行失败:', fallbackError);
            }
        }
        // 尝试重试（如果错误可恢复且满足重试条件）
        if (error.recoverable && shouldRetry(error, 0)) {
            for(let attempt = 0; attempt < maxRetries; attempt++){
                if (!shouldRetry(error, attempt)) {
                    break;
                }
                const delay = exponentialBackoff ? retryDelay * Math.pow(2, attempt) : retryDelay;
                _utils.logger.debug(`错误恢复重试 ${attempt + 1}/${maxRetries}，${delay}ms 后重试...`);
                await new Promise((resolve)=>setTimeout(resolve, delay));
            // 这里应该调用原始操作的重试逻辑
            // 由于错误处理器不知道原始操作，这里只返回可恢复状态
            // 实际的重试应该在调用方实现
            }
        }
        return {
            recoverable: error.recoverable
        };
    }
    /**
   * 创建错误处理器的便捷方法
   */ static create(config) {
        return new ErrorHandler(config);
    }
    constructor(config = {}){
        _define_property(this, "config", void 0);
        _define_property(this, "monitoring", void 0);
        this.monitoring = config.monitoring;
        this.config = {
            defaultStrategies: config.defaultStrategies ?? [
                "LOG",
                "REPORT"
            ],
            severityStrategies: config.severityStrategies ?? {},
            typeStrategies: config.typeStrategies ?? {},
            recoveryOptions: config.recoveryOptions ?? {},
            showDetailedErrorsInDev: config.showDetailedErrorsInDev ?? true
        };
    }
};
/**
 * 默认错误处理器实例（单例）
 */ let defaultErrorHandler = null;
function getDefaultErrorHandler() {
    if (!defaultErrorHandler) {
        defaultErrorHandler = new ErrorHandler();
    }
    return defaultErrorHandler;
}
function setDefaultErrorHandler(handler) {
    defaultErrorHandler = handler;
}

//# sourceMappingURL=ErrorHandler.js.map