/**
 * 配置文件加载模块
 * 支持从JSON/YAML文件加载配置
 * 优化：支持环境变量配置、配置热更新
 */ "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 ConfigFileFormat () {
        return ConfigFileFormat;
    },
    get ConfigLoader () {
        return ConfigLoader;
    }
});
const _utils = require("../../utils");
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 ConfigFileFormat = /*#__PURE__*/ function(ConfigFileFormat) {
    ConfigFileFormat["JSON"] = "json";
    ConfigFileFormat["YAML"] = "yaml";
    return ConfigFileFormat;
}({});
/**
 * 配置变更通知管理器
 */ let ConfigChangeNotifier = class ConfigChangeNotifier {
    /**
   * 添加配置变更监听器
   */ addListener(listener) {
        this.listeners.add(listener);
        // 返回取消监听的函数
        return ()=>{
            this.listeners.delete(listener);
        };
    }
    /**
   * 移除配置变更监听器
   */ removeListener(listener) {
        this.listeners.delete(listener);
    }
    /**
   * 通知配置变更
   */ notify(newConfig, oldConfig) {
        this.listeners.forEach((listener)=>{
            try {
                listener(newConfig, oldConfig);
            } catch (error) {
                _utils.logger.warn('配置变更监听器执行失败:', error);
            }
        });
    }
    /**
   * 清除所有监听器
   */ clear() {
        this.listeners.clear();
    }
    constructor(){
        _define_property(this, "listeners", new Set());
    }
};
/**
 * 全局配置变更通知器实例
 */ const configChangeNotifier = new ConfigChangeNotifier();
let ConfigLoader = class ConfigLoader {
    /**
   * 从JSON文件加载配置
   * 
   * @param path - 文件路径
   * @returns 配置对象
   */ static async loadFromJSON(path) {
        try {
            // 在浏览器环境中，需要通过网络请求加载
            if (typeof window !== 'undefined') {
                const response = await fetch(path);
                if (!response.ok) {
                    throw new Error(`无法加载配置文件: ${path} (${response.status})`);
                }
                return await response.json();
            }
            // 在Node.js环境中，使用fs模块
            if (typeof require !== 'undefined') {
                const fs = require('fs');
                const content = fs.readFileSync(path, 'utf-8');
                return JSON.parse(content);
            }
            throw new Error('不支持的环境：无法加载配置文件');
        } catch (error) {
            _utils.logger.error(`加载JSON配置文件失败: ${path}`, error);
            throw error;
        }
    }
    /**
   * 从YAML文件加载配置
   * 
   * @param path - 文件路径
   * @returns 配置对象
   */ static async loadFromYAML(path) {
        try {
            // 在浏览器环境中，需要通过网络请求加载
            if (typeof window !== 'undefined') {
                const response = await fetch(path);
                if (!response.ok) {
                    throw new Error(`无法加载配置文件: ${path} (${response.status})`);
                }
                const text = await response.text();
                // 需要YAML解析库，这里假设有yaml库
                // 如果没有，可以提示用户安装
                if (typeof window.YAML !== 'undefined') {
                    return window.YAML.parse(text);
                }
                // 降级：尝试作为JSON解析（如果YAML格式简单）
                try {
                    return JSON.parse(text);
                } catch  {
                    throw new Error('需要YAML解析库，请安装 yaml 包');
                }
            }
            // 在Node.js环境中，使用fs模块和yaml库
            if (typeof require !== 'undefined') {
                const fs = require('fs');
                const yaml = require('yaml');
                const content = fs.readFileSync(path, 'utf-8');
                return yaml.parse(content);
            }
            throw new Error('不支持的环境：无法加载配置文件');
        } catch (error) {
            _utils.logger.error(`加载YAML配置文件失败: ${path}`, error);
            throw error;
        }
    }
    /**
   * 从文件加载配置
   * 
   * @param options - 加载选项
   * @returns 配置对象
   */ static async loadFromFile(options) {
        const { path, format = "json", required = false, defaultConfig = {} } = options;
        if (!path) {
            if (required) {
                throw new Error('配置文件路径未指定');
            }
            return defaultConfig;
        }
        try {
            let config;
            switch(format){
                case "json":
                    config = await this.loadFromJSON(path);
                    break;
                case "yaml":
                    config = await this.loadFromYAML(path);
                    break;
                default:
                    throw new Error(`不支持的配置文件格式: ${format}`);
            }
            _utils.logger.info(`成功加载配置文件: ${path}`);
            return config;
        } catch (error) {
            if (required) {
                throw error;
            }
            _utils.logger.warn(`配置文件加载失败，使用默认配置: ${path}`, error);
            return defaultConfig;
        }
    }
    /**
   * 合并配置（深度合并）
   * 
   * @param base - 基础配置
   * @param override - 覆盖配置
   * @returns 合并后的配置
   */ static mergeConfig(base, override) {
        const merged = {
            ...base
        };
        for(const key in override){
            if (!Object.prototype.hasOwnProperty.call(override, key)) {
                continue;
            }
            const baseValue = merged[key];
            const overrideValue = override[key];
            if (baseValue && overrideValue && typeof baseValue === 'object' && typeof overrideValue === 'object' && !Array.isArray(baseValue) && !Array.isArray(overrideValue)) {
                // 深度合并对象
                merged[key] = this.mergeConfig(baseValue, overrideValue);
            } else {
                // 直接覆盖
                merged[key] = overrideValue;
            }
        }
        return merged;
    }
    /**
   * 从多个源加载并合并配置
   * 
   * @param sources - 配置源列表（按优先级从低到高）
   * @returns 合并后的配置
   */ static async loadFromMultipleSources(sources) {
        let merged = {};
        for (const source of sources){
            if ('path' in source && 'format' in source) {
                // 配置文件
                const fileConfig = await this.loadFromFile(source);
                merged = this.mergeConfig(merged, fileConfig);
            } else if (!('path' in source) && !('format' in source)) {
                // 配置对象
                merged = this.mergeConfig(merged, source);
            }
        }
        return merged;
    }
    /**
   * 从环境变量加载配置
   * 
   * 支持以下环境变量格式：
   * - FRAMEWORK_LOGGER_LEVEL=DEBUG
   * - FRAMEWORK_SHOW_SPLASH_SCREEN=always
   * - FRAMEWORK_MIN_SPLASH_SCREEN_TIME=1000
   * 
   * @param prefix - 环境变量前缀，默认为 'FRAMEWORK_'
   * @returns 配置对象
   */ static loadFromEnv(prefix = 'FRAMEWORK_') {
        const config = {};
        if (typeof process === 'undefined' || !process.env) {
            return config;
        }
        // 遍历所有环境变量
        for (const [key, value] of Object.entries(process.env)){
            if (!key.startsWith(prefix)) {
                continue;
            }
            // 移除前缀并转换为驼峰命名
            const configKey = key.slice(prefix.length).toLowerCase().split('_').map((part, index)=>index === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)).join('');
            // 尝试解析值
            let parsedValue = value;
            if (value === 'true' || value === 'false') {
                parsedValue = value === 'true';
            } else if (!isNaN(Number(value))) {
                parsedValue = Number(value);
            } else if (value?.startsWith('{') || value?.startsWith('[')) {
                try {
                    parsedValue = JSON.parse(value);
                } catch  {
                // 解析失败，使用原始值
                }
            }
            // 设置配置值
            config[configKey] = parsedValue;
        }
        _utils.logger.debug('从环境变量加载配置:', config);
        return config;
    }
    /**
   * 从多个源加载配置（包括环境变量）
   * 
   * 优化：明确优先级，从低到高：
   * 1. 默认配置
   * 2. 配置文件
   * 3. 环境变量
   * 4. 代码配置（通过 sources 参数传入）
   * 
   * @param sources - 配置源列表（代码配置，优先级最高）
   * @param defaultConfig - 默认配置（优先级最低）
   * @param includeEnv - 是否包含环境变量，默认为 true
   * @param envPrefix - 环境变量前缀，默认为 'FRAMEWORK_'
   * @returns 合并后的配置
   */ static async loadFromAllSources(sources = [], defaultConfig = {}, includeEnv = true, envPrefix = 'FRAMEWORK_') {
        // 保存旧配置用于变更通知
        const oldConfig = {
            ...defaultConfig
        };
        // 1. 从默认配置开始
        let merged = {
            ...defaultConfig
        };
        // 2. 加载配置文件（优先级高于默认配置）
        const fileConfigs = await this.loadFromMultipleSources(sources.filter((source)=>typeof source === 'object' && 'path' in source));
        merged = this.mergeConfig(merged, fileConfigs);
        // 3. 加载环境变量（优先级高于配置文件）
        if (includeEnv) {
            const envConfig = this.loadFromEnv(envPrefix);
            merged = this.mergeConfig(merged, envConfig);
        }
        // 4. 合并代码配置（优先级最高）
        const codeConfigs = sources.filter((source)=>typeof source === 'object' && !('path' in source));
        for (const codeConfig of codeConfigs){
            merged = this.mergeConfig(merged, codeConfig);
        }
        // 通知配置变更
        configChangeNotifier.notify(merged, oldConfig);
        return merged;
    }
    /**
   * 添加配置变更监听器
   * 
   * @param listener - 配置变更监听器
   * @returns 取消监听的函数
   */ static onConfigChange(listener) {
        return configChangeNotifier.addListener(listener);
    }
    /**
   * 移除配置变更监听器
   */ static removeConfigChangeListener(listener) {
        configChangeNotifier.removeListener(listener);
    }
};

//# sourceMappingURL=ConfigLoader.js.map