using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using DG.Tweening;
using Unity.VisualScripting;
using UnityEngine;

public class TurnManager : MonoBehaviour
{
    // ======== serializeField ========
    [SerializeField] private List<GameObject> playerCharacterGo; // 玩家队伍列表(应该传入5个角色), 暂时只传3个
    [SerializeField] private List<GameObject> enemyCharacterGo; // 敌人队伍列表
    [SerializeField] private float dealCardAnimationDuration = 0.12f; // 系统发牌动画时间
    [SerializeField] private float dragCardAnimationDuration = 0.1f; // 卡牌被拖拽动画时间
    [SerializeField] private float dropCardAnimationDuration = 0.12f; // 系统弃牌动画时间
    [SerializeField] private Transform cardDeckContainer;
    [SerializeField] private Transform cardHandContainer;
    [SerializeField] private Transform cardDropContainer;
    [SerializeField] private Transform playerCharacterContainer;
    [SerializeField] private Transform enemyCharacterContainer;

    // ======== private ========
    // private TurnManagerSingleton turn_manager_singleton;
    private List<Card> card_deck_list = new List<Card>(); // 牌组
    private readonly List<Card> card_pile_list = new List<Card>(); // 弃牌堆
    private TurnManagerStateEnum turn_manager_state; // 状态机
    private TurnCharacterManager character_manager;
    private TurnCardManager card_manager;
    private TurnUIManager ui_manager;
    private TurnEnemyManager enemy_manager;
    private TurnManagerSingleton manager_singleton;

    private enum TurnManagerStateEnum
    {
        WAIT = 0,
        SETUP = 1,
        SELF_START = 2, // 我方回合开始
        SELF_STAY = 3, // 我方回合停留
        SELF_END = 4, // 我方回合结束
        ENEMY_START = 5, // 敌方回合开始
        ENEMY_END = 6, // 敌方回合结束
        SHUFFLE_CARD = 7,
    }

    private void Start() => on_setup_turn_manager_before();

    // public TurnManagerStateEnum GetTurnManagerState() => turnManagerState;

    private void on_setup_turn_manager_before()
    {
        card_manager = GetComponent<TurnCardManager>();
        character_manager = GetComponent<TurnCharacterManager>();
        ui_manager = GetComponent<TurnUIManager>();
        enemy_manager = GetComponent<TurnEnemyManager>();
        turn_manager_state = TurnManagerStateEnum.WAIT;
        manager_singleton = TurnManagerSingleton.Instance;
        TurnManagerEvent.OnTurnManagerStaySelfTurn += on_stay_self_turn;
        TurnManagerEvent.OnTurnManagerEndSelfTurn += on_end_self_turn;
        TurnManagerEvent.OnTurnManagerEnterEnemyTurn += after_end_self_turn; // 弃牌以后判断是否需要洗牌再进入敌方回合
        TurnManagerEvent.OnTurnManagerExitEnemyTurn += on_end_enemy_turn;
        TurnManagerEvent.DropOneCard += drop_out_one_card;

        TurnManagerEvent.TakeOutOneCard += take_out_one_card;
        setup_turn_manager();
    }


    private void setup_turn_manager() // 进入设置状态
    {
        turn_manager_state = TurnManagerStateEnum.SETUP;
        if (manager_singleton.GetNeedDebugLog()) TurnManagerSingleton.print_msg("TurnManager", "状态切换", "进入设置状态");
        card_deck_list?.Clear();
        card_pile_list?.Clear();
        CharacterManagerEvent.call_character_manager_setup();
        UIManagerEvent.call_ui_manager_setup(cardDeckContainer, cardDropContainer);
        CardManagerEvent.call_card_manager_setup(cardHandContainer, cardDropContainer,
            dropCardAnimationDuration, dealCardAnimationDuration);
        card_deck_list = character_manager.render_character_sprite_return_card_list(playerCharacterGo, playerCharacterContainer,
            cardDeckContainer, enemyCharacterGo, enemyCharacterContainer);

        on_enter_self_turn(6);
    }

    // ======================= 公共方法 ====================
    private Card take_out_one_card()
    {
        Card card = card_deck_list[UnityEngine.Random.Range(0, card_deck_list.Count)];
        card_deck_list.Remove(card);
        ui_manager.update_ui_card_deck_number(card_deck_list.Count);
        return card;
    }

    private void drop_out_one_card(Card card)
    {
        card_pile_list.Add(card);
        ui_manager.update_ui_drop_card_pile_number(card_pile_list.Count);
    }

    private bool get_now_state_is_target_state(List<TurnManagerStateEnum> target_state_list)
    {
        if (target_state_list.Contains(turn_manager_state)) return true;
        string errorMsg = target_state_list.Count switch
        {
            1 => $"[TurnManager][Error]: [{turn_manager_state}], Expect [{target_state_list[0]}]",
            2 => $"[TurnManager][Error]: [{turn_manager_state}], Expect [{target_state_list[0]}, {target_state_list[1]}]",
            _ => ""
        };
        if (errorMsg != "") Debug.LogError(errorMsg);
        return false;
    }


    private void on_enter_self_turn(int card_number) // 进入我方回合并抽卡, 必须传入抽卡数量才能进入
    {
        if (!get_now_state_is_target_state(new List<TurnManagerStateEnum>()
                { TurnManagerStateEnum.SETUP, TurnManagerStateEnum.ENEMY_END })
           ) return;
        if (manager_singleton.GetNeedDebugLog()) TurnManagerSingleton.print_msg("TurnManager", "状态切换", "进入我方回合");
        turn_manager_state = TurnManagerStateEnum.SELF_START;
        card_manager.take_card(card_number, dragCardAnimationDuration);
    }

    private void on_stay_self_turn() // 停留我方回合
    {
        if (!get_now_state_is_target_state(new List<TurnManagerStateEnum>() { TurnManagerStateEnum.SELF_START })) return;
        if (manager_singleton.GetNeedDebugLog()) TurnManagerSingleton.print_msg("TurnManager", "状态切换", "停留我方回合");
        turn_manager_state = TurnManagerStateEnum.SELF_STAY;
    }

    private void on_end_self_turn() // 结束我方回合
    {
        if (!get_now_state_is_target_state(new List<TurnManagerStateEnum>() { TurnManagerStateEnum.SELF_STAY })) return;
        // if (!card_manager.GetCardManagerStateIsWait()) return;
        if (manager_singleton.GetNeedDebugLog()) TurnManagerSingleton.print_msg("TurnManager", "状态切换", "结束我方回合");
        turn_manager_state = TurnManagerStateEnum.SELF_END;
        card_manager.drop_all_card_from_hand();
    }


    private void on_enter_enemy_turn() // 进入对方回合
    {
        if (!get_now_state_is_target_state(new List<TurnManagerStateEnum>()
                { TurnManagerStateEnum.SELF_END, TurnManagerStateEnum.SHUFFLE_CARD })) return;
        if (manager_singleton.GetNeedDebugLog()) TurnManagerSingleton.print_msg("TurnManager", "状态切换", "进入对方回合");
        turn_manager_state = TurnManagerStateEnum.ENEMY_START;
        ui_manager.enter_enemy_turn();
        enemy_manager.setup_enemy_manager();
        enemy_manager.debug_enemy_turn();
    }

    private void on_end_enemy_turn() // 结束对方回合
    {
        if (!get_now_state_is_target_state(new List<TurnManagerStateEnum>() { TurnManagerStateEnum.ENEMY_START })) return;
        if (manager_singleton.GetNeedDebugLog()) TurnManagerSingleton.print_msg("TurnManager", "状态切换", "结束对方回合");
        turn_manager_state = TurnManagerStateEnum.ENEMY_END;
        ui_manager.exit_enemy_turn();
        on_enter_self_turn(card_pile_list.Count == 0 ? 6 : 5);
    }

    private void after_end_self_turn()
    {
        if (card_deck_list.Count != 0)
        {
            on_enter_enemy_turn();
            return;
        }

        if (manager_singleton.GetNeedDebugLog()) TurnManagerSingleton.print_msg("TurnManager", "状态切换", "开始洗牌");
        turn_manager_state = TurnManagerStateEnum.SHUFFLE_CARD;
        card_deck_list = new List<Card>(card_pile_list);
        card_pile_list.Clear();
        ui_manager.update_ui_card_deck_number(card_deck_list.Count);
        ui_manager.update_ui_drop_card_pile_number(card_pile_list.Count);
        TurnCardManager.move_all_card_goto_deck(cardDropContainer, cardDeckContainer);
        StartCoroutine(enumerator());
        return;

        IEnumerator enumerator()
        {
            for (var i = 0; i <= 3; i++)
            {
                yield return new WaitForSeconds(1);
            }

            on_enter_enemy_turn();
        }
    }
}