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;
}
import { PluginSandbox } from "./plugin/PluginSandbox";
import { pluginEventBus } from "./plugin/PluginEventBus";
/**
 * 插件管理器
 * 
 * 优化：
 * 1. 支持插件依赖管理
 * 2. 支持插件优先级控制
 * 3. 支持插件生命周期管理
 * 4. 支持插件热插拔（动态加载/卸载）
 */ export class PluginManager {
    /**
   * 注册插件
   * 
   * 优化：检查插件依赖是否已注册
   */ register(plugin) {
        if (this.plugins.has(plugin.name)) {
            console.warn(`插件 ${plugin.name} 已存在，将被覆盖`);
        }
        // 检查依赖是否已注册
        if (plugin.dependencies && plugin.dependencies.length > 0) {
            const missingDeps = plugin.dependencies.filter((dep)=>!this.plugins.has(dep));
            if (missingDeps.length > 0) {
                console.warn(`插件 ${plugin.name} 的依赖未注册: ${missingDeps.join(', ')}`);
            }
        }
        this.plugins.set(plugin.name, plugin);
        this.pluginStatus.set(plugin.name, 'registered');
        // 创建插件沙箱
        if (plugin.sandbox) {
            const sandbox = new PluginSandbox({
                ...plugin.sandbox,
                name: plugin.name
            });
            this.sandboxes.set(plugin.name, sandbox);
        } else {
            // 如果没有配置沙箱，创建默认沙箱（非严格模式）
            const sandbox = new PluginSandbox({
                strictMode: false,
                name: plugin.name
            });
            this.sandboxes.set(plugin.name, sandbox);
        }
    }
    /**
   * 获取插件加载顺序（考虑依赖和优先级）
   * 
   * @returns 插件名称数组，按加载顺序排列
   */ getLoadOrder() {
        const plugins = Array.from(this.plugins.values());
        // 按优先级排序
        const sortedPlugins = plugins.sort((a, b)=>{
            const priorityA = a.priority ?? 100;
            const priorityB = b.priority ?? 100;
            return priorityA - priorityB;
        });
        // 构建依赖图并拓扑排序
        const visited = new Set();
        const visiting = new Set();
        const result = [];
        const visit = (pluginName)=>{
            if (visiting.has(pluginName)) {
                console.warn(`检测到循环依赖，涉及插件: ${pluginName}`);
                return;
            }
            if (visited.has(pluginName)) {
                return;
            }
            visiting.add(pluginName);
            const plugin = this.plugins.get(pluginName);
            if (plugin?.dependencies) {
                for (const dep of plugin.dependencies){
                    visit(dep);
                }
            }
            visiting.delete(pluginName);
            visited.add(pluginName);
            result.push(pluginName);
        };
        for (const plugin of sortedPlugins){
            visit(plugin.name);
        }
        return result;
    }
    /**
   * 注销插件
   */ unregister(name) {
        const plugin = this.plugins.get(name);
        if (plugin && plugin.destroy) {
            plugin.destroy();
        }
        this.plugins.delete(name);
        this.sandboxes.delete(name);
        this.pluginStatus.delete(name);
        this.pluginLoaders.delete(name);
    }
    /**
   * 动态加载插件（热插拔）
   * 
   * @param options - 插件加载选项
   * @returns 加载的插件
   */ async loadPlugin(options) {
        let plugin;
        if (options.url) {
            // 从URL加载插件
            const response = await fetch(options.url);
            if (!response.ok) {
                throw new Error(`无法加载插件: ${options.url} (${response.status})`);
            }
            const pluginModule = await response.json();
            plugin = pluginModule.default || pluginModule;
        } else if (options.modulePath) {
            // 从模块路径动态导入
            const pluginModule = await import(options.modulePath);
            plugin = pluginModule.default || pluginModule;
        } else {
            throw new Error('必须提供 url 或 modulePath');
        }
        if (!plugin || !plugin.name) {
            throw new Error('插件格式无效：必须包含 name 属性');
        }
        // 检查插件是否已加载
        if (this.plugins.has(plugin.name)) {
            throw new Error(`插件 ${plugin.name} 已加载`);
        }
        // 设置加载状态
        this.pluginStatus.set(plugin.name, 'loading');
        try {
            // 注册插件
            this.register(plugin);
            // 如果要求立即初始化
            if (options.initialize && options.initContext && options.startOptions) {
                await this.initializePlugin(plugin.name, options.startOptions, options.initContext);
            }
            return plugin;
        } catch (error) {
            this.pluginStatus.delete(plugin.name);
            throw error;
        }
    }
    /**
   * 初始化单个插件
   * 
   * @param name - 插件名称
   * @param options - 启动选项
   * @param context - 初始化上下文
   */ async initializePlugin(name, options, context) {
        const plugin = this.plugins.get(name);
        if (!plugin) {
            throw new Error(`插件 ${name} 未注册`);
        }
        const status = this.pluginStatus.get(name);
        if (status === 'initialized') {
            return; // 已经初始化
        }
        try {
            const sandbox = this.sandboxes.get(name);
            if (!sandbox) {
                throw new Error(`插件 ${name} 的沙箱未找到`);
            }
            // 执行初始化钩子
            if (plugin.init) {
                const filteredOptions = sandbox.filterConfig(options);
                await plugin.init(filteredOptions, context, sandbox, pluginEventBus);
            }
            this.pluginStatus.set(name, 'initialized');
        } catch (error) {
            console.error(`插件 ${name} 初始化失败:`, error);
            throw error;
        }
    }
    /**
   * 卸载插件（热插拔）
   * 
   * @param name - 插件名称
   * @param force - 是否强制卸载（即使有依赖）
   */ async unloadPlugin(name, force = false) {
        const plugin = this.plugins.get(name);
        if (!plugin) {
            throw new Error(`插件 ${name} 未加载`);
        }
        // 检查是否有其他插件依赖此插件
        if (!force) {
            const dependents = Array.from(this.plugins.values()).filter((p)=>p.dependencies && p.dependencies.includes(name));
            if (dependents.length > 0) {
                throw new Error(`无法卸载插件 ${name}，以下插件依赖它: ${dependents.map((p)=>p.name).join(', ')}`);
            }
        }
        // 执行销毁钩子
        if (plugin.destroy) {
            try {
                await plugin.destroy();
            } catch (error) {
                console.error(`插件 ${name} 的 destroy 钩子执行失败:`, error);
            }
        }
        // 从事件总线移除相关监听器（如果有）
        // 注意：事件总线是全局的，这里只移除插件相关的事件
        // 实际实现可能需要更细粒度的控制
        // 清理插件
        this.unregister(name);
        this.pluginStatus.set(name, 'destroyed');
    }
    /**
   * 检查插件是否可以热加载
   * 
   * @param plugin - 插件
   * @returns 是否可以热加载
   */ canHotLoad(plugin) {
        // 检查依赖是否都已加载
        if (plugin.dependencies && plugin.dependencies.length > 0) {
            const missingDeps = plugin.dependencies.filter((dep)=>!this.plugins.has(dep));
            if (missingDeps.length > 0) {
                return false;
            }
        }
        return true;
    }
    /**
   * 注册插件加载器（用于延迟加载）
   * 
   * @param name - 插件名称
   * @param loader - 加载器函数
   */ registerLoader(name, loader) {
        this.pluginLoaders.set(name, loader);
    }
    /**
   * 使用加载器加载插件
   * 
   * @param name - 插件名称
   * @param options - 加载选项
   * @returns 加载的插件
   */ async loadPluginByLoader(name, options) {
        const loader = this.pluginLoaders.get(name);
        if (!loader) {
            throw new Error(`插件 ${name} 的加载器未注册`);
        }
        const plugin = await loader();
        if (!plugin || !plugin.name) {
            throw new Error('插件格式无效：必须包含 name 属性');
        }
        if (plugin.name !== name) {
            throw new Error(`插件名称不匹配: 期望 ${name}，实际 ${plugin.name}`);
        }
        // 检查插件是否已加载
        if (this.plugins.has(plugin.name)) {
            return this.plugins.get(plugin.name);
        }
        // 设置加载状态
        this.pluginStatus.set(plugin.name, 'loading');
        try {
            // 注册插件
            this.register(plugin);
            // 如果要求立即初始化
            if (options?.initialize && options.initContext && options.startOptions) {
                await this.initializePlugin(plugin.name, options.startOptions, options.initContext);
            }
            return plugin;
        } catch (error) {
            this.pluginStatus.delete(plugin.name);
            throw error;
        }
    }
    /**
   * 获取插件
   */ get(name) {
        return this.plugins.get(name);
    }
    /**
   * 获取所有插件
   */ getAll() {
        return Array.from(this.plugins.values());
    }
    /**
   * 执行初始化前钩子
   * 
   * 优化：按依赖顺序执行
   */ async executeBeforeInit(options) {
        const loadOrder = this.getLoadOrder();
        for (const pluginName of loadOrder){
            const plugin = this.plugins.get(pluginName);
            if (!plugin || !plugin.beforeInit) {
                continue;
            }
            try {
                const sandbox = this.sandboxes.get(plugin.name);
                if (!sandbox) {
                    console.warn(`插件 ${plugin.name} 的沙箱未找到`);
                    continue;
                }
                // 根据沙箱配置过滤选项
                const filteredOptions = sandbox.filterConfig(options);
                await plugin.beforeInit(filteredOptions, sandbox, pluginEventBus);
            } catch (error) {
                console.error(`插件 ${plugin.name} 的 beforeInit 钩子执行失败:`, error);
            }
        }
    }
    /**
   * 执行初始化钩子
   * 
   * 优化：按依赖顺序执行，并更新插件状态
   */ async executeInit(options, context) {
        const loadOrder = this.getLoadOrder();
        for (const pluginName of loadOrder){
            const plugin = this.plugins.get(pluginName);
            if (!plugin || !plugin.init) {
                continue;
            }
            try {
                const sandbox = this.sandboxes.get(plugin.name);
                if (!sandbox) {
                    console.warn(`插件 ${plugin.name} 的沙箱未找到`);
                    continue;
                }
                // 根据沙箱配置过滤选项
                const filteredOptions = sandbox.filterConfig(options);
                await plugin.init(filteredOptions, context, sandbox, pluginEventBus);
                this.pluginStatus.set(plugin.name, 'initialized');
            } catch (error) {
                console.error(`插件 ${plugin.name} 的 init 钩子执行失败:`, error);
            }
        }
    }
    /**
   * 执行初始化后钩子
   * 
   * 优化：按依赖顺序执行（逆序，确保依赖插件先执行）
   */ async executeAfterInit(options, context) {
        const loadOrder = this.getLoadOrder();
        // 逆序执行，确保依赖插件先执行
        const reverseOrder = [
            ...loadOrder
        ].reverse();
        for (const pluginName of reverseOrder){
            const plugin = this.plugins.get(pluginName);
            if (!plugin || !plugin.afterInit) {
                continue;
            }
            try {
                const sandbox = this.sandboxes.get(plugin.name);
                if (!sandbox) {
                    console.warn(`插件 ${plugin.name} 的沙箱未找到`);
                    continue;
                }
                // 根据沙箱配置过滤选项
                const filteredOptions = sandbox.filterConfig(options);
                await plugin.afterInit(filteredOptions, context, sandbox, pluginEventBus);
            } catch (error) {
                console.error(`插件 ${plugin.name} 的 afterInit 钩子执行失败:`, error);
            }
        }
    }
    /**
   * 获取插件状态
   * 
   * @param name - 插件名称
   * @returns 插件状态
   */ getPluginStatus(name) {
        return this.pluginStatus.get(name);
    }
    /**
   * 检查插件是否已加载
   * 
   * @param name - 插件名称
   * @returns 是否已加载
   */ isLoaded(name) {
        return this.plugins.has(name);
    }
    /**
   * 获取已加载的插件列表
   * 
   * @returns 插件名称数组
   */ getLoadedPlugins() {
        return Array.from(this.plugins.keys());
    }
    /**
   * 获取所有插件状态
   * 
   * @returns 插件状态映射
   */ getAllPluginStatus() {
        return new Map(this.pluginStatus);
    }
    /**
   * 获取插件沙箱
   * 
   * @param name - 插件名称
   * @returns 插件沙箱或undefined
   */ getSandbox(name) {
        return this.sandboxes.get(name);
    }
    /**
   * 获取事件总线
   */ getEventBus() {
        return pluginEventBus;
    }
    /**
   * 销毁所有插件
   */ async destroyAll() {
        for (const plugin of this.plugins.values()){
            if (plugin.destroy) {
                try {
                    await plugin.destroy();
                } catch (error) {
                    console.error(`插件 ${plugin.name} 的 destroy 钩子执行失败:`, error);
                }
            }
        }
        this.plugins.clear();
    }
    constructor(){
        _define_property(this, "plugins", new Map());
        _define_property(this, "sandboxes", new Map());
        _define_property(this, "pluginStatus", new Map());
        _define_property(this, "pluginLoaders", new Map());
    }
}
/**
 * 默认插件管理器
 */ export const pluginManager = new PluginManager();
// 导出插件相关类型和工具
export { PluginSandbox, PluginPermission } from "./plugin/PluginSandbox";
export { PluginEventBus, pluginEventBus } from "./plugin/PluginEventBus";

//# sourceMappingURL=plugin.js.map