/**
 * 埋点功能测试脚本
 * 用于验证埋点管理器的各项功能是否正常工作
 */

import { _decorator, Component, Node, Label, Button } from 'cc';
import { Analytics } from './AnalyticsManager';
import { MPLifecycle } from './MPLifecycleManager';

const { ccclass, property } = _decorator;

@ccclass('AnalyticsTest')
export class AnalyticsTest extends Component {
    @property(Label)
    statusLabel: Label = null;

    @property(Button)
    testButton: Button = null;

    private testResults: string[] = [];

    start() {
        this.updateStatus('埋点测试准备就绪');
        
        if (this.testButton) {
            this.testButton.node.on('click', this.runAllTests, this);
        }
    }

    /**
     * 运行所有测试
     */
    public runAllTests(): void {
        this.testResults = [];
        this.updateStatus('开始运行埋点测试...');

        // 测试基础埋点功能
        this.testBasicTracking();
        
        // 测试小程序生命周期事件
        this.testMPLifecycleEvents();
        
        // 测试场景加载事件
        this.testSceneLoadEvents();
        
        // 测试游戏进度事件
        this.testGameProgressEvents();
        
        // 显示测试结果
        this.showTestResults();
    }

    /**
     * 测试基础埋点功能
     */
    private testBasicTracking(): void {
        try {
            // 测试自定义事件
            Analytics.track('test_custom_event', {
                test_property: 'test_value',
                test_number: 123,
                test_boolean: true
            });
            
            this.addTestResult('✅ 基础埋点功能测试通过');
        } catch (error) {
            this.addTestResult('❌ 基础埋点功能测试失败: ' + error.message);
        }
    }

    /**
     * 测试小程序生命周期事件
     */
    private testMPLifecycleEvents(): void {
        try {
            // 测试启动事件
            Analytics.trackMPLaunch({
                scene: 1001,
                query: '{"test": "value"}',
                shareTicket: 'test_ticket'
            });
            
            // 测试显示事件
            Analytics.trackMPShow({
                scene: 1001,
                query: '{"test": "value"}'
            });
            
            // 测试隐藏事件
            Analytics.trackMPHide();
            
            this.addTestResult('✅ 小程序生命周期事件测试通过');
        } catch (error) {
            this.addTestResult('❌ 小程序生命周期事件测试失败: ' + error.message);
        }
    }

    /**
     * 测试场景加载事件
     */
    private testSceneLoadEvents(): void {
        try {
            // 测试场景加载开始
            Analytics.trackSceneLoadStart('TestScene');
            
            // 模拟加载时间
            setTimeout(() => {
                // 测试场景加载成功
                Analytics.trackSceneLoaded({
                    scene_name: 'TestScene',
                    load_time: 1500,
                    success: true
                });
                
                // 测试场景加载失败
                Analytics.trackSceneLoaded({
                    scene_name: 'FailedScene',
                    load_time: 3000,
                    success: false,
                    error_msg: 'Scene not found'
                });
                
                // 测试场景卸载
                Analytics.trackSceneUnloaded('TestScene');
            }, 100);
            
            this.addTestResult('✅ 场景加载事件测试通过');
        } catch (error) {
            this.addTestResult('❌ 场景加载事件测试失败: ' + error.message);
        }
    }

    /**
     * 测试游戏进度事件
     */
    private testGameProgressEvents(): void {
        try {
            // 测试完成关卡
            Analytics.trackCompleteSection({
                level: 5,
                score: 8500,
                time_spent: 120,
                result: 'success'
            });
            
            // 测试等级提升
            Analytics.trackUpdateLevel(4, 5);
            
            // 测试新手引导
            Analytics.trackTutorialStart();
            
            setTimeout(() => {
                Analytics.trackTutorialFinish(300);
            }, 50);
            
            this.addTestResult('✅ 游戏进度事件测试通过');
        } catch (error) {
            this.addTestResult('❌ 游戏进度事件测试失败: ' + error.message);
        }
    }

    /**
     * 测试小程序生命周期管理器
     */
    private testMPLifecycleManager(): void {
        try {
            // 测试手动触发显示事件
            MPLifecycle.triggerShow({
                scene: 1001,
                query: '{"manual": "test"}'
            });
            
            // 测试手动触发隐藏事件
            MPLifecycle.triggerHide();
            
            // 测试获取会话时长
            const sessionDuration = MPLifecycle.getSessionDuration();
            console.log('[AnalyticsTest] 当前会话时长:', sessionDuration);
            
            this.addTestResult('✅ 小程序生命周期管理器测试通过');
        } catch (error) {
            this.addTestResult('❌ 小程序生命周期管理器测试失败: ' + error.message);
        }
    }

    /**
     * 添加测试结果
     */
    private addTestResult(result: string): void {
        this.testResults.push(result);
        console.log('[AnalyticsTest]', result);
    }

    /**
     * 显示测试结果
     */
    private showTestResults(): void {
        const summary = this.testResults.join('\n');
        const passedCount = this.testResults.filter(r => r.indexOf('✅') !== -1).length;
        const failedCount = this.testResults.filter(r => r.indexOf('❌') !== -1).length;
        
        const finalStatus = `埋点测试完成\n通过: ${passedCount} 项\n失败: ${failedCount} 项\n\n${summary}`;
        
        this.updateStatus(finalStatus);
        
        console.log('[AnalyticsTest] 测试完成');
        console.log('[AnalyticsTest] 通过:', passedCount, '项');
        console.log('[AnalyticsTest] 失败:', failedCount, '项');
    }

    /**
     * 更新状态显示
     */
    private updateStatus(status: string): void {
        if (this.statusLabel) {
            this.statusLabel.string = status;
        }
        console.log('[AnalyticsTest]', status);
    }

    /**
     * 单独测试某个功能（供外部调用）
     */
    public testSpecificFeature(featureName: string): void {
        switch (featureName) {
            case 'basic':
                this.testBasicTracking();
                break;
            case 'lifecycle':
                this.testMPLifecycleEvents();
                break;
            case 'scene':
                this.testSceneLoadEvents();
                break;
            case 'progress':
                this.testGameProgressEvents();
                break;
            case 'manager':
                this.testMPLifecycleManager();
                break;
            default:
                console.warn('[AnalyticsTest] 未知的测试功能:', featureName);
        }
    }
}

// 导出测试工具函数，供控制台调用
(window as any).testAnalytics = {
    // 快速测试所有功能
    runAll: () => {
        const testComponent = new AnalyticsTest();
        testComponent.runAllTests();
    },
    
    // 测试特定功能
    test: (feature: string) => {
        const testComponent = new AnalyticsTest();
        testComponent.testSpecificFeature(feature);
    },
    
    // 手动发送测试事件
    sendTestEvent: (eventName: string, properties: any = {}) => {
        Analytics.track(eventName, properties);
    },
    
    // 获取会话时长
    getSessionDuration: () => {
        return MPLifecycle.getSessionDuration();
    }
};