using System.Collections.Generic;
using System.Linq;
using Continentis.MainGame.Character;
using Continentis.MainGame.Combat;
using Continentis.MainGame.UI;
using SLSFramework.General;
using UnityEngine;
using UnityEngine.EventSystems;

namespace Continentis.MainGame.Card
{
    public partial class HandCardView : IBeginDragHandler, IDragHandler, IEndDragHandler, IPointerClickHandler
    {
        public CombatCharacterViewBase currentTargetingCharacterView;
        
        public List<CharacterBase> validTargets = new List<CharacterBase>();
        public List<CharacterBase> conditionNotMetTargets = new List<CharacterBase>();
        public List<CharacterBase> invalidTargets = new List<CharacterBase>();

        public override void OnPointerEnter(PointerEventData eventData)
        {
            base.OnPointerEnter(eventData);
            card.contentSubmodule.dirtyMark = true;
            if (CombatUIManager.Instance.selectingCardView == null)
            {
                canvas.overrideSorting = true;
                canvas.sortingLayerName = "UI";
                canvas.sortingOrder = 10;
            }
        }
        
        public override void OnPointerExit(PointerEventData eventData)
        {
            base.OnPointerExit(eventData);

            if (!isSelecting)
            {
                canvas.overrideSorting = false;
                canvas.sortingOrder = 0;
            }
        }
        
        public void OnPointerClick(PointerEventData eventData)
        {
            if (CombatUIManager.Instance.combatMainPage.handCardSelector.gameObject.activeInHierarchy)
            {
                if(isOccupied) return;
                
                if (CombatUIManager.Instance.combatMainPage.handCardSelector.selectedCards.Contains(card))
                {
                    CombatUIManager.Instance.combatMainPage.handCardSelector.Deselect(this);
                }
                else
                {
                    CombatUIManager.Instance.combatMainPage.handCardSelector.Select(this);
                }
            }
            else if (CombatUIManager.Instance.combatMainPage.customCardSelector.gameObject.activeInHierarchy)
            {
                if(isOccupied) return;
                
                if (CombatUIManager.Instance.combatMainPage.customCardSelector.selectedCards.Contains(card))
                {
                    CombatUIManager.Instance.combatMainPage.customCardSelector.Deselect(this);
                }
                else
                {
                    CombatUIManager.Instance.combatMainPage.customCardSelector.Select(this);
                }
            }
        }

        public void OnBeginDrag(PointerEventData eventData)
        {
            isSelecting = true;
            CombatUIManager.Instance.selectingCardView = this;
            
            card.user = CombatMainManager.Instance.currentCharacter;
            card.DetectTargetsValidity(out validTargets, out conditionNotMetTargets, out invalidTargets);

            if (card.attributeSubmodule.targetCount == 1)
            {
                CombatUIManager.Instance.arrowsPage.GeneratePointerArrow(cardTransform.position, cardTransform.position, true);
            }
            else if (card.attributeSubmodule.targetCount == -1)
            {
                CombatUIManager.Instance.arrowsPage.GeneratePointerArrow(cardTransform.position, cardTransform.position, true);

                for (int i = 0; i < validTargets.Count + conditionNotMetTargets.Count - 1; i++)
                {
                    CombatUIManager.Instance.arrowsPage.GeneratePointerArrow(cardTransform.position, cardTransform.position, false);
                }
            }
        }

        public void OnDrag(PointerEventData eventData)
        {
            RectTransform arrowCanvasRect = CombatUIManager.Instance.arrowsPage.rectTransform;
            Camera uiCamera = CombatUIManager.Instance.uiCamera;
            Camera worldCamera = CombatUIManager.Instance.combatCamera;
            
            // 先检查悬停的视图是否和当前记录的目标视图发生了变化
            if (CombatUIManager.Instance.hoveringCharacterView != currentTargetingCharacterView)
            {
                // 如果悬停视图不是空的，说明鼠标移动到了一个新的目标上
                if (CombatUIManager.Instance.hoveringCharacterView != null)
                {
                    card.Targeting(CombatUIManager.Instance.hoveringCharacterView.character);
                    currentTargetingCharacterView = CombatUIManager.Instance.hoveringCharacterView;
                }
                else // 悬停视图是空的，说明鼠标离开了之前的目标
                {
                    card.Untargeting();
                    currentTargetingCharacterView = null;
                }

                card.contentSubmodule.dirtyMark = true;
            }
            
            Vector3 startPosition = cardTransform.position + new Vector3(0, cardTransform.rect.height * cardTransform.lossyScale.y / 2, 0);
            Vector3 endPosition = SpaceConverter.ScreenPointToUIPoint(arrowCanvasRect, eventData.position, uiCamera);
            PointerArrow mainPointerArrow = CombatUIManager.Instance.arrowsPage.mainPointerArrow;
            
            CombatCharacterViewBase hoveringCharacterView = CombatUIManager.Instance.hoveringCharacterView;
            CharacterBase hoveringCharacter = hoveringCharacterView != null ? hoveringCharacterView.character : null;
            
            if (card.attributeSubmodule.targetCount == 1)
            {
                mainPointerArrow.SetArrow(startPosition, endPosition);
                
                if (hoveringCharacter != null)
                {
                    if (validTargets.Contains(hoveringCharacter))
                    {
                        mainPointerArrow.SetColor(Color.white);
                    }
                    else if (conditionNotMetTargets.Contains(hoveringCharacter))
                    {
                        mainPointerArrow.SetColor(Color.yellow);
                    }
                    else if (invalidTargets.Contains(hoveringCharacter))
                    {
                        mainPointerArrow.SetColor(Color.red);
                    }
                }
                else
                {
                    mainPointerArrow.SetColor(Color.white);
                }
            }
            else if (card.attributeSubmodule.targetCount == -1)
            {
                mainPointerArrow.SetArrow(startPosition, endPosition);

                if (validTargets.Count > 0)
                {
                    if (hoveringCharacter != null)
                    {
                        mainPointerArrow.SetColor(Color.white);
                    }

                    if (validTargets.Contains(hoveringCharacter))
                    {
                        mainPointerArrow.SetColor(Color.white);
                    }
                    else if (conditionNotMetTargets.Contains(hoveringCharacter))
                    {
                        mainPointerArrow.SetColor(Color.yellow);
                    }
                    else if (invalidTargets.Contains(hoveringCharacter))
                    {
                        mainPointerArrow.SetColor(Color.red);
                    }
                }
                else
                {
                    mainPointerArrow.SetColor(Color.red);
                    return;
                }

                if (hoveringCharacter != null && (validTargets.Contains(hoveringCharacter) || conditionNotMetTargets.Contains(hoveringCharacter)))
                {
                    List<CharacterBase> validTargetsExceptHovering =
                        validTargets.FindAll(target => target != hoveringCharacter);

                    List<CharacterBase> notMetTargetsExceptHovering =
                        conditionNotMetTargets.FindAll(target => target != hoveringCharacter);

                    for (int i = 0; i < validTargetsExceptHovering.Count; i++)
                    {
                        PointerArrow arrow = CombatUIManager.Instance.arrowsPage.otherPointerArrows[i];
                        CharacterBase target = validTargetsExceptHovering[i];
                        Vector3 targetViewPosition = target.characterView.transform.position;
                        arrow.gameObject.SetActive(true);
                        Vector3 otherEndPosition = SpaceConverter.WorldPointToUIPoint(arrowCanvasRect, targetViewPosition, worldCamera, uiCamera);
                        arrow.SetArrow(startPosition, otherEndPosition);
                        arrow.SetColor(Color.white);
                    }

                    for (int i = validTargetsExceptHovering.Count; i < validTargetsExceptHovering.Count + notMetTargetsExceptHovering.Count; i++)
                    {
                        PointerArrow arrow = CombatUIManager.Instance.arrowsPage.otherPointerArrows[i];
                        CharacterBase target = notMetTargetsExceptHovering[i];
                        Vector3 targetViewPosition = target.characterView.transform.position;
                        arrow.gameObject.SetActive(true);
                        Vector3 otherEndPosition = SpaceConverter.WorldPointToUIPoint(arrowCanvasRect, targetViewPosition, worldCamera, uiCamera);
                        arrow.SetArrow(startPosition, otherEndPosition);
                        arrow.SetColor(Color.yellow);
                    }
                }
                else
                {
                    CombatUIManager.Instance.arrowsPage.otherPointerArrows.ForEach(arrow => { arrow.gameObject.SetActive(false); });
                }
            }
            else if (card.attributeSubmodule.targetCount == 0)
            {
                Vector3 cardPosition = SpaceConverter.ScreenPointToUIPoint(arrowCanvasRect, eventData.position, uiCamera);
                cardTransform.position = cardPosition;
            }
        }

        public void OnEndDrag(PointerEventData eventData)
        {
            CombatCharacterViewBase hoveringCharacterView = CombatUIManager.Instance.hoveringCharacterView;
            CharacterBase hoveringCharacter = hoveringCharacterView != null ? hoveringCharacterView.character : null;
            Camera uiCamera = CombatUIManager.Instance.uiCamera;
            CombatUIManager.Instance.arrowsPage.ClearPointerArrows();
            
            if (isSelecting)
            {
                isSelecting = false;
                isHovering = false;
                CombatUIManager.Instance.selectingCardView = null;
                canvas.overrideSorting = false;
                canvas.sortingOrder = 0;
                card.eventSubmodule.onUntargeting();
                card.contentSubmodule.dirtyMark = true;
            }
            else
            {
                return;
            }

            if (card.HasKeyword("Unplayable")) // 如果有“不能打出”关键词，直接返回
            {
                return;
            }
            
            
            if (!card.HasKeyword("TargetSelf"))
            {
                if (!validTargets.Contains(hoveringCharacter))
                {
                    // 当前鼠标悬停的目标不在有效目标列表中
                    return;
                }
            }
            
            // 根据目标类型，打出卡牌
            if (card.attributeSubmodule.targetCount == 1)
            {
                if (hoveringCharacter != null && validTargets.Contains(hoveringCharacter))
                {
                    if (!card.Play(new List<CharacterBase>() { hoveringCharacter }))
                    {
                        card.eventSubmodule.onUntargeting();
                        card.contentSubmodule.dirtyMark = true;
                    }
                }
            }
            else
            {
                RectTransform dropZone = CombatUIManager.Instance.combatMainPage.dropZone;
                bool isInDropZone = RectTransformUtility.RectangleContainsScreenPoint(dropZone, eventData.position, uiCamera);
                List<CharacterBase> targetList = new List<CharacterBase>();

                if (card.attributeSubmodule.targetCount == -1)
                {
                    targetList.AddRange(validTargets);
                }
                else if (card.HasKeyword("TargetSelf") && card.attributeSubmodule.targetCount == 0)
                {
                    targetList.Add(card.user);
                }

                if (!isInDropZone)
                {
                    card.Play(targetList);
                }
            }
        }
    }
}