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 { logger } from "../../../utils";
import { RouterError, RouterErrorCode } from "../errors";
/**
 * 路由适配器管理器
 */ export class AdapterManager {
    /**
   * 注册适配器
   * 
   * @param registration - 适配器注册信息
   * @returns 取消注册函数
   */ register(registration) {
        // 验证适配器
        if (!registration.name) {
            throw new Error('适配器必须提供名称');
        }
        if (!registration.factory || typeof registration.factory !== 'function') {
            throw new Error('适配器必须提供工厂函数');
        }
        // 设置默认值
        const adapterRegistration = {
            priority: 100,
            enabled: true,
            ...registration
        };
        // 注册适配器
        this.adapters.set(registration.name, adapterRegistration);
        logger.debug(`路由适配器已注册: ${registration.name}`);
        // 如果没有默认适配器，设置为第一个注册的适配器
        if (!this.defaultAdapterName) {
            this.defaultAdapterName = registration.name;
        }
        // 返回取消注册函数
        return ()=>{
            this.unregister(registration.name);
        };
    }
    /**
   * 批量注册适配器
   * 
   * @param registrations - 适配器注册信息数组
   */ registerBatch(registrations) {
        registrations.forEach((registration)=>this.register(registration));
    }
    /**
   * 取消注册适配器
   * 
   * @param name - 适配器名称
   */ unregister(name) {
        if (this.adapters.has(name)) {
            this.adapters.delete(name);
            logger.debug(`路由适配器已取消注册: ${name}`);
            // 如果取消的是默认适配器，重置默认适配器
            if (this.defaultAdapterName === name) {
                const firstAdapter = Array.from(this.adapters.keys())[0];
                this.defaultAdapterName = firstAdapter || null;
            }
        }
    }
    /**
   * 创建适配器实例
   * 
   * @param name - 适配器名称（可选，使用默认适配器）
   * @param config - 适配器配置
   * @returns 适配器实例
   */ async createAdapter(config, name) {
        const adapterName = name || this.defaultAdapterName;
        if (!adapterName) {
            throw new RouterError('没有可用的路由适配器', RouterErrorCode.ROUTER_NOT_INITIALIZED);
        }
        const registration = this.adapters.get(adapterName);
        if (!registration) {
            throw new RouterError(`路由适配器不存在: ${adapterName}`, RouterErrorCode.ROUTER_CONFIG_ERROR, undefined, undefined, {
                adapterName
            });
        }
        if (!registration.enabled) {
            throw new RouterError(`路由适配器已禁用: ${adapterName}`, RouterErrorCode.ROUTER_CONFIG_ERROR, undefined, undefined, {
                adapterName
            });
        }
        try {
            // 创建适配器实例
            const adapter = await registration.factory(config);
            // 验证适配器
            if (!adapter || typeof adapter.initialize !== 'function') {
                throw new Error('适配器实例无效');
            }
            // 初始化适配器
            await adapter.initialize(config);
            logger.info(`路由适配器已创建并初始化: ${adapterName}`);
            return adapter;
        } catch (error) {
            logger.error(`创建路由适配器失败: ${adapterName}`, error);
            const errorContext = {
                adapterName
            };
            if (error instanceof Error) {
                errorContext.originalError = error;
            }
            throw new RouterError(`创建路由适配器失败: ${adapterName}`, RouterErrorCode.ROUTER_CONFIG_ERROR, undefined, error instanceof Error ? error : undefined, errorContext);
        }
    }
    /**
   * 设置当前适配器
   * 
   * @param adapter - 适配器实例
   */ setCurrentAdapter(adapter) {
        // 销毁旧的适配器
        if (this.currentAdapter && this.currentAdapter.destroy) {
            try {
                this.currentAdapter.destroy();
            } catch (error) {
                logger.warn('销毁旧适配器失败', error);
            }
        }
        this.currentAdapter = adapter;
        logger.debug(`当前路由适配器已设置: ${adapter.name}`);
    }
    /**
   * 获取当前适配器
   * 
   * @returns 当前适配器实例，如果不存在返回 null
   */ getCurrentAdapter() {
        return this.currentAdapter;
    }
    /**
   * 设置默认适配器
   * 
   * @param name - 适配器名称
   */ setDefaultAdapter(name) {
        if (!this.adapters.has(name)) {
            throw new Error(`适配器不存在: ${name}`);
        }
        this.defaultAdapterName = name;
        logger.debug(`默认路由适配器已设置: ${name}`);
    }
    /**
   * 获取默认适配器名称
   * 
   * @returns 默认适配器名称
   */ getDefaultAdapterName() {
        return this.defaultAdapterName;
    }
    /**
   * 获取所有适配器
   * 
   * @returns 适配器注册信息数组
   */ getAllAdapters() {
        return Array.from(this.adapters.values());
    }
    /**
   * 获取启用的适配器
   * 
   * @returns 启用的适配器注册信息数组
   */ getEnabledAdapters() {
        return Array.from(this.adapters.values()).filter((a)=>a.enabled !== false);
    }
    /**
   * 获取适配器
   * 
   * @param name - 适配器名称
   * @returns 适配器注册信息，如果不存在返回 undefined
   */ getAdapter(name) {
        return this.adapters.get(name);
    }
    /**
   * 清空所有适配器
   */ clear() {
        // 销毁当前适配器
        if (this.currentAdapter && this.currentAdapter.destroy) {
            try {
                this.currentAdapter.destroy();
            } catch (error) {
                logger.warn('销毁适配器失败', error);
            }
        }
        this.adapters.clear();
        this.currentAdapter = null;
        this.defaultAdapterName = null;
        logger.debug('所有路由适配器已清空');
    }
    /**
   * 获取适配器数量
   * 
   * @returns 适配器数量
   */ getCount() {
        return this.adapters.size;
    }
    constructor(){
        _define_property(this, "adapters", new Map());
        _define_property(this, "currentAdapter", null);
        _define_property(this, "defaultAdapterName", null);
    }
}
/**
 * 获取路由适配器管理器单例
 */ let adapterManagerInstance = null;
export function getAdapterManager() {
    if (!adapterManagerInstance) {
        adapterManagerInstance = new AdapterManager();
    }
    return adapterManagerInstance;
}

//# sourceMappingURL=AdapterManager.js.map