import { invoke } from '@tauri-apps/api/core';
import { SettingsService } from './SettingsService';
import { LogLevel } from '@esengine/ecs-framework';

export interface SystemPerformanceData {
  name: string;
  executionTime: number;
  entityCount: number;
  averageTime: number;
  percentage: number;
}

export interface RemoteEntity {
  id: number;
  name: string;
  enabled: boolean;
  active: boolean;
  activeInHierarchy: boolean;
  componentCount: number;
  componentTypes: string[];
  parentId: number | null;
  childIds: number[];
  depth: number;
  tag: number;
  updateOrder: number;
}

export interface RemoteComponentDetail {
  typeName: string;
  properties: Record<string, any>;
}

export interface RemoteEntityDetails {
  id: number;
  name: string;
  enabled: boolean;
  active: boolean;
  activeInHierarchy: boolean;
  scene: string;
  sceneName: string;
  sceneType: string;
  componentCount: number;
  componentTypes: string[];
  components: RemoteComponentDetail[];
  parentName: string | null;
}

export interface ProfilerData {
  totalFrameTime: number;
  systems: SystemPerformanceData[];
  entityCount: number;
  componentCount: number;
  fps: number;
  entities?: RemoteEntity[];
}

type ProfilerDataListener = (data: ProfilerData) => void;

export class ProfilerService {
  private ws: WebSocket | null = null;
  private isServerRunning = false;
  private wsPort: string;
  private listeners: Set<ProfilerDataListener> = new Set();
  private currentData: ProfilerData | null = null;
  private checkServerInterval: NodeJS.Timeout | null = null;
  private reconnectTimeout: NodeJS.Timeout | null = null;
  private clientIdMap: Map<string, string> = new Map(); // 客户端地址 -> 客户端ID映射
  private autoStart: boolean;

  constructor() {
    const settings = SettingsService.getInstance();
    this.wsPort = settings.get('profiler.port', '8080');
    this.autoStart = settings.get('profiler.autoStart', true);

    this.startServerCheck();
    this.listenToSettingsChanges();

    // 如果设置了自动启动，则启动服务器
    if (this.autoStart) {
      this.manualStartServer();
    }
  }

  private listenToSettingsChanges(): void {
    window.addEventListener('settings:changed', ((event: CustomEvent) => {
      const newPort = event.detail['profiler.port'];
      if (newPort && newPort !== this.wsPort) {
        this.wsPort = newPort;
        this.reconnectWithNewPort();
      }
    }) as EventListener);
  }

  private async reconnectWithNewPort(): Promise<void> {
    this.disconnect();

    if (this.checkServerInterval) {
      clearInterval(this.checkServerInterval);
      this.checkServerInterval = null;
    }

    try {
      await invoke('stop_profiler_server');
      this.isServerRunning = false;
    } catch (error) {
      console.error('[ProfilerService] Failed to stop server:', error);
    }

    this.startServerCheck();
  }

  public subscribe(listener: ProfilerDataListener): () => void {
    this.listeners.add(listener);

    // 如果已有数据，立即发送给新订阅者
    if (this.currentData) {
      listener(this.currentData);
    }

    return () => {
      this.listeners.delete(listener);
    };
  }

  public isConnected(): boolean {
    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
  }

  public isServerActive(): boolean {
    return this.isServerRunning;
  }

  /**
   * 手动启动服务器
   */
  public async manualStartServer(): Promise<void> {
    await this.startServer();
  }

  /**
   * 手动停止服务器
   */
  public async manualStopServer(): Promise<void> {
    try {
      await invoke('stop_profiler_server');
      this.isServerRunning = false;
      this.disconnect();
    } catch (error) {
      console.error('[ProfilerService] Failed to stop server:', error);
    }
  }

  private startServerCheck(): void {
    this.checkServerStatus();
    this.checkServerInterval = setInterval(() => {
      this.checkServerStatus();
    }, 2000);
  }

  private async checkServerStatus(): Promise<void> {
    try {
      const status = await invoke<boolean>('get_profiler_status');
      const wasRunning = this.isServerRunning;
      this.isServerRunning = status;

      // 服务器启动了，尝试连接
      if (status && !this.ws) {
        this.connectToServer();
      }

      // 服务器从运行变为停止
      if (wasRunning && !status) {
        this.disconnect();
      }
    } catch (error) {
      this.isServerRunning = false;
    }
  }

  private async startServer(): Promise<void> {
    try {
      const port = parseInt(this.wsPort);
      await invoke<string>('start_profiler_server', { port });
      this.isServerRunning = true;
    } catch (error) {
      console.error('[ProfilerService] Failed to start server:', error);
    }
  }

  private connectToServer(): void {
    if (this.ws) return;

    try {
      const ws = new WebSocket(`ws://localhost:${this.wsPort}`);

      ws.onopen = () => {
        this.notifyListeners(this.createEmptyData());
      };

      ws.onclose = () => {
        this.ws = null;

        // 通知监听器连接已断开
        if (this.currentData) {
          this.notifyListeners(this.currentData);
        }

        // 如果服务器还在运行，尝试重连
        if (this.isServerRunning && !this.reconnectTimeout) {
          this.reconnectTimeout = setTimeout(() => {
            this.reconnectTimeout = null;
            this.connectToServer();
          }, 3000);
        }
      };

      ws.onerror = (error) => {
        console.error('[ProfilerService] WebSocket error:', error);
        this.ws = null;

        // 通知监听器连接出错
        if (this.currentData) {
          this.notifyListeners(this.currentData);
        }
      };

      ws.onmessage = (event) => {
        try {
          const message = JSON.parse(event.data);
          if (message.type === 'debug_data' && message.data) {
            this.handleDebugData(message.data);
          } else if (message.type === 'get_raw_entity_list_response' && message.data) {
            this.handleRawEntityListResponse(message.data);
          } else if (message.type === 'get_entity_details_response' && message.data) {
            this.handleEntityDetailsResponse(message.data);
          } else if (message.type === 'log' && message.data) {
            this.handleRemoteLog(message.data);
          }
        } catch (error) {
          console.error('[ProfilerService] Failed to parse message:', error);
        }
      };

      this.ws = ws;
    } catch (error) {
      console.error('[ProfilerService] Failed to create WebSocket:', error);
    }
  }

  public requestEntityDetails(entityId: number): void {
    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
      return;
    }

    try {
      const request = {
        type: 'get_entity_details',
        requestId: `entity_details_${entityId}_${Date.now()}`,
        entityId
      };
      this.ws.send(JSON.stringify(request));
    } catch (error) {
      console.error('[ProfilerService] Failed to request entity details:', error);
    }
  }

  private handleDebugData(debugData: any): void {
    const performance = debugData.performance;
    if (!performance) return;

    const totalFrameTime = performance.frameTime || 0;
    const fps = totalFrameTime > 0 ? Math.round(1000 / totalFrameTime) : 0;

    let systems: SystemPerformanceData[] = [];
    if (performance.systemPerformance && Array.isArray(performance.systemPerformance)) {
      systems = performance.systemPerformance
        .map((sys: any) => ({
          name: sys.systemName,
          executionTime: sys.lastExecutionTime || sys.averageTime || 0,
          entityCount: sys.entityCount || 0,
          averageTime: sys.averageTime || 0,
          percentage: 0
        }))
        .sort((a: SystemPerformanceData, b: SystemPerformanceData) =>
          b.executionTime - a.executionTime
        );

      const totalTime = performance.frameTime || 1;
      systems.forEach((sys: SystemPerformanceData) => {
        sys.percentage = (sys.executionTime / totalTime) * 100;
      });
    }

    const entityCount = debugData.entities?.totalEntities || debugData.entities?.totalCount || 0;
    const componentTypes = debugData.components?.types || [];
    const componentCount = componentTypes.length;

    this.currentData = {
      totalFrameTime,
      systems,
      entityCount,
      componentCount,
      fps,
      entities: []
    };

    this.notifyListeners(this.currentData);

    // 请求完整的实体列表
    this.requestRawEntityList();
  }

  private requestRawEntityList(): void {
    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
      return;
    }

    try {
      const request = {
        type: 'get_raw_entity_list',
        requestId: `entity_list_${Date.now()}`
      };
      this.ws.send(JSON.stringify(request));
    } catch (error) {
      console.error('[ProfilerService] Failed to request entity list:', error);
    }
  }

  private handleRawEntityListResponse(data: any): void {
    if (!data || !Array.isArray(data)) {
      return;
    }

    const entities: RemoteEntity[] = data.map((e: any) => ({
      id: e.id,
      name: e.name || `Entity ${e.id}`,
      enabled: e.enabled !== false,
      active: e.active !== false,
      activeInHierarchy: e.activeInHierarchy !== false,
      componentCount: e.componentCount || 0,
      componentTypes: e.componentTypes || [],
      parentId: e.parentId || null,
      childIds: e.childIds || [],
      depth: e.depth || 0,
      tag: e.tag || 0,
      updateOrder: e.updateOrder || 0
    }));

    if (this.currentData) {
      this.currentData.entities = entities;
      this.notifyListeners(this.currentData);
    }
  }

  private handleEntityDetailsResponse(data: any): void {
    if (!data) {
      return;
    }

    const entityDetails: RemoteEntityDetails = {
      id: data.id,
      name: data.name || `Entity ${data.id}`,
      enabled: data.enabled !== false,
      active: data.active !== false,
      activeInHierarchy: data.activeInHierarchy !== false,
      scene: data.scene || '',
      sceneName: data.sceneName || '',
      sceneType: data.sceneType || '',
      componentCount: data.componentCount || 0,
      componentTypes: data.componentTypes || [],
      components: data.components || [],
      parentName: data.parentName || null
    };

    window.dispatchEvent(new CustomEvent('profiler:entity-details', {
      detail: entityDetails
    }));
  }

  private handleRemoteLog(data: any): void {
    if (!data) {
      return;
    }

    const levelMap: Record<string, LogLevel> = {
      'debug': LogLevel.Debug,
      'info': LogLevel.Info,
      'warn': LogLevel.Warn,
      'error': LogLevel.Error,
      'fatal': LogLevel.Fatal
    };

    const level = levelMap[data.level?.toLowerCase() || 'info'] || LogLevel.Info;

    let message = data.message || '';
    if (typeof message === 'object') {
      try {
        message = JSON.stringify(message, null, 2);
      } catch {
        message = String(message);
      }
    }

    const clientId = data.clientId || data.client_id || 'unknown';

    window.dispatchEvent(new CustomEvent('profiler:remote-log', {
      detail: {
        level,
        message,
        timestamp: data.timestamp ? new Date(data.timestamp) : new Date(),
        clientId
      }
    }));
  }

  private createEmptyData(): ProfilerData {
    return {
      totalFrameTime: 0,
      systems: [],
      entityCount: 0,
      componentCount: 0,
      fps: 0
    };
  }

  private notifyListeners(data: ProfilerData): void {
    this.listeners.forEach(listener => {
      try {
        listener(data);
      } catch (error) {
        console.error('[ProfilerService] Error in listener:', error);
      }
    });
  }

  private disconnect(): void {
    const hadConnection = this.ws !== null;

    if (this.ws) {
      this.ws.close();
      this.ws = null;
    }

    if (this.reconnectTimeout) {
      clearTimeout(this.reconnectTimeout);
      this.reconnectTimeout = null;
    }

    // 如果有连接且手动断开，通知监听器
    if (hadConnection && this.currentData) {
      this.notifyListeners(this.currentData);
    }
  }

  public destroy(): void {
    this.disconnect();

    if (this.checkServerInterval) {
      clearInterval(this.checkServerInterval);
      this.checkServerInterval = null;
    }

    this.listeners.clear();
    this.currentData = null;
  }
}