import { InstanceContext, SnowCatCore } from 'snowcat-core';
import { SnowCatPathWrapper } from 'snowcat-common/src/path';
import { NapCatOneBot11Adapter } from 'snowcat-onebot';
import { SnowCatProtocolAdapter } from 'snowcat-protocol';

// 协议适配器类型
export type ProtocolAdapterType = 'onebot11' | 'snowcat-protocol';

// 协议适配器接口
export interface IProtocolAdapter {
  readonly name: string;
  readonly enabled: boolean;
  init (): Promise<void>;
  close (): Promise<void>;
}

// 协议适配器包装器
class OneBotAdapterWrapper implements IProtocolAdapter {
  readonly name = 'onebot11';
  private adapter: NapCatOneBot11Adapter;

  constructor (adapter: NapCatOneBot11Adapter) {
    this.adapter = adapter;
  }

  get enabled (): boolean {
    return true; // OneBot11 默认启用
  }

  async init (): Promise<void> {
    await this.adapter.InitOneBot();
  }

  async close (): Promise<void> {
    await this.adapter.networkManager.closeAllAdapters();
  }

  getAdapter (): NapCatOneBot11Adapter {
    return this.adapter;
  }
}

// NapCat Protocol 适配器包装器
class SnowCatProtocolAdapterWrapper implements IProtocolAdapter {
  readonly name = 'snowcat-protocol';
  private adapter: SnowCatProtocolAdapter;

  constructor (adapter: SnowCatProtocolAdapter) {
    this.adapter = adapter;
  }

  get enabled (): boolean {
    return this.adapter.isEnabled();
  }

  async init (): Promise<void> {
    await this.adapter.initProtocol();
  }

  async close (): Promise<void> {
    await this.adapter.close();
  }

  getAdapter (): SnowCatProtocolAdapter {
    return this.adapter;
  }
}

// 协议适配器管理器
export class SnowCatAdapterManager {
  private core: SnowCatCore;
  private context: InstanceContext;
  private pathWrapper: SnowCatPathWrapper;

  // 协议适配器实例
  private onebotAdapter: OneBotAdapterWrapper | null = null;
  private snowcatProtocolAdapter: SnowCatProtocolAdapterWrapper | null = null;

  // 所有已注册的适配器
  private adapters: Map<string, IProtocolAdapter> = new Map();

  constructor (core: SnowCatCore, context: InstanceContext, pathWrapper: SnowCatPathWrapper) {
    this.core = core;
    this.context = context;
    this.pathWrapper = pathWrapper;
  }

  // 初始化所有协议适配器
  async initAdapters (): Promise<void> {
    this.context.logger.log('[AdapterManager] 开始初始化协议适配器...');

    // 初始化 OneBot11 适配器 (默认启用)
    try {
      const onebot = new NapCatOneBot11Adapter(this.core, this.context, this.pathWrapper);
      this.onebotAdapter = new OneBotAdapterWrapper(onebot);
      this.adapters.set('onebot11', this.onebotAdapter);
      await this.onebotAdapter.init();
      this.context.logger.log('[AdapterManager] OneBot11 适配器初始化完成');
    } catch (e) {
      this.context.logger.logError('[AdapterManager] OneBot11 适配器初始化失败:', e);
    }

    // 初始化 NapCat Protocol 适配器 (默认关闭，需要配置启用)
    try {
      const snowcatProtocol = new SnowCatProtocolAdapter(this.core, this.context, this.pathWrapper);
      this.snowcatProtocolAdapter = new SnowCatProtocolAdapterWrapper(snowcatProtocol);
      this.adapters.set('snowcat-protocol', this.snowcatProtocolAdapter);

      if (this.snowcatProtocolAdapter.enabled) {
        await this.snowcatProtocolAdapter.init();
        this.context.logger.log('[AdapterManager] SnowCat Protocol 适配器初始化完成');
      } else {
        this.context.logger.log('[AdapterManager] SnowCat Protocol 适配器未启用，跳过初始化');
      }
    } catch (e) {
      this.context.logger.logError('[AdapterManager] SnowCat Protocol 适配器初始化失败:', e);
    }

    this.context.logger.log(`[AdapterManager] 协议适配器初始化完成，已加载 ${this.adapters.size} 个适配器`);
  }

  // 获取 OneBot11 适配器
  getOneBotAdapter (): NapCatOneBot11Adapter | null {
    return this.onebotAdapter?.getAdapter() ?? null;
  }

  // 获取 NapCat Protocol 适配器
  getNapCatProtocolAdapter (): SnowCatProtocolAdapter | null {
    return this.snowcatProtocolAdapter?.getAdapter() ?? null;
  }

  // 获取指定适配器
  getAdapter (name: ProtocolAdapterType): IProtocolAdapter | undefined {
    return this.adapters.get(name);
  }

  // 获取所有已启用的适配器
  getEnabledAdapters (): IProtocolAdapter[] {
    return Array.from(this.adapters.values()).filter(adapter => adapter.enabled);
  }

  // 获取所有适配器
  getAllAdapters (): IProtocolAdapter[] {
    return Array.from(this.adapters.values());
  }

  // 关闭所有适配器
  async closeAllAdapters (): Promise<void> {
    this.context.logger.log('[AdapterManager] 开始关闭所有协议适配器...');

    for (const [name, adapter] of this.adapters) {
      try {
        await adapter.close();
        this.context.logger.log(`[AdapterManager] ${name} 适配器已关闭`);
      } catch (e) {
        this.context.logger.logError(`[AdapterManager] 关闭 ${name} 适配器失败:`, e);
      }
    }

    this.adapters.clear();
    this.context.logger.log('[AdapterManager] 所有协议适配器已关闭');
  }

  // 重新加载指定适配器
  async reloadAdapter (name: ProtocolAdapterType): Promise<void> {
    const adapter = this.adapters.get(name);
    if (adapter) {
      await adapter.close();
      await adapter.init();
      this.context.logger.log(`[AdapterManager] ${name} 适配器已重新加载`);
    }
  }
}

export { NapCatOneBot11Adapter } from 'snowcat-onebot';
export { SnowCatProtocolAdapter } from 'snowcat-protocol';