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 RouteVersionManager {
    /**
   * 注册路由版本
   * 
   * @param version - 版本信息
   */ registerVersion(version) {
        // 验证版本号格式（简单的语义化版本检查）
        if (!/^\d+\.\d+\.\d+/.test(version.version)) {
            throw new Error(`无效的版本号格式: ${version.version}`);
        }
        this.versions.set(version.version, {
            ...version,
            createdAt: version.createdAt || Date.now()
        });
        logger.debug(`路由版本已注册: ${version.version}`);
    }
    /**
   * 注册版本迁移函数
   * 
   * @param fromVersion - 源版本
   * @param toVersion - 目标版本
   * @param migration - 迁移函数
   */ registerMigration(fromVersion, toVersion, migration) {
        const key = `${fromVersion}->${toVersion}`;
        this.migrations.set(key, migration);
        logger.debug(`路由版本迁移已注册: ${key}`);
    }
    /**
   * 检查版本兼容性
   * 
   * @param version - 要检查的版本
   * @returns 是否兼容
   */ checkCompatibility(version) {
        const versionInfo = this.versions.get(version);
        if (!versionInfo) {
            return false;
        }
        // 如果明确标记为不兼容，返回 false
        if (versionInfo.compatible === false) {
            return false;
        }
        // 简单的版本兼容性检查（主版本号相同）
        const currentMajor = parseInt(this.config.currentVersion.split('.')[0]);
        const targetMajor = parseInt(version.split('.')[0]);
        return currentMajor === targetMajor;
    }
    /**
   * 迁移路由配置
   * 
   * @param fromVersion - 源版本
   * @param toVersion - 目标版本
   * @param routes - 路由配置
   * @returns 迁移后的路由配置
   */ async migrate(fromVersion, toVersion, routes) {
        if (fromVersion === toVersion) {
            return routes;
        }
        const migrationKey = `${fromVersion}->${toVersion}`;
        const migration = this.migrations.get(migrationKey);
        if (!migration) {
            // 如果没有直接迁移，尝试逐步迁移
            return this.migrateStepwise(fromVersion, toVersion, routes);
        }
        try {
            const migratedRoutes = await migration(fromVersion, toVersion, routes);
            logger.info(`路由版本迁移完成: ${fromVersion} -> ${toVersion}`);
            return migratedRoutes;
        } catch (error) {
            logger.error(`路由版本迁移失败: ${fromVersion} -> ${toVersion}`, error);
            const errorContext = {
                fromVersion,
                toVersion
            };
            if (error instanceof Error) {
                errorContext.originalError = error;
            }
            throw new RouterError(`路由版本迁移失败: ${fromVersion} -> ${toVersion}`, RouterErrorCode.ROUTE_TRANSFORM_FAILED, undefined, error instanceof Error ? error : undefined, errorContext);
        }
    }
    /**
   * 逐步迁移（通过中间版本）
   */ async migrateStepwise(fromVersion, toVersion, routes) {
        // 获取所有版本并按版本号排序
        const allVersions = Array.from(this.versions.keys()).sort((a, b)=>{
            const aParts = a.split('.').map(Number);
            const bParts = b.split('.').map(Number);
            for(let i = 0; i < 3; i++){
                if (aParts[i] !== bParts[i]) {
                    return aParts[i] - bParts[i];
                }
            }
            return 0;
        });
        // 找到从 fromVersion 到 toVersion 的路径
        const fromIndex = allVersions.indexOf(fromVersion);
        const toIndex = allVersions.indexOf(toVersion);
        if (fromIndex === -1 || toIndex === -1) {
            throw new Error(`无法找到版本迁移路径: ${fromVersion} -> ${toVersion}`);
        }
        let currentRoutes = routes;
        const step = fromIndex < toIndex ? 1 : -1;
        for(let i = fromIndex; i !== toIndex; i += step){
            const currentVersion = allVersions[i];
            const nextVersion = allVersions[i + step];
            const migrationKey = `${currentVersion}->${nextVersion}`;
            const migration = this.migrations.get(migrationKey);
            if (migration) {
                currentRoutes = await migration(currentVersion, nextVersion, currentRoutes);
            } else {
                // 如果没有迁移函数，直接使用当前路由（可能不兼容）
                logger.warn(`缺少迁移函数: ${migrationKey}，跳过迁移`);
            }
        }
        return currentRoutes;
    }
    /**
   * 获取版本信息
   * 
   * @param version - 版本号
   * @returns 版本信息，如果不存在返回 undefined
   */ getVersion(version) {
        return this.versions.get(version);
    }
    /**
   * 获取所有版本
   * 
   * @returns 版本信息数组
   */ getAllVersions() {
        return Array.from(this.versions.values());
    }
    /**
   * 获取当前版本
   * 
   * @returns 当前版本信息
   */ getCurrentVersion() {
        return this.versions.get(this.config.currentVersion);
    }
    /**
   * 回滚到指定版本
   * 
   * @param version - 目标版本
   * @param routes - 当前路由配置
   * @returns 回滚后的路由配置
   */ async rollback(version, routes) {
        return this.migrate(this.config.currentVersion, version, routes);
    }
    constructor(config){
        _define_property(this, "versions", new Map());
        _define_property(this, "migrations", new Map());
        _define_property(this, "config", void 0);
        this.config = {
            enableVersionCheck: config.enableVersionCheck ?? true,
            enableAutoMigration: config.enableAutoMigration ?? false,
            currentVersion: config.currentVersion
        };
    }
}
/**
 * 获取路由版本管理器单例
 */ let versionManagerInstance = null;
export function getRouteVersionManager(config) {
    if (!versionManagerInstance && config) {
        versionManagerInstance = new RouteVersionManager(config);
    }
    if (!versionManagerInstance) {
        throw new Error('路由版本管理器未初始化，请先提供配置');
    }
    return versionManagerInstance;
}

//# sourceMappingURL=RouteVersionManager.js.map