using UnityEngine;
using UnityEngine.UI;
using System.Collections.Generic;
using System;
using DG.Tweening;

namespace vnxbqy.UI
{
    public class WishingPoolWin : Window
    {
        [SerializeField] DragItem dragItem;
        [SerializeField] Text activityDayText;
        [SerializeField] Text totalDayText;
        [SerializeField] Text dayRemainTime;
        [SerializeField] Button lookAllBtn;
        [SerializeField] Button freeRefreshWishBtn;
        [SerializeField] Button moneyRefreshWishBtn;
        [SerializeField] Text moneyValueText;
        [SerializeField] Text freeWishCoolText;
        [SerializeField] List<PoolItemCell> poolItemCells = new List<PoolItemCell>();
        [SerializeField] List<WishItemCell> wishingCells = new List<WishItemCell>();
        [SerializeField] GameObject activityOpenObj;
        [SerializeField] GameObject activityCloseObj;
        [SerializeField] GameObject maskObj;
        [Header("动画控制")]
        [SerializeField] RectTransform handImg;
        [SerializeField] CanvasGroup handAlpha;
        [SerializeField] List<Vector2> startPos = new List<Vector2>();
        [SerializeField] List<Vector2> endPos = new List<Vector2>();
        [Header("最小时间间隔")] [SerializeField] float minDuration = 1.5f;
        [Header("最大时间间隔")] [SerializeField] float maxDuration = 2.5f;
        [Header("渐隐渐显时间")] [SerializeField] float alphaDuration = 0.5f;

        
        WishingPoolModel wishingModel { get { return ModelCenter.Instance.GetModel<WishingPoolModel>(); } }
        OperationWishingWellInfo operation = null;
        int playTimes = 0;
        #region Built-in
        protected override void BindController()
        {

        }

        protected override void AddListeners()
        {
            freeRefreshWishBtn.AddListener(ClickFreeRefreshWish);
            moneyRefreshWishBtn.AddListener(ClickMoneyRefreshWish);
            lookAllBtn.AddListener(ClickLook);
        }

        protected override void OnPreOpen()
        {
            Display();
            OperationTimeHepler.Instance.operationEndEvent += OperationEndEvent;
            wishingModel.UpdatePoolDataEvent += UpdatePoolItemByIndex;
            wishingModel.UpdateWishingDataEvent += UpdateWishItemByIndex;
            GlobalTimeEvent.Instance.secondEvent += UpdateSecond;
            wishingModel.UpdateHandMoveEvent += UpdateHandMove;
        }

        protected override void OnAfterOpen()
        {

        }
        protected override void OnPreClose()
        {
            wishingModel.UpdatePoolDataEvent -= UpdatePoolItemByIndex;
            wishingModel.UpdateWishingDataEvent -= UpdateWishItemByIndex;
            GlobalTimeEvent.Instance.secondEvent -= UpdateSecond;
            OperationTimeHepler.Instance.operationEndEvent -= OperationEndEvent;
            wishingModel.UpdateHandMoveEvent -= UpdateHandMove;
        }
        protected override void OnAfterClose()
        {

        }
        #endregion

        private void Display()
        {
            operation = wishingModel.GetOperationWishing();
            if (operation == null) return;

            UpdatePoolItem();
            for (int i = 0; i < wishingCells.Count; i++)
            {
                UpdateWishItemByIndex(i);
            }
            dragItem.dragItemRect.SetActive(false);
            UpdateFreeWishCool();
            UpdateActivityState();
            UpdateDayRemainTime();
            activityDayText.text = Language.Get("WishingPool103", operation.GetActivityDay());
            totalDayText.text = Language.Get("WishingPool101", Language.Get(StringUtility.Contact("Num_CHS_", operation.GetActivitySumDay())));
            handImg.SetActive(false);
            playTimes = 0;
            handAlpha.DOKill();
            handImg.DOKill();
            wishingModel.isClick = true;
            maskObj.SetActive(false);
        }

        private void UpdateHandMove()
        {
            PlayHandMovePos();
        }

        private void PlayHandMovePos()
        {
            maskObj.SetActive(true);
            playTimes = 0;
            handAlpha.DORestart();
            handImg.DORestart();
            PlayAlphaTween(true);
        }

        private void PlayPosTween()
        {
            playTimes += 1;
            Vector2 pos = endPos[wishingModel.handEndIndex];
            float offset = (float)Mathf.Abs(wishingModel.handStartIndex % 4 - wishingModel.handEndIndex) / 2;
            if (offset < minDuration)
            {
                offset = minDuration;
            }
            else if (offset > maxDuration)
            {
                offset = maxDuration;
            }
            handImg.DOAnchorPos(pos, offset).OnComplete(()=> { PlayAlphaTween(false); });
        }

        private void PlayAlphaTween(bool isStart)
        {
            if (isStart)
            {
                handImg.anchoredPosition = startPos[wishingModel.handStartIndex];
                handImg.SetActive(true);
                handAlpha.alpha = 0;
                handAlpha.DOFade(1, alphaDuration).OnComplete(() =>
                {
                    PlayPosTween();
                });
            }
            else
            {
                handAlpha.alpha = 1;
                handAlpha.DOFade(0, alphaDuration).OnComplete(() =>
                {
                    if (playTimes < 2)
                    {
                        PlayAlphaTween(true);
                    }
                    else
                    {
                        maskObj.SetActive(false);
                        handImg.SetActive(false);
                        wishingModel.isClick = true;
                    }
                });
            }
        }

        #region 许愿逻辑
        protected override void LateUpdate()
        {
           if(wishingModel.isDraging)
            {
               if(TryGetDragItem())
                {
                    Vector2 _pos;
                    if (RectTransformUtility.ScreenPointToLocalPointInRectangle(this.transform as RectTransform,
                        Input.mousePosition, CameraManager.uiCamera, out _pos))
                    {
                        dragItem.dragItemRect.anchoredPosition3D = _pos;
                    }

                    if (Input.GetMouseButtonUp(0))
                    {
                        dragItem.dragItemRect.SetActive(false);
                        CheckWishingCell();
                        wishingModel.ResetDragData();
                    }
                }
            }
        }
       
        private void CheckWishingCell()
        {
            bool isAddWish = false;
            for(int i = 0; i < wishingCells.Count; i++)
            {
                var rect = wishingCells[i].transform as RectTransform;
                var des = RectTransformUtility.CalculateRelativeRectTransformBounds(this.transform, rect);
                var src = RectTransformUtility.CalculateRelativeRectTransformBounds(this.transform, dragItem.dragItemRect);
                var dis = Vector3.Distance(des.center, src.center);
                if (dis < rect.rect.width / 2)
                {
                    //WishingPoolModel.WishingWellItem wellPoolItem = null;
                    //bool isPoolData = wishingModel.TryGetPoolDataByIndex(wishingModel.dragIndex, out wellPoolItem);
                    //WishingPoolModel.WishingWellItem wellWishItem = null;
                    //bool isWishData = wishingModel.TryGetWishDataByIndex(i, out wellWishItem);
                    //if (wellWishItem.itemId == 0)
                    //{
                    //    wishingModel.RemovetWishingPoolData(i);
                    //}
                    //else
                    //{
                    //    wishingModel.SetWishingPoolData(wishingModel.dragIndex,wellWishItem);
                    //}
                    //wishingModel.SetWishingData(i,wellPoolItem);
                    isAddWish = true;
                    wishingModel.SendRefreshWishInfo(wishingModel.dragIndex,i);
                    break;
                }
            }
            if(!isAddWish)
            {
                UpdatePoolItem();
            }
        }

        private bool TryGetDragItem()
        {
            WishingPoolModel.WishingWellItem wellItem = null;
            bool isPoolData = wishingModel.TryGetPoolDataByIndex(wishingModel.dragIndex, out wellItem);
            if (isPoolData)
            {
                dragItem.dragItemRect.SetActive(true);
                string rareIconKey = string.Empty;
                bool isRare = wishingModel.TryGetItemRareIcon(wellItem.rare, out rareIconKey);
                dragItem.dragBestIcon.SetActive(isRare);
                if (isRare)
                {
                    dragItem.dragBestIcon.SetSprite(rareIconKey);
                }
                ItemCellModel cellModel = new ItemCellModel(wellItem.itemId,false,(ulong)wellItem.itemCount);
                dragItem.dragItemBasic.Init(cellModel);
                poolItemCells[wishingModel.dragIndex].SetActive(false);
            }
            else
            {
                dragItem.dragItemRect.SetActive(false);
            }
            return isPoolData;
        }

        private void UpdatePoolItem()
        {
            for (int i = 0; i < poolItemCells.Count; i++)
            {
                UpdatePoolItemByIndex(i);
            }
        }

        private void UpdatePoolItemByIndex(int index)
        {
            WishingPoolModel.WishingWellItem wellItem = null;
            var poolItemCell = poolItemCells[index];
            bool isPoolData = wishingModel.TryGetPoolDataByIndex(index, out wellItem);
            if (isPoolData)
            {
                poolItemCell.SetActive(true);
                poolItemCell.Display(index);
            }
            else
            {
                poolItemCell.SetActive(false);
            }
        }

        private void UpdateWishItemByIndex(int index)
        {
            var wishCell = wishingCells[index];
            wishCell.Display(index);
        }

        [Serializable]
        public class DragItem
        {
           public RectTransform dragItemRect;
           public CommonItemBaisc dragItemBasic;
           public Image dragBestIcon;
        }
        #endregion

        #region 活动逻辑
        private void OperationEndEvent(Operation type, int state)
        {
            if(type == Operation.WishingWellInfo && state == 0)
            {
                UpdateActivityState();
            }
        }


        private void UpdateSecond()
        {
            if (operation == null) return;
            UpdateFreeWishCool();
            UpdateDayRemainTime();
        }

        private void UpdateDayRemainTime()
        {
            dayRemainTime.text = Language.Get("WishingPool104", TimeUtility.SecondsToHMS(operation.GetResetSurplusTime()));
        }

        private void UpdateFreeWishCool()
        {
            int second = 0;
            bool isCool = wishingModel.TryGetFreeWishCoolTime(out second);
            if (isCool)
            {
                freeRefreshWishBtn.SetActive(false);
                freeWishCoolText.SetActive(true);
                moneyRefreshWishBtn.SetActive(true);
                moneyValueText.text = wishingModel.wishingPrice.ToString();
                freeWishCoolText.text = Language.Get("WishingPool102", TimeUtility.SecondsToHMS(second));
            }
            else
            {

                freeRefreshWishBtn.SetActive(true);
                freeWishCoolText.SetActive(false);
                moneyRefreshWishBtn.SetActive(false);
            }
        }

        private void UpdateActivityState()
        {
            if (wishingModel.IsOpen)
            {
                activityOpenObj.SetActive(true);
                activityCloseObj.SetActive(false);
            }
            else
            {
                activityOpenObj.SetActive(false);
                activityCloseObj.SetActive(true);
            }

        }

        private void ClickLook()
        {
            WindowCenter.Instance.Open<WishingWarehouseWin>();
        }

        private void ClickMoneyRefreshWish()
        {
            if(!wishingModel.IsBestItem())
            {
                CheckMoney();
            }
            else
            {
                ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("WishingPool106", wishingModel.wishingPrice), (bool isOk) =>
                {
                    if (isOk)
                    {
                        CheckMoney();
                    }
                });
            }
        }

        private void CheckMoney()
        {
            if ((int)UIHelper.GetMoneyCnt(1) < wishingModel.wishingPrice)
            {
                WindowCenter.Instance.Open<RechargeTipWin>();
            }
            else
            {
                if (wishingModel.isOpenPrompting)
                {
                    ConfirmCancel.ToggleConfirmCancel(Language.Get("Mail101"), Language.Get("WishingPool105", wishingModel.wishingPrice),
                    Language.Get("ConfirmCancel101"), (bool isOk, bool isToggle) =>
                    {
                        if (isOk)
                        {
                            wishingModel.SendRefreshPoolInfo(0);
                            wishingModel.isOpenPrompting = !isToggle;
                        }

                    });
                }
                else
                {
                    wishingModel.SendRefreshPoolInfo(0);
                }
            }
        }

        private void ClickFreeRefreshWish()
        {
            if (!wishingModel.IsBestItem())
            {
                wishingModel.SendRefreshPoolInfo(1);
            }
            else
            {
                ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("WishingPool106"), (bool isOk) =>
                {
                    if (isOk)
                    {
                        wishingModel.SendRefreshPoolInfo(1);
                    }
                });
            }
         
        }
        #endregion

    }
}