using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using DG.Tweening;
using UnityEngine;
using UnityEngine.Splines;

public class TurnCardManager : MonoBehaviour
{
    [SerializeField] private Collider2D areaCollider2D;
    [SerializeField] private SplineContainer splineContainer;


    // =============== private ================
    private Transform drop_card_container;
    private Transform hand_card_container;
    private float drop_card_animation_duration;
    private float move_card_animation_duration;
    private TurnManagerSingleton turn_manager_singleton;
    private CardManagerState card_manager_state = CardManagerState.WAIT;
    private readonly List<Card> hand_card_list = new List<Card>();
    private bool is_setup = false;
    // private bool lockOneCardBeingUsed = false; // 是否锁定一个卡牌正在使用

    private enum CardManagerState
    {
        WAIT,
        DEAL_CARD,
        DROP_CARD,
    }

    private void Awake()
    {
        CardManagerEvent.OnCardManagerSetup += setup_card_manager;
        CardManagerEvent.OnCardManagerUseOneCard += use_a_card;
    }

    private void setup_card_manager(Transform hand_card_parent, Transform drop_card_parent, float drop_duration, float move_duration)
    {
        if (is_setup) return;
        is_setup = true;
        turn_manager_singleton = TurnManagerSingleton.Instance;
        if (turn_manager_singleton.GetNeedDebugLog()) TurnManagerSingleton.print_msg("CardManager", "初始化", "初始化成功");
        hand_card_container = hand_card_parent;
        drop_card_animation_duration = drop_duration;
        move_card_animation_duration = move_duration;
        drop_card_container = drop_card_parent.Find("CardContainer");
    }

    public void drop_all_card_from_hand()
    {
        if (turn_manager_singleton.GetNeedDebugLog()) TurnManagerSingleton.print_msg("CardManager", "动作切换", "开始弃牌");
        StartCoroutine(coroutine());
        return;

        IEnumerator coroutine()
        {
            card_manager_state = CardManagerState.DROP_CARD;
            foreach (var card in hand_card_list)
            {
                Sequence tweenAnimation = card.card_goto_drop(drop_card_container, drop_card_animation_duration);
                TurnManagerEvent.call_turn_manager_drop_one_card(card);
                yield return tweenAnimation.WaitForCompletion();
            }

            hand_card_list.Clear();
            card_manager_state = CardManagerState.WAIT;
            TurnManagerEvent.call_turn_manager_enter_enemy_turn();
        }
    }

    private void use_a_card(Card card)
    {
        card_manager_state = CardManagerState.DROP_CARD;
        card.card_goto_drop(drop_card_container, drop_card_animation_duration);
        hand_card_list.Remove(card);
        readjust_card_position();
        TurnManagerEvent.call_turn_manager_drop_one_card(card);
        card_manager_state = CardManagerState.WAIT;
    }

    public static void move_all_card_goto_deck(Transform drop_card_transform, Transform deck_transform)
    {
        const string container_name = "CardContainer";
        Transform drop_card_container = drop_card_transform.Find(container_name);
        Transform card_deck_container = deck_transform.Find(container_name);
        for (int i = drop_card_container.childCount - 1; i >= 0; i--)
        {
            Transform card = drop_card_container.GetChild(i);
            card.SetParent(card_deck_container);
            card.localPosition = Vector3.zero;
        }
    }

    public void take_card(int number, float drag_animation_duration)
    {
        if (turn_manager_singleton.GetNeedDebugLog()) TurnManagerSingleton.print_msg("CardManager", "动作切换", $"开始抽卡:{number}");
        card_manager_state = CardManagerState.DEAL_CARD;
        StartCoroutine(enumerator());
        return;

        IEnumerator enumerator()
        {
            for (int i = 0; i < number; i++)
            {
                Card card = TurnManagerEvent.call_turn_manager_take_out_one_card();
                card.set_area_collider2D(areaCollider2D, drag_animation_duration); // 卡片被抽出时再设置拖拽动画事件
                hand_card_list.Add(card);
                if (turn_manager_singleton.GetNeedDebugLog()) print($"[CardManager][抽卡ID]: {card.GetID(isInstance: true)}");
                readjust_card_position();
                yield return new WaitForSeconds(move_card_animation_duration);
            }

            card_manager_state = CardManagerState.WAIT;
            TurnManagerEvent.call_turn_manager_go_stay_self_turn();
        }
    }


    private void readjust_card_position() // 重新调整卡牌位置
    {
        int hand_card_list_count = hand_card_list.Count;
        if (hand_card_list_count == 0) return;
        float cardSpacing = hand_card_list_count switch // 动态调整卡牌间距
        {
            <= 4 => 0.5f / (hand_card_list_count + 1),
            <= 5 => 0.75f / (hand_card_list_count + 1),
            _ => 1f / (hand_card_list_count + 1)
        };

        float first_card_position = 0.5f - (hand_card_list_count - 1) * cardSpacing / 2; // 获取第一个卡牌的位置
        Spline spline = splineContainer.Spline; // 获取曲线

        for (int i = 0; i < hand_card_list_count; i++)
        {
            float position = first_card_position + i * cardSpacing;
            Vector3 card_world_position = spline.EvaluatePosition(position); // 获取曲线指定位置的坐标
            card_world_position += hand_card_container.position;
            Vector3 forward = spline.EvaluateTangent(position); // 获取曲线指定的切线方向
            Vector3 up = spline.EvaluateUpVector(position); // 获取曲线指定的UP向量
            Vector3 upwards = Vector3.Cross(up, forward).normalized; // 切线和向上的夹角计算方向
            Quaternion rotation = Quaternion.LookRotation(up, upwards);
            Card hand_card = hand_card_list[i];
            hand_card.move_card_go_hand(card_world_position, rotation, move_card_animation_duration, i + 1, hand_card_container);
        }
    }
}