/**
 * Terminal 实例管理器（单例模式）
 * 职责：管理所有 Terminal 实例的生命周期，确保同一 Tab 复用同一实例
 * 同时管理连接策略的创建，确保每个 Tab 有独立的连接策略
 */

import { TerminalInstance, TerminalInstanceCreateConfig } from './TerminalInstance';
import { SSHConnectionStrategy } from '../strategies/SSHConnectionStrategy';
import type { BaseConnectionStrategy } from '../strategies/BaseConnectionStrategy';

/**
 * Terminal 实例管理器
 * 使用单例模式确保全局只有一个管理器实例
 */
export class TerminalInstanceManager {
    private static instance: TerminalInstanceManager | null = null;
    private instances: Map<string, TerminalInstance> = new Map();
    private connectionStrategies: Map<string, BaseConnectionStrategy> = new Map();

    private constructor() {
    }

    /**
     * 获取管理器单例
     */
    static getInstance(): TerminalInstanceManager {
        if (!TerminalInstanceManager.instance) {
            TerminalInstanceManager.instance = new TerminalInstanceManager();
        }
        return TerminalInstanceManager.instance;
    }

    /**
     * 获取或创建 Terminal 实例
     * @param tabId Tab 的唯一标识
     * @param config Terminal 创建配置（包含连接配置）
     * @returns Terminal 实例
     */
    getOrCreate(tabId: string, config: TerminalInstanceCreateConfig): TerminalInstance {
        // 如果实例已存在，直接返回
        if (this.instances.has(tabId)) {
            return this.instances.get(tabId)!;
        }

        // 创建连接策略（每个 Tab 独立的策略）
        const connectionStrategy = this.createConnectionStrategy(config.connectionConfig);
        this.connectionStrategies.set(tabId, connectionStrategy);

        // 创建新实例
        const instance = new TerminalInstance({
            id: config.id,
            connection: connectionStrategy,
            display: config.display,
        });
        this.instances.set(tabId, instance);
        
        return instance;
    }

    /**
     * 根据连接配置创建对应的连接策略
     */
    private createConnectionStrategy(config: any): BaseConnectionStrategy {
        switch (config.type) {
            case 'ssh':
                return new SSHConnectionStrategy({
                    type: 'ssh',
                    serverId: config.serverId,
                    token: config.token,
                    autoReconnect: config.autoReconnect,
                    reconnectInterval: config.reconnectInterval,
                    maxReconnectAttempts: config.maxReconnectAttempts,
                });
            // 未来可以添加其他类型：k8s, docker 等
            default:
                throw new Error(`Unsupported connection type: ${config.type}`);
        }
    }

    /**
     * 获取指定 Tab 的 Terminal 实例
     * @param tabId Tab 的唯一标识
     * @returns Terminal 实例，如果不存在则返回 undefined
     */
    get(tabId: string): TerminalInstance | undefined {
        return this.instances.get(tabId);
    }

    /**
     * 检查实例是否存在
     * @param tabId Tab 的唯一标识
     * @returns 是否存在
     */
    has(tabId: string): boolean {
        return this.instances.has(tabId);
    }

    /**
     * 销毁指定 Tab 的 Terminal 实例
     * @param tabId Tab 的唯一标识
     */
    destroy(tabId: string): void {
        const instance = this.instances.get(tabId);
        if (instance) {
                instance.dispose();
            this.instances.delete(tabId);
        }
        
        // 同时销毁连接策略
        const strategy = this.connectionStrategies.get(tabId);
        if (strategy && 'dispose' in strategy) {
            (strategy as any).dispose();
        }
        this.connectionStrategies.delete(tabId);
    }

    /**
     * 销毁所有实例（通常用于应用卸载时）
     */
    destroyAll(): void {
        this.instances.forEach((instance) => {
            instance.dispose();
        });
        this.instances.clear();
        
        // 销毁所有连接策略
        this.connectionStrategies.forEach((strategy) => {
            if ('dispose' in strategy) {
                (strategy as any).dispose();
            }
        });
        this.connectionStrategies.clear();
    }

    /**
     * 获取当前实例数量
     */
    getCount(): number {
        return this.instances.size;
    }

    /**
     * 获取所有实例的 Tab ID 列表
     */
    getAllTabIds(): string[] {
        return Array.from(this.instances.keys());
    }
}
