import { 
    IECSDebugConfig, 
    IECSDebugData, 
    IEntityDebugData, 
    ISystemDebugData, 
    IPerformanceDebugData, 
    IComponentDebugData, 
    ISceneDebugData 
} from '../types';
import { Core } from '../Core';
import { Time } from './Time';

/**
 * ECS调试报告器 - WebSocket模式
 * 
 * 负责收集ECS框架的运行时调试数据并通过WebSocket发送到调试服务器
 */
export class DebugReporter {
    private config: IECSDebugConfig;
    private core: Core;
    private timer?: any;
    private ws?: WebSocket;
    private lastFrameTime: number = 0;
    private frameCount: number = 0;
    private lastFpsTime: number = 0;
    private fps: number = 0;
    private sceneStartTime: number = 0;
    private isConnected: boolean = false;
    private reconnectAttempts: number = 0;
    private maxReconnectAttempts: number = 5;
    private frameTimeHistory: number[] = [];
    private maxHistoryLength: number = 60; // 保存60帧的历史数据

    /**
     * 构造函数
     * @param core Core实例
     * @param config 调试配置
     */
    constructor(core: Core, config: IECSDebugConfig) {
        this.core = core;
        this.config = config;
        this.sceneStartTime = Date.now();
        
        // 确保性能监控器在调试模式下被启用
        if (this.config.enabled && this.config.channels.performance) {
            if (!this.core._performanceMonitor.isEnabled) {
                this.core._performanceMonitor.enable();
                console.log('[ECS Debug] Performance monitor enabled for debugging');
            }
        }
        
        if (this.config.enabled) {
            this.start();
        }
    }

    /**
     * 启动调试报告器
     */
    private start(): void {
        this.connectWebSocket();
    }

    /**
     * 停止调试报告器
     */
    public stop(): void {
        if (this.timer) {
            clearInterval(this.timer);
            this.timer = null;
        }

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

        this.isConnected = false;
    }

    /**
     * 更新配置
     * @param newConfig 新配置
     */
    public updateConfig(newConfig: IECSDebugConfig): void {
        const wasEnabled = this.config.enabled;
        const urlChanged = this.config.websocketUrl !== newConfig.websocketUrl;
        
        this.config = newConfig;

        // 根据配置启用或禁用性能监控器
        if (newConfig.enabled && newConfig.channels.performance) {
            if (!this.core._performanceMonitor.isEnabled) {
                this.core._performanceMonitor.enable();
                console.log('[ECS Debug] Performance monitor enabled for debugging');
            }
        }

        if (!newConfig.enabled && wasEnabled) {
            this.stop();
        } else if (newConfig.enabled && (!wasEnabled || urlChanged)) {
            this.stop();
            this.start();
        }
    }

    /**
     * 连接WebSocket
     */
    private connectWebSocket(): void {
        if (!this.config.websocketUrl) {
            console.error('[ECS Debug] WebSocket URL not provided');
            return;
        }

        try {
            this.ws = new WebSocket(this.config.websocketUrl);
            
            this.ws.onopen = () => {
                this.isConnected = true;
                this.reconnectAttempts = 0;
                this.startDataStream();
                
                // 发送初始化消息
                this.send({
                    type: 'init',
                    data: {
                        frameworkVersion: this.getFrameworkVersion(),
                        timestamp: Date.now()
                    }
                });
            };

            this.ws.onmessage = (event) => {
                try {
                    const message = JSON.parse(event.data);
                    this.handleMessage(message);
                } catch (error) {
                    console.error('[ECS Debug] Failed to parse message:', error);
                }
            };

            this.ws.onclose = (event) => {
                this.isConnected = false;
                
                if (this.timer) {
                    clearInterval(this.timer);
                    this.timer = null;
                }

                // 自动重连
                if (this.config.autoReconnect !== false && this.reconnectAttempts < this.maxReconnectAttempts) {
                    this.reconnectAttempts++;
                    const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts - 1), 10000);
                    setTimeout(() => this.connectWebSocket(), delay);
                }
            };

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

    /**
     * 启动数据流
     */
    private startDataStream(): void {
        const interval = this.config.updateInterval || 1000;

        this.timer = setInterval(() => {
            if (this.isConnected) {
                try {
                    const data = this.collectDebugData();
                    this.send({ type: 'debug_data', data });
                } catch (error) {
                    console.error('[ECS Debug] Failed to send debug data:', error);
                }
            }
        }, interval);
    }

    /**
     * 发送消息
     */
    private send(message: any): void {
        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
            this.ws.send(JSON.stringify(message));
        }
    }

    /**
     * 处理接收到的消息
     * @param message 消息内容
     */
    private handleMessage(message: any): void {
        switch (message.type) {
            case 'get_debug_data':
                const data = this.collectDebugData();
                this.send({ type: 'debug_data_response', data, requestId: message.requestId });
                break;
                
            case 'update_config':
                if (message.config) {
                    this.updateConfig(message.config);
                    this.send({ type: 'config_updated', success: true });
                }
                break;
                
            case 'ping':
                this.send({ type: 'pong', timestamp: Date.now() });
                break;
                
            default:
                console.warn('[ECS Debug] Unknown message type:', message.type);
        }
    }

    /**
     * 收集调试数据
     * @returns 调试数据对象
     */
    private collectDebugData(): IECSDebugData {
        const currentTime = Date.now();
        
        // 更新FPS计算
        this.updateFPS(currentTime);

        const data: IECSDebugData = {
            timestamp: currentTime,
            frameworkVersion: this.getFrameworkVersion(),
            isRunning: true,
            frameworkLoaded: true,
            currentScene: this.getCurrentSceneName()
        };

        // 根据配置收集不同类型的数据
        if (this.config.channels.entities) {
            data.entities = this.collectEntityData();
        }

        if (this.config.channels.systems) {
            data.systems = this.collectSystemData();
        }

        if (this.config.channels.performance) {
            data.performance = this.collectPerformanceData();
        }

        if (this.config.channels.components) {
            data.components = this.collectComponentData();
        }

        if (this.config.channels.scenes) {
            data.scenes = this.collectSceneData();
        }

        return data;
    }

    /**
     * 更新FPS计算
     */
    private updateFPS(currentTime: number): void {
        this.frameCount++;
        
        if (currentTime - this.lastFpsTime >= 1000) {
            this.fps = this.frameCount;
            this.frameCount = 0;
            this.lastFpsTime = currentTime;
        }
    }

    /**
     * 获取框架版本
     */
    private getFrameworkVersion(): string {
        return '1.0.0';
    }

    /**
     * 获取当前场景名称
     */
    private getCurrentSceneName(): string {
        const scene = Core.scene;
        return scene ? (scene as any).name || 'Unnamed Scene' : 'No Scene';
    }

    /**
     * 收集实体数据
     */
    private collectEntityData(): IEntityDebugData {
        const scene = Core.scene;
        if (!scene) {
            return {
                totalEntities: 0,
                activeEntities: 0,
                pendingAdd: 0,
                pendingRemove: 0,
                entitiesPerArchetype: [],
                topEntitiesByComponents: []
            };
        }

        const entityList = (scene as any).entities;
        if (!entityList) {
            return {
                totalEntities: 0,
                activeEntities: 0,
                pendingAdd: 0,
                pendingRemove: 0,
                entitiesPerArchetype: [],
                topEntitiesByComponents: []
            };
        }

        const allEntities = entityList.buffer || [];
        const activeEntities = allEntities.filter((e: any) => e.enabled && !e._isDestroyed);
        
        return {
            totalEntities: allEntities.length,
            activeEntities: activeEntities.length,
            pendingAdd: entityList.toAdd?.length || 0,
            pendingRemove: entityList.toRemove?.length || 0,
            entitiesPerArchetype: this.getArchetypeDistribution({ entities: allEntities }),
            topEntitiesByComponents: this.getTopEntitiesByComponents({ entities: allEntities }),
            entityDetails: this.getEntityDetails({ entities: allEntities })
        };
    }

    /**
     * 获取实体详情
     */
    private getEntityDetails(entityContainer: any): Array<any> {
        if (!entityContainer.entities) return [];

        return entityContainer.entities.slice(0, 100).map((entity: any) => ({
            id: entity.id,
            name: entity.name || `Entity_${entity.id}`,
            tag: entity.tag,
            enabled: entity.enabled,
            componentCount: entity.components?.length || 0,
            components: entity.components?.map((c: any) => c.constructor.name) || []
        }));
    }

    /**
     * 收集系统数据
     */
    private collectSystemData(): ISystemDebugData {
        const scene = Core.scene;
        if (!scene) {
            return {
                totalSystems: 0,
                systemsInfo: []
            };
        }

        const entityProcessors = (scene as any).entityProcessors;
        if (!entityProcessors) {
            return {
                totalSystems: 0,
                systemsInfo: []
            };
        }

        const systems = entityProcessors.processors || [];
        
        // 获取性能监控数据
        const monitor = this.core._performanceMonitor;
        let systemStats: Map<string, any> = new Map();
        let systemData: Map<string, any> = new Map();
        
        if (monitor) {
            try {
                systemStats = monitor.getAllSystemStats();
                systemData = monitor.getAllSystemData();
            } catch (error) {
                // 忽略错误，使用空的Map
            }
        }
        
        return {
            totalSystems: systems.length,
            systemsInfo: systems.map((system: any) => {
                const systemName = system.systemName || system.constructor.name;
                const stats = systemStats.get(systemName);
                const data = systemData.get(systemName);
                
                return {
                    name: systemName,
                    type: system.constructor.name,
                    entityCount: system.entities?.length || 0,
                    executionTime: stats?.averageTime || data?.executionTime || 0,
                    minExecutionTime: stats?.minTime === Number.MAX_VALUE ? 0 : (stats?.minTime || 0),
                    maxExecutionTime: stats?.maxTime || 0,
                    executionTimeHistory: stats?.recentTimes || [],
                    updateOrder: system.updateOrder || 0,
                    enabled: system.enabled !== false,
                    lastUpdateTime: data?.lastUpdateTime || 0
                };
            })
        };
    }

    /**
     * 收集性能数据
     */
    private collectPerformanceData(): IPerformanceDebugData {
        const frameTimeSeconds = Time.deltaTime;
        const engineFrameTimeMs = frameTimeSeconds * 1000;
        const currentFps = frameTimeSeconds > 0 ? Math.round(1 / frameTimeSeconds) : 0;
        
        const ecsPerformanceData = this.getECSPerformanceData();
        const ecsExecutionTimeMs = ecsPerformanceData.totalExecutionTime;
        const ecsPercentage = engineFrameTimeMs > 0 ? (ecsExecutionTimeMs / engineFrameTimeMs * 100) : 0;
        
        let memoryUsage = 0;
        if ((performance as any).memory) {
            memoryUsage = (performance as any).memory.usedJSHeapSize / 1024 / 1024;
        }

        // 更新ECS执行时间历史记录
        this.frameTimeHistory.push(ecsExecutionTimeMs);
        if (this.frameTimeHistory.length > this.maxHistoryLength) {
            this.frameTimeHistory.shift();
        }
        
        // 计算ECS执行时间统计
        const history = this.frameTimeHistory.filter(t => t >= 0);
        const averageECSTime = history.length > 0 ? history.reduce((a, b) => a + b, 0) / history.length : ecsExecutionTimeMs;
        const minECSTime = history.length > 0 ? Math.min(...history) : ecsExecutionTimeMs;
        const maxECSTime = history.length > 0 ? Math.max(...history) : ecsExecutionTimeMs;

        return {
            frameTime: ecsExecutionTimeMs,
            engineFrameTime: engineFrameTimeMs,
            ecsPercentage: ecsPercentage,
            memoryUsage: memoryUsage,
            fps: currentFps,
            averageFrameTime: averageECSTime, // ECS平均执行时间
            minFrameTime: minECSTime, // ECS最短执行时间
            maxFrameTime: maxECSTime, // ECS最长执行时间
            frameTimeHistory: [...this.frameTimeHistory],
            systemPerformance: this.getSystemPerformance(),
            systemBreakdown: ecsPerformanceData.systemBreakdown,
            memoryDetails: this.getMemoryDetails()
        };
    }

    /**
     * 获取ECS框架整体性能数据
     */
    private getECSPerformanceData(): { totalExecutionTime: number; systemBreakdown: Array<any> } {
        const monitor = this.core._performanceMonitor;
        if (!monitor) {
            console.warn('[ECS Debug] Performance monitor not found');
            return { totalExecutionTime: 0, systemBreakdown: [] };
        }

        if (!monitor.isEnabled) {
            console.warn('[ECS Debug] Performance monitor is disabled. Enable it to see ECS performance data.');
            // 尝试启用性能监控器
            monitor.enable();
            return { totalExecutionTime: 0, systemBreakdown: [] };
        }

        try {
            let totalTime = 0;
            const systemBreakdown = [];
            
            const stats = monitor.getAllSystemStats();
            
            if (stats.size === 0) {
                console.log('[ECS Debug] No system performance data available yet. This is normal on first frames.');
                return { totalExecutionTime: 0, systemBreakdown: [] };
            }
            
            // 计算各系统的执行时间
            for (const [systemName, stat] of stats.entries()) {
                const systemTime = stat.averageTime || 0;
                
                totalTime += systemTime;
                systemBreakdown.push({
                    systemName: systemName,
                    executionTime: systemTime,
                    percentage: 0 // 后面计算
                });
            }
            
            // 计算各系统占ECS总时间的百分比
            systemBreakdown.forEach(system => {
                system.percentage = totalTime > 0 ? (system.executionTime / totalTime * 100) : 0;
            });
            
            // 按执行时间排序
            systemBreakdown.sort((a, b) => b.executionTime - a.executionTime);
            
            console.log(`[ECS Debug] Performance data: ${stats.size} systems, total time: ${totalTime.toFixed(2)}ms`);
            
            return {
                totalExecutionTime: totalTime,
                systemBreakdown: systemBreakdown
            };
        } catch (error) {
            console.error('[ECS Debug] Error getting ECS performance data:', error);
            return { totalExecutionTime: 0, systemBreakdown: [] };
        }
    }

    /**
     * 获取系统性能数据
     */
    private getSystemPerformance(): Array<any> {
        const monitor = this.core._performanceMonitor;
        if (!monitor) {
            return [];
        }

        try {
            const stats = monitor.getAllSystemStats();
            const systemData = monitor.getAllSystemData();
            
            return Array.from(stats.entries()).map(([systemName, stat]) => {
                const data = systemData.get(systemName);
                return {
                    systemName: systemName,
                    averageTime: stat.averageTime,
                    maxTime: stat.maxTime,
                    minTime: stat.minTime === Number.MAX_VALUE ? 0 : stat.minTime,
                    samples: stat.executionCount,
                    percentage: 0, // 在getECSPerformanceData中计算
                    entityCount: data?.entityCount || 0,
                    lastExecutionTime: data?.executionTime || 0
                };
            });
        } catch (error) {
            return [];
        }
    }

    /**
     * 获取内存详情
     */
    private getMemoryDetails(): any {
        const scene = Core.scene;
        if (!scene) {
            return {
                entities: 0,
                components: 0,
                systems: 0,
                pooled: 0,
                totalMemory: 0,
                usedMemory: 0,
                freeMemory: 0,
                gcCollections: 0
            };
        }

        try {
            let entityMemory = 0;
            let componentMemory = 0;
            let systemMemory = 0;
            let pooledMemory = 0;

            const entityManager = (scene as any).entityManager;
            if (entityManager?.entities) {
                // 计算实体和组件内存
                entityManager.entities.forEach((entity: any) => {
                    entityMemory += this.estimateObjectSize(entity);
                    
                    if (entity.components) {
                        entity.components.forEach((component: any) => {
                            componentMemory += this.estimateObjectSize(component);
                        });
                    }
                });
            } else {
                // 如果entityManager不存在，尝试从场景直接获取
                const entityList = (scene as any).entities;
                if (entityList?.buffer) {
                    entityList.buffer.forEach((entity: any) => {
                        entityMemory += this.estimateObjectSize(entity);
                        
                        if (entity.components) {
                            entity.components.forEach((component: any) => {
                                componentMemory += this.estimateObjectSize(component);
                            });
                        }
                    });
                }
            }

            // 计算系统内存
            const entitySystems = (scene as any).entitySystems;
            if (entitySystems?.systems) {
                entitySystems.systems.forEach((system: any) => {
                    systemMemory += this.estimateObjectSize(system);
                });
            } else {
                // 尝试从entityProcessors获取
                const entityProcessors = (scene as any).entityProcessors;
                if (entityProcessors?.processors) {
                    entityProcessors.processors.forEach((system: any) => {
                        systemMemory += this.estimateObjectSize(system);
                    });
                }
            }

            // 计算对象池内存
            try {
                const { ComponentPoolManager } = require('../ECS/Core/ComponentPool');
                const poolManager = ComponentPoolManager.getInstance();
                const poolStats = poolManager.getPoolStats();
                
                for (const [typeName, stats] of poolStats.entries()) {
                    // 估算每个组件实例的大小
                    const estimatedComponentSize = this.calculateComponentMemorySize(typeName);
                    pooledMemory += stats.available * estimatedComponentSize;
                }
            } catch (error) {
                // 如果无法访问ComponentPoolManager，使用估算值
                pooledMemory = 512 * 1024; // 512KB估算值
            }

            // 获取浏览器内存信息
            let totalMemory = 512 * 1024 * 1024;
            let usedMemory = entityMemory + componentMemory + systemMemory + pooledMemory;
            let gcCollections = 0;

            if ((performance as any).memory) {
                const perfMemory = (performance as any).memory;
                totalMemory = perfMemory.jsHeapSizeLimit || totalMemory;
                usedMemory = perfMemory.usedJSHeapSize || usedMemory;
            }

            return {
                entities: entityMemory,
                components: componentMemory,
                systems: systemMemory,
                pooled: pooledMemory,
                totalMemory: totalMemory,
                usedMemory: usedMemory,
                freeMemory: totalMemory - usedMemory,
                gcCollections: gcCollections
            };
        } catch (error) {
            return {
                entities: 0,
                components: 0,
                systems: 0,
                pooled: 0,
                totalMemory: 512 * 1024 * 1024,
                usedMemory: 0,
                freeMemory: 512 * 1024 * 1024,
                gcCollections: 0
            };
        }
    }

    /**
     * 收集组件数据
     */
    private collectComponentData(): IComponentDebugData {
        const scene = Core.scene;
        if (!scene) {
            return {
                componentTypes: 0,
                componentInstances: 0,
                componentStats: []
            };
        }

        const entityList = (scene as any).entities;
        if (!entityList?.buffer) {
            return {
                componentTypes: 0,
                componentInstances: 0,
                componentStats: []
            };
        }

        const componentStats = new Map<string, { count: number; entities: number }>();
        let totalInstances = 0;

        entityList.buffer.forEach((entity: any) => {
            if (entity.components) {
                entity.components.forEach((component: any) => {
                    const typeName = component.constructor.name;
                    const stats = componentStats.get(typeName) || { count: 0, entities: 0 };
                    stats.count++;
                    totalInstances++;
                    componentStats.set(typeName, stats);
                });
            }
        });

        // 获取池利用率信息
        let poolUtilizations = new Map<string, number>();
        let poolSizes = new Map<string, number>();
        
        try {
            const { ComponentPoolManager } = require('../ECS/Core/ComponentPool');
            const poolManager = ComponentPoolManager.getInstance();
            const poolStats = poolManager.getPoolStats();
            const utilizations = poolManager.getPoolUtilization();
            
            for (const [typeName, stats] of poolStats.entries()) {
                poolSizes.set(typeName, stats.maxSize);
            }
            
            for (const [typeName, util] of utilizations.entries()) {
                poolUtilizations.set(typeName, util.utilization);
            }
        } catch (error) {
            // 如果无法获取池信息，使用默认值
        }

        return {
            componentTypes: componentStats.size,
            componentInstances: totalInstances,
            componentStats: Array.from(componentStats.entries()).map(([typeName, stats]) => {
                const poolSize = poolSizes.get(typeName) || 0;
                const poolUtilization = poolUtilizations.get(typeName) || 0;
                const memoryPerInstance = this.calculateComponentMemorySize(typeName);
                
                return {
                    typeName,
                    instanceCount: stats.count,
                    memoryPerInstance: memoryPerInstance,
                    totalMemory: stats.count * memoryPerInstance,
                    poolSize: poolSize,
                    poolUtilization: poolUtilization,
                    averagePerEntity: stats.count / entityList.buffer.length
                };
            })
        };
    }

    /**
     * 计算组件实际内存大小
     */
    private calculateComponentMemorySize(typeName: string): number {
        const scene = Core.scene;
        if (!scene) return 32;
        
        const entityList = (scene as any).entities;
        if (!entityList?.buffer) return 32;
        
        try {
            // 找到第一个包含此组件的实体，分析组件大小
            for (const entity of entityList.buffer) {
                if (entity.components) {
                    const component = entity.components.find((c: any) => c.constructor.name === typeName);
                    if (component) {
                        return this.estimateObjectSize(component);
                    }
                }
            }
        } catch (error) {
            // 忽略错误，使用默认值
        }
        
        // 如果无法计算，返回基础大小
        return 32; // 基础对象开销
    }

    /**
     * 估算对象内存大小（字节）
     */
    private estimateObjectSize(obj: any, visited = new WeakSet(), depth = 0): number {
        // 防止无限递归：限制深度和检测循环引用
        if (obj === null || obj === undefined || depth > 10) return 0;
        if (visited.has(obj)) return 0; // 已访问过，避免循环引用
        
        let size = 0;
        const type = typeof obj;
        
        switch (type) {
            case 'boolean':
                size = 1;
                break;
            case 'number':
                size = 8; // JavaScript中数字都是64位浮点数
                break;
            case 'string':
                size = Math.min(obj.length * 2, 1024); // UTF-16编码，每字符2字节，限制最大1KB
                break;
            case 'object':
                visited.add(obj); // 标记为已访问
                
                if (Array.isArray(obj)) {
                    size = 24; // 数组基础开销
                    // 只处理前100个元素，避免大数组导致性能问题
                    const maxItems = Math.min(obj.length, 100);
                    for (let i = 0; i < maxItems; i++) {
                        size += this.estimateObjectSize(obj[i], visited, depth + 1);
                    }
                } else {
                    size = 24; // 对象基础开销
                    let propertyCount = 0;
                    
                    for (const key in obj) {
                        // 只处理前50个属性，避免复杂对象导致性能问题
                        if (propertyCount >= 50) break;
                        
                        if (obj.hasOwnProperty(key)) {
                            // 跳过一些可能导致问题的属性
                            if (key === 'scene' || key === 'parent' || key === 'children' || 
                                key === '_scene' || key === '_parent' || key === '_children' ||
                                key === 'entity' || key === '_entity') {
                                continue;
                            }
                            
                            try {
                                size += key.length * 2; // 属性名
                                size += this.estimateObjectSize(obj[key], visited, depth + 1); // 属性值
                                propertyCount++;
                            } catch (error) {
                                // 忽略访问错误的属性
                                continue;
                            }
                        }
                    }
                }
                break;
            default:
                size = 8; // 其他类型默认8字节
        }
        
        return Math.min(size, 10240); // 限制单个对象最大10KB
    }

    /**
     * 收集场景数据
     */
    private collectSceneData(): ISceneDebugData {
        const scene = Core.scene;
        if (!scene) {
            return {
                currentSceneName: 'No Scene',
                isInitialized: false,
                sceneRunTime: 0,
                sceneEntityCount: 0,
                sceneSystemCount: 0,
                sceneMemory: 0,
                sceneUptime: 0
            };
        }

        const currentTime = Date.now();
        const runTime = (currentTime - this.sceneStartTime) / 1000;

        const entityList = (scene as any).entities;
        const entityProcessors = (scene as any).entityProcessors;

        return {
            currentSceneName: (scene as any).name || 'Unnamed Scene',
            isInitialized: (scene as any)._didSceneBegin || false,
            sceneRunTime: runTime,
            sceneEntityCount: entityList?.buffer?.length || 0,
            sceneSystemCount: entityProcessors?.processors?.length || 0,
            sceneMemory: 0, // TODO: 计算实际场景内存
            sceneUptime: runTime
        };
    }

    /**
     * 手动触发数据收集
     * @returns 当前调试数据
     */
    public getDebugData(): IECSDebugData {
        return this.collectDebugData();
    }

    /**
     * 重置场景时间
     */
    public onSceneChanged(): void {
        this.sceneStartTime = Date.now();
        
        // 发送场景切换事件
        if (this.isConnected) {
            this.send({
                type: 'scene_changed',
                data: {
                    sceneName: this.getCurrentSceneName(),
                    timestamp: Date.now()
                }
            });
        }
    }

    /**
     * 获取连接状态
     */
    public get connected(): boolean {
        return this.isConnected;
    }

    /**
     * 手动重连
     */
    public reconnect(): void {
        if (this.ws) {
            this.ws.close();
        }
        this.reconnectAttempts = 0;
        this.connectWebSocket();
    }

    /**
     * 获取Archetype分布
     */
    private getArchetypeDistribution(entityContainer: any): Array<{ signature: string; count: number; memory: number }> {
        if (!entityContainer.entities) return [];

        const archetypes = new Map<string, { count: number; memory: number }>();
        
        entityContainer.entities.forEach((entity: any) => {
            const components = entity.components || [];
            const signature = components.map((c: any) => c.constructor.name).sort().join(',') || 'Empty';
            
            const existing = archetypes.get(signature) || { count: 0, memory: 0 };
            existing.count++;
            
            // 计算每个组件的实际内存大小
            let entityMemory = 0;
            components.forEach((component: any) => {
                entityMemory += this.estimateObjectSize(component);
            });
            existing.memory += entityMemory;
            
            archetypes.set(signature, existing);
        });

        return Array.from(archetypes.entries())
            .map(([signature, data]) => ({ signature, ...data }))
            .sort((a: any, b: any) => b.count - a.count)
            .slice(0, 10); // 只返回前10个
    }

    /**
     * 获取组件数量最多的实体
     */
    private getTopEntitiesByComponents(entityContainer: any): Array<{ id: string; name: string; componentCount: number; memory: number }> {
        if (!entityContainer.entities) return [];

        return entityContainer.entities
            .map((entity: any) => {
                const components = entity.components || [];
                let memory = 0;
                
                // 计算实际内存使用
                components.forEach((component: any) => {
                    memory += this.estimateObjectSize(component);
                });
                
                return {
                    id: entity.id?.toString() || 'unknown',
                    name: entity.name || `Entity_${entity.id}`,
                    componentCount: components.length,
                    memory: memory
                };
            })
            .sort((a: any, b: any) => b.componentCount - a.componentCount)
            .slice(0, 10); // 只返回前10个
    }
}