import { _decorator, Component, Node, resources, sp, Asset, Button } from 'cc';
import { DataManager } from './DataManager';
import { CharacterManager } from './CharacterManager';
import { QuestionAnswerManager } from './QuestionAnswerManager';
import { AvatarManager } from './AvatarManager';
import { PassCardManager } from './PassCardManager';
import { PhoneManager } from './PhoneManager';
import { RosterManager } from './RosterManager';
import { PersonalInfoManager } from './PersonalInfoManager';
import { LieDetectorManager } from './LieDetectorManager';

const { ccclass, property } = _decorator;

@ccclass('GameFlowManager')
export class GameFlowManager extends Component {
    @property({
        type: DataManager,
        tooltip: '数据管理器引用'
    })
    dataManager: DataManager = null;

    @property({
        type: CharacterManager,
        tooltip: '角色管理器引用'
    })
    characterManager: CharacterManager = null;

    @property({
        type: QuestionAnswerManager,
        tooltip: '问答管理器引用'
    })
    questionAnswerManager: QuestionAnswerManager = null;

    @property({
        type: Button,
        tooltip: '放行按钮'
    })
    allowButton: Button = null;

    @property({
        type: Button,
        tooltip: '赶走按钮'
    })
    dismissButton: Button = null;

    @property({
        type: AvatarManager,
        tooltip: '头像管理器引用'
    })
    avatarManager: AvatarManager = null;

    @property({
        type: PassCardManager,
        tooltip: '通行证管理器引用'
    })
    passCardManager: PassCardManager = null;

    @property({
        type: PhoneManager,
        tooltip: '电话管理器引用'
    })
    phoneManager: PhoneManager = null;

    @property({
        type: RosterManager,
        tooltip: '名单管理器引用'
    })
    rosterManager: RosterManager = null;

    @property({
        type: PersonalInfoManager,
        tooltip: '个人资料管理器引用'
    })
    personalInfoManager: PersonalInfoManager = null;

    @property({
        type: LieDetectorManager,
        tooltip: '测谎仪管理器引用'
    })
    lieDetectorManager: LieDetectorManager = null;

    // 当前关卡中的NPC索引
    private currentNpcIndex: number = -1;
    
    // 当前关卡的NPC列表
    private currentNpcs: any[] = [];

    start() {
        // 初始化UI管理器
        this.initUIManagers();
        
        // 注册按钮事件
        this.registerButtonEvents();
        
        // 开始游戏流程
        this.startGameFlow();
    }

    /**
     * 初始化UI管理器
     */
    private initUIManagers(): void {
        // 检查通行证管理器是否被正确引用
        if (!this.passCardManager) {
            console.error('通行证管理器未设置');
        }
        
        // 检查电话管理器是否被正确引用
        if (!this.phoneManager) {
            console.error('电话管理器未设置');
        }
        
        // 检查名单管理器是否被正确引用
        if (!this.rosterManager) {
            console.error('名单管理器未设置');
        }
        
        // 检查个人资料管理器是否被正确引用
        if (!this.personalInfoManager) {
            console.error('个人资料管理器未设置');
        }
        
        // 检查测谎仪管理器是否被正确引用
        if (!this.lieDetectorManager) {
            console.error('测谎仪管理器未设置');
        }
        
        console.log('所有UI管理器已初始化');
    }

    /**
     * 注册按钮事件
     */
    private registerButtonEvents(): void {
        // 注册放行按钮点击事件
        if (this.allowButton) {
            this.allowButton.node.on(Button.EventType.CLICK, this.handleCharacterPassed, this);
        } else {
            console.error('放行按钮未设置');
        }
        
        // 注册赶走按钮点击事件
        if (this.dismissButton) {
            this.dismissButton.node.on(Button.EventType.CLICK, this.handleCharacterDismissed, this);
        } else {
            console.error('赶走按钮未设置');
        }
    }

    /**
     * 开始游戏流程
     */
    private startGameFlow(): void {
        // 获取当前关卡数据
        const currentLevel = this.dataManager.getCurrentLevel();
        if (!currentLevel) {
            console.error('无法获取当前关卡数据');
            return;
        }

        console.log(`开始关卡: ${currentLevel.name}`);
        
        // 获取当前关卡的NPC列表
        this.currentNpcs = currentLevel.npcs;
        
        // 重置NPC索引
        this.currentNpcIndex = -1;
        
        // 显示第一个NPC
        this.showNextNpc();
    }

    /**
     * 显示下一个NPC
     */
    public showNextNpc(): void {
        this.currentNpcIndex++;
        
        // 检查是否还有NPC
        if (this.currentNpcIndex >= this.currentNpcs.length) {
            console.log('当前关卡所有NPC已处理完毕');
            // 可以在这里添加关卡完成逻辑
            return;
        }
        
        // 获取当前NPC数据
        const npc = this.currentNpcs[this.currentNpcIndex];
        
        // 配置问答对
        this.setupQuestionAnswers(npc.qaPairs);
        
        // 如果有头像管理器，先加载头像
        if (this.avatarManager) {
            this.avatarManager.loadAvatar(npc.characterId);
        }
        
        // 配置角色外观，并在完成后让角色入场
        this.characterManager.setupCharacterAppearance(npc.characterId, npc.skinName, () => {
            // 让角色入场（只有在外观设置完成后才执行）
            this.characterManager.characterEnter();
            
            // 启用按钮
            this.enableButtons();
        });
    }

    /**
     * 启用决策按钮
     */
    private enableButtons(): void {
        if (this.allowButton) {
            this.allowButton.interactable = true;
        }
        
        if (this.dismissButton) {
            this.dismissButton.interactable = true;
        }
    }
    
    /**
     * 禁用决策按钮
     */
    private disableButtons(): void {
        if (this.allowButton) {
            this.allowButton.interactable = false;
        }
        
        if (this.dismissButton) {
            this.dismissButton.interactable = false;
        }
    }

    /**
     * 设置问答对
     * @param qaPairs 问答对数组
     */
    private setupQuestionAnswers(qaPairs: any[]): void {
        if (!this.questionAnswerManager) {
            console.error('问答管理器未设置');
            return;
        }
        
        // 替换所有问答对（而不是添加）
        this.questionAnswerManager.replaceAllQuestionAnswers(qaPairs);
    }

    /**
     * 处理放行角色
     */
    public handleCharacterPassed(): void {
        // 禁用按钮，防止连续点击
        this.disableButtons();
        
        // 让角色向右移动，动画完成后显示下一个NPC
        this.characterManager.moveCharacterRight(() => {
            this.showNextNpc();
        });
    }

    /**
     * 处理赶走角色
     */
    public handleCharacterDismissed(): void {
        // 禁用按钮，防止连续点击
        this.disableButtons();
        
        // 让角色向左移动，动画完成后显示下一个NPC
        this.characterManager.moveCharacterLeft(() => {
            this.showNextNpc();
        });
    }

    /**
     * 获取当前NPC数据
     * @returns 当前NPC数据，如果没有则返回null
     */
    public getCurrentNpcData(): any {
        if (this.currentNpcIndex < 0 || this.currentNpcIndex >= this.currentNpcs.length) {
            return null;
        }
        
        return this.currentNpcs[this.currentNpcIndex];
    }

    /**
     * 获取通行证管理器
     * @returns 通行证管理器实例
     */
    public getPassCardManager(): PassCardManager {
        return this.passCardManager;
    }

    /**
     * 获取电话管理器
     * @returns 电话管理器实例
     */
    public getPhoneManager(): PhoneManager {
        return this.phoneManager;
    }

    /**
     * 获取名单管理器
     * @returns 名单管理器实例
     */
    public getRosterManager(): RosterManager {
        return this.rosterManager;
    }
    
    /**
     * 获取个人资料管理器
     * @returns 个人资料管理器实例
     */
    public getPersonalInfoManager(): PersonalInfoManager {
        return this.personalInfoManager;
    }
    
    /**
     * 获取测谎仪管理器
     * @returns 测谎仪管理器实例
     */
    public getLieDetectorManager(): LieDetectorManager {
        return this.lieDetectorManager;
    }
    
    /**
     * 显示通行证
     * @param passData 通行证数据
     */
    public showPassCard(passData: any): void {
        if (this.passCardManager) {
            this.passCardManager.showPassCard(passData);
        } else {
            console.error('通行证管理器未设置，无法显示通行证');
        }
    }
    
    /**
     * 显示电话对话框
     */
    public showPhoneUI(): void {
        if (this.phoneManager) {
            this.phoneManager.showPhonePanel();
        } else {
            console.error('电话管理器未设置，无法显示电话UI');
        }
    }
    
    /**
     * 显示名单面板
     */
    public showRosterPanel(): void {
        if (this.rosterManager) {
            this.rosterManager.showRosterPanel();
        } else {
            console.error('名单管理器未设置，无法显示名单面板');
        }
    }

    /**
     * 获取当前关卡名单数据并显示
     */
    public showCurrentLevelRoster(): void {
        console.log("准备显示角色名单...");
        
        // 1. 从DataManager获取当前关卡数据
        const currentLevel = this.dataManager.getCurrentLevel();
        console.log("当前关卡数据:", currentLevel);
        
        if (!currentLevel || !currentLevel.npcs) {
            console.error('无法获取当前关卡数据');
            return;
        }
        
        // 2. 构建人员数据，包括完整的头像路径
        const personnelData = currentLevel.npcs.map(npc => {
            return {
                name: npc.characterName,
                avatarPath: `avatars/${npc.characterId}/avatar_${npc.characterId}_5/spriteFrame` // 第5张头像
            };
        });
        console.log("构建的人员数据:", personnelData);
        
        // 3. 调用RosterManager显示数据
        if (this.rosterManager) {
            console.log("RosterManager存在，准备显示人员列表");
            this.rosterManager.displayLevelPersonnel(personnelData);
            this.rosterManager.showRosterPanel();
        } else {
            console.error('名单管理器未设置，无法显示名单');
        }
    }

    /**
     * 显示当前NPC的个人资料
     */
    public showCurrentNpcPersonalInfo(): void {
        // 获取当前NPC数据
        const npcData = this.getCurrentNpcData();
        if (!npcData) {
            console.error('无法获取当前NPC数据');
            return;
        }
        
        // 显示个人资料
        if (this.personalInfoManager) {
            this.personalInfoManager.displayCharacterInfo({
                characterId: npcData.characterId,
                info: npcData.personal?.info || "无个人资料",
                avatarPath: `avatars/${npcData.characterId}/avatar_${npcData.characterId}_5/spriteFrame`
            });
        } else {
            console.error('个人资料管理器未设置');
        }
    }

    /**
     * 显示测谎仪面板
     */
    public showLieDetectorPanel(): void {
        // 获取当前NPC数据
        const npcData = this.getCurrentNpcData();
        if (!npcData) {
            console.error('无法获取当前NPC数据');
            return;
        }
        
        // 设置测谎仪状态并显示
        if (this.lieDetectorManager) {
            // 从NPC数据中获取是否为伪装者的状态
            const isFake = npcData.type === 'fake';
            
            // 设置当前角色状态
            this.lieDetectorManager.setCharacterStatus(isFake);
            
            // 显示测谎仪面板
            this.lieDetectorManager.showLieDetectorPanel();
        } else {
            console.error('测谎仪管理器未设置');
        }
    }

    /**
     * 组件销毁时清理事件监听
     */
    onDestroy() {
        // 移除按钮事件监听
        if (this.allowButton) {
            this.allowButton.node.off(Button.EventType.CLICK, this.handleCharacterPassed, this);
        }
        
        if (this.dismissButton) {
            this.dismissButton.node.off(Button.EventType.CLICK, this.handleCharacterDismissed, this);
        }
    }
}