import { _decorator, Component, Node, director, assetManager, ProgressBar, Label, Sprite, SpriteFrame, resources } from 'cc';
import { Analytics } from './Utils/AnalyticsManager';
import { MPLifecycle } from './Utils/MPLifecycleManager';
import './Utils/BlockMergeTrackingTest';
const { ccclass, property } = _decorator;

// 微信小游戏API类型声明
declare global {
    interface Window {
        wx?: {
            loadSubpackage?: (options: {
                name: string;
                success?: () => void;
                fail?: (err: any) => void;
            }) => any;
            getLaunchOptionsSync?: () => any;
            onShow?: (callback: (options: any) => void) => void;
            onHide?: (callback: () => void) => void;
        };
    }
    const wx: {
        loadSubpackage?: (options: {
            name: string;
            success?: () => void;
            fail?: (err: any) => void;
        }) => any;
        getLaunchOptionsSync?: () => any;
        onShow?: (callback: (options: any) => void) => void;
        onHide?: (callback: () => void) => void;
    } | undefined;
}

@ccclass('LaunchScreen')
export class LaunchScreen extends Component {
    @property(ProgressBar)
    progressBar: ProgressBar = null;

    @property(Label)
    progressLabel: Label = null;

    @property(Sprite)
    backgroundSprite: Sprite = null;

    @property(SpriteFrame)
    launchBackground: SpriteFrame = null;

    private totalAssets = 0;
    private loadedAssets = 0;
    private sceneLoadStartTime = 0;
    private launchOptions: any = {};

    start() {
        console.log('[LaunchScreen] 启动页开始初始化');
        
        // 初始化埋点管理器
        Analytics.init();
        
        // 初始化小程序生命周期管理器
        MPLifecycle.init();
        
        // 注册与登录埋点
        this.setupAuthTracking();

        // 追踪小程序启动事件
        this.trackMPLaunch();
        
        // 设置启动页背景
        this.setupBackground();
        
        // 开始预加载游戏资源
        this.preloadGameAssets();
    }

    /**
     * 设置启动页背景
     */
    private setupBackground() {
        if (this.backgroundSprite && this.launchBackground) {
            this.backgroundSprite.spriteFrame = this.launchBackground;
            console.log('[LaunchScreen] 启动页背景设置完成');
        }
    }

    /**
     * 预加载游戏资源
     */
    private async preloadGameAssets() {
        try {
            console.log('[LaunchScreen] 开始预加载游戏资源');
            
            // 更新进度显示
            this.updateProgress(0, '正在加载游戏资源...');

            // 直接预加载GameLevel场景（不使用分包）
            await this.preloadGameLevelScene();
            
            // 预加载完成，跳转到游戏场景
            this.loadGameScene();
            
        } catch (error) {
            console.error('[LaunchScreen] 资源预加载失败:', error);
            this.updateProgress(0, '资源加载失败，请重试');
        }
    }

    /**
     * 直接预加载GameLevel场景
     */
    private preloadGameLevelScene(): Promise<void> {
        return new Promise<void>((resolve, reject) => {
            console.log('[LaunchScreen] 开始预加载GameLevel场景');
            
            // 追踪场景加载开始事件
            this.sceneLoadStartTime = Date.now();
            Analytics.trackSceneLoadStart('GameLevel');
            
            // 直接预加载场景
            director.preloadScene('GameLevel', (finished: number, total: number) => {
                const progress = finished / total;
                this.updateProgress(progress * 100, `正在加载游戏场景... ${Math.floor(progress * 100)}%`);
            }, (err) => {
                const loadTime = Date.now() - this.sceneLoadStartTime;
                
                if (err) {
                    console.error('[LaunchScreen] GameLevel场景预加载失败:', err);
                    
                    // 追踪场景加载失败事件
                    Analytics.trackSceneLoaded({
                        scene_name: 'GameLevel',
                        load_time: loadTime,
                        success: false,
                        error_msg: err.toString()
                    });
                    
                    // 预加载失败时，仍然尝试直接跳转（可能场景存在但预加载失败）
                    console.log('[LaunchScreen] 预加载失败，但仍将尝试直接加载场景');
                    this.updateProgress(100, '准备进入游戏...');
                    resolve();
                    return;
                }
                
                console.log('[LaunchScreen] GameLevel场景预加载完成');
                
                // 追踪场景加载成功事件
                Analytics.trackSceneLoaded({
                    scene_name: 'GameLevel',
                    load_time: loadTime,
                    success: true
                });
                
                this.updateProgress(100, '加载完成！');
                resolve();
            });
        });
    }
    
    /**
     * 更新加载进度
     */
    private updateProgress(progress: number, message: string) {
        if (this.progressBar) {
            this.progressBar.progress = progress / 100;
        }
        
        if (this.progressLabel) {
            this.progressLabel.string = message;
        }
        
        console.log(`[LaunchScreen] ${message} (${progress.toFixed(1)}%)`);
    }

    /**
     * 跳转到游戏场景
     */
    private loadGameScene() {
        console.log('[LaunchScreen] 准备跳转到GameLevel场景');
        
        // 延迟一秒后跳转，让用户看到加载完成的提示
        this.scheduleOnce(() => {
            // 直接加载GameLevel场景
            director.loadScene('GameLevel', (err) => {
                if (err) {
                    console.error('[LaunchScreen] GameLevel场景加载失败:', err);
                    console.log('[LaunchScreen] 尝试降级方案：停留在启动页面');
                    this.updateProgress(0, 'GameLevel场景不存在，请检查场景配置');
                    
                    // 提供重试按钮或其他交互方式
                    this.scheduleOnce(() => {
                        this.updateProgress(0, '点击屏幕重试或检查场景配置');
                    }, 2.0);
                    return;
                }
                
                console.log('[LaunchScreen] 成功切换到GameLevel场景');
            });
        }, 1.0);
    }

    // ==================== 埋点相关方法 ====================

    /**
     * 追踪小程序启动事件
     */
    private trackMPLaunch(): void {
        // 使用已获取的启动参数
        const opts = this.launchOptions || {};

        Analytics.trackMPLaunch({
            scene: opts.scene || 0,
            query: JSON.stringify(opts.query || {}),
            shareTicket: opts.shareTicket || '',
            referrerInfo: opts.referrerInfo || {}
        });

        // 检测是否通过分享启动，如果是则追踪分享事件
        if (opts.shareTicket) {
            this.trackMPShareFromLaunch(opts);
        }
    }

    /**
     * 追踪通过分享启动的事件
     */
    private trackMPShareFromLaunch(launchOptions: any): void {
        try {
            Analytics.trackMPShare({
                share_type: 'launch_from_share', // 分享类型：从分享启动
                share_target: 'unknown', // 分享目标：未知（启动时无法确定）
                share_content: launchOptions.shareTicket || '', // 分享内容：shareTicket
                share_time: Date.now(), // 分享时间戳
                scene: launchOptions.scene || 0, // 启动场景
                query: JSON.stringify(launchOptions.query || {}) // 启动参数
            });
            console.log('[LaunchScreen] $MPShare 事件已上报（从分享启动）:', launchOptions);
        } catch (error) {
            console.error('[LaunchScreen] 追踪分享启动事件时出错:', error);
        }
    }

    /**
     * 设置注册/登录/登出/创建角色埋点
     */
    private setupAuthTracking(): void {
        // 获取并缓存启动参数（微信小游戏环境）
        if (typeof wx !== 'undefined' && wx.getLaunchOptionsSync) {
            try {
                this.launchOptions = wx.getLaunchOptionsSync() || {};
            } catch (error) {
                console.warn('[LaunchScreen] 获取启动参数失败:', error);
                this.launchOptions = {};
            }
        }

        const sceneVal = this.launchOptions?.scene || 0;
        const queryStr = JSON.stringify(this.launchOptions?.query || {});

        // 首次注册（本地标记判断）
        try {
            const firstFlag = localStorage.getItem('first_register_tracked');
            if (!firstFlag) {
                Analytics.trackUserFirstRegister({
                    register_time: Date.now(),
                    channel: typeof wx !== 'undefined' ? 'wechat_game' : 'web',
                    scene: sceneVal,
                    query: queryStr
                });

                // 小程序注册事件（首次）
                Analytics.trackMPRegister({
                    register_time: Date.now(),
                    scene: sceneVal,
                    query: queryStr
                });

                // 创建角色（首次运行时认为创建默认角色）
                this.trackInitialRoleCreate();

                localStorage.setItem('first_register_tracked', '1');
            }
        } catch (e) {
            console.warn('[LaunchScreen] 处理首次注册标记失败:', e);
        }

        // 小程序登录事件（每次启动）
        Analytics.trackMPLogin({
            login_time: Date.now(),
            scene: sceneVal,
            query: queryStr
        });

        // 小程序登出事件（监听 onHide）
        if (typeof wx !== 'undefined' && wx.onHide) {
            try {
                wx.onHide(() => {
                    Analytics.trackMPLogout({
                        logout_time: Date.now(),
                        scene: sceneVal
                    });
                });
            } catch (error) {
                console.warn('[LaunchScreen] 注册 onHide 失败:', error);
            }
        }
    }

    /**
     * 首次运行时创建默认角色并上报
     */
    private trackInitialRoleCreate(): void {
        try {
            const roleFlag = localStorage.getItem('default_role_created');
            if (!roleFlag) {
                Analytics.trackCreateRole({
                    role_id: 'default_player',
                    role_name: 'Player',
                    role_class: 'starter',
                    create_time: Date.now(),
                    user_level: 1
                });
                localStorage.setItem('default_role_created', '1');
                console.log('[LaunchScreen] $CreateRole 事件已上报（默认角色创建）');
            }
        } catch (e) {
            console.warn('[LaunchScreen] 创建默认角色标记失败:', e);
        }
    }

    /**
     * 组件销毁时的清理工作
     */
    onDestroy(): void {
        // 追踪场景卸载事件
        Analytics.trackSceneUnloaded('LaunchScreen');
    }
}