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


namespace vnxbqy.UI
{
    
    public class WishingPoolModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk, IOpenServerActivity
    {
        public event Action<int> UpdateWishingDataEvent;
        public event Action<int> UpdatePoolDataEvent;
        public event Action UpdateWishAwardEvent;
        public event Action<int> onStateUpdate;
        public const int WishRedKey = 20915;
        public bool isOpenPrompting { get; set; }
        public override void Init()
        {
            ParseConfig();
            OperationTimeHepler.Instance.operationStartEvent += OperationStartEvent;
            OperationTimeHepler.Instance.operationEndEvent += OperationEndEvent;
            OperationTimeHepler.Instance.operationAdvanceEvent += OperationAdvanceEvent;
            OpenServerActivityCenter.Instance.Register(15, this);
            SetWishRedpoint();
        }

        public void OnBeforePlayerDataInitialize()
        {
            GlobalTimeEvent.Instance.secondEvent -= UpdateSecond;
            isOpenPrompting = true;
            ResetDragData();
            ResetPoolData();
        }

        public void OnPlayerLoginOk()
        {
            GlobalTimeEvent.Instance.secondEvent += UpdateSecond;
            UpdateRedpoint();
            UpdateFreeWishRedpoint();
        }

        public override void UnInit()
        {

        }

        public bool IsOpen {
            get {
                return OperationTimeHepler.Instance.SatisfyOpenCondition(Operation.WishingWellInfo);
            }
        }

        public bool priorityOpen {
            get {
                return wishPoolRedpoint.state == RedPointState.Simple;
            }
        }

        public bool IsAdvance {
            get {
                return OperationTimeHepler.Instance.SatisfyAdvanceCondition(Operation.WishingWellInfo);
            }
        }

        private void OperationEndEvent(Operation type, int state)
        {
            if (type == Operation.WishingWellInfo && state == 0)
            {
                UpdateRedpoint();
                UpdateFreeWishRedpoint();
                if (onStateUpdate != null)
                {
                    onStateUpdate(15);
                }
            }
        }

        private void OperationAdvanceEvent(Operation type)
        {
            if (type == Operation.WishingWellInfo)
            {
                if (onStateUpdate != null)
                {
                    onStateUpdate(15);
                }
            }
        }

        private void OperationStartEvent(Operation type, int state)
        {
            if (type == Operation.WishingWellInfo && state == 0)
            {

                UpdateRedpoint();
                UpdateFreeWishRedpoint();
                if (onStateUpdate != null)
                {
                    onStateUpdate(15);
                }
            }
        }

        public OperationWishingWellInfo GetOperationWishing()
        {
            OperationBase operationBase;
            if (OperationTimeHepler.Instance.TryGetOperationTime(Operation.WishingWellInfo, out operationBase))
            {
                return operationBase as OperationWishingWellInfo;
            }

            return null;
        }

        public bool TryGetFreeWishCoolTime(out int second)
        {
            second = 0;
            int endSeconds = freeStartTime + freeRefreshCoolTime;
            DateTime endTime = TimeUtility.GetTime((uint)endSeconds);
            second = Mathf.CeilToInt((float)(endTime - TimeUtility.ServerNow).TotalSeconds);
            if (second > 0)
            {
                return true;
            }
            return false;
        }

        public bool IsBestItem()
        {
            foreach (var key in poolDataDict.Keys)
            {
                if (poolDataDict[key].rare == 1)
                {
                    return true;
                }
            }
            return false;
        }

        public bool TryGetItemRareIcon(int rare, out string iconKey)
        {
            iconKey = string.Empty;
            return wishItemRareDict.TryGetValue(rare, out iconKey);
        }

        public int handStartIndex { get; private set; }
        public int handEndIndex { get; private set; }
        public event Action UpdateHandMoveEvent;
        public bool isClick { get; set; }
        public void SetHandMovePos(int wishIndex)
        {
            if (!isClick) return;

            foreach (var key in poolDataDict.Keys)
            {
                if (poolDataDict[key].itemId != 0)
                {
                    handStartIndex = key;
                    break;
                }
            }
            handEndIndex = wishIndex;
            if (UpdateHandMoveEvent != null)
            {
                isClick = false;
                UpdateHandMoveEvent();
            }
        }

        private void UpdateSecond()
        {
            if (!IsOpen || freeWishRedpoint.state != RedPointState.None) return;

            int second = 0;
            bool isCool = TryGetFreeWishCoolTime(out second);
            if (!isCool)
            {
                UpdateFreeWishRedpoint();
            }
        }

        #region 本地数据
        public bool isDraging { get; set; }
        public int dragIndex { get; set; }
        public void ResetDragData()
        {
            isDraging = false;
            dragIndex = -1;
        }
        public int freeRefreshCoolTime { get; private set; }
        public string wishingPriceFormula { get; private set; }
        public Dictionary<int, string> wishItemRareDict { get; private set; }

        public void ParseConfig()
        {
            FuncConfigConfig funcConfig = FuncConfigConfig.Get("WishingWellCfg");
            freeRefreshCoolTime = int.Parse(funcConfig.Numerical1);
            wishingPriceFormula = funcConfig.Numerical2;
            FuncConfigConfig WishingIcon = FuncConfigConfig.Get("WishingIcon");
            wishItemRareDict = ConfigParse.GetDic<int, string>(WishingIcon.Numerical1);
        }
        #endregion

        #region 协议
        Dictionary<int, WishingWellItem> poolDataDict = new Dictionary<int, WishingWellItem>();
        public int freeStartTime { get; private set; }// 免费开始倒计时时间
        public int alreadyWishNum { get; private set; } // 许愿付费刷新次数
        public int wishingPrice { get; private set; }
        public void SetWishingWellPlayerInfo(HAA1A_tagMCActWishingWellPlayerInfo wishInfo)
        {
            freeStartTime = (int)wishInfo.FreeStartTime;
            alreadyWishNum = (int)wishInfo.WishCnt;
            wishingPrice = GetWishingPrice((int)wishInfo.WishCnt);
            for (int i = 0; i < wishInfo.WellItemCnt; i++)
            {
                var itemInfo = wishInfo.WellItemInfo[i];
                WishingWellItem wellItem = new WishingWellItem((int)itemInfo.ItemID, itemInfo.ItemCnt, itemInfo.IsSpecial);
                SetWishingPoolData(i, wellItem);
            }

            for (int i = 0; i < wishInfo.CurAwardCnt; i++)
            {
                var itemInfo = wishInfo.CurAwardItemInfo[i];
                WishingWellItem wellItem = new WishingWellItem((int)itemInfo.ItemID, itemInfo.ItemCnt, itemInfo.IsSpecial);
                SetWishingData(i, wellItem);
            }

            wishingAwardDict.Clear();
            for (int i = 0; i < wishInfo.LastAwardCnt; i++)
            {
                var itemInfo = wishInfo.LastAwardItemInfo[i];
                if (itemInfo.ItemID != 0)
                {
                    WishingWellItem wellItem = new WishingWellItem((int)itemInfo.ItemID, itemInfo.ItemCnt, itemInfo.IsSpecial);
                    SetWishingAwardData(i, wellItem);
                }
            }
            UpdateRedpoint();
            UpdateFreeWishRedpoint();
            if (UpdateWishAwardEvent != null)
            {
                UpdateWishAwardEvent();
            }
        }

        public int GetWishingPrice(int wishNum)
        {
            Equation.Instance.Clear();
            Equation.Instance.AddKeyValue("refreshCnt", wishNum);
            return Equation.Instance.Eval<int>(wishingPriceFormula);
        }

        public void SetWishingResultInfo(HAA1B_tagMCActWishingDragResult result)
        {
            for (int i = 0; i < result.Cnt; i++)
            {
                var resultInfo = result.InfoList[i];
                WishingWellItem wellItem = new WishingWellItem((int)resultInfo.ItemID, resultInfo.ItemCnt, resultInfo.IsSpecial);
                switch (resultInfo.WellType)
                {
                    case 0:
                        SetWishingPoolData(resultInfo.Index, wellItem);
                        break;
                    case 1:
                        SetWishingData(resultInfo.Index, wellItem);
                        break;
                }
            }
            UpdateRedpoint();
            UpdateFreeWishRedpoint();
        }

        public void SetWishingPoolData(int index, WishingWellItem wellItem)
        {
            if (!poolDataDict.ContainsKey(index))
            {
                poolDataDict.Add(index, wellItem);
            }
            else
            {
                poolDataDict[index] = wellItem;
            }
            if (UpdatePoolDataEvent != null)
            {
                UpdatePoolDataEvent(index);
            }
        }

        public void RemovetWishingPoolData(int index)
        {
            if (poolDataDict.ContainsKey(index))
            {
                poolDataDict.Remove(index);
            }
            if (UpdatePoolDataEvent != null)
            {
                UpdatePoolDataEvent(index);
            }
        }

        Dictionary<int, WishingWellItem> wishingDataDict = new Dictionary<int, WishingWellItem>();
        public void SetWishingData(int index, WishingWellItem wellItem)
        {
            if (!wishingDataDict.ContainsKey(index))
            {
                wishingDataDict.Add(index, wellItem);
            }
            else
            {
                wishingDataDict[index] = wellItem;
            }

            if (UpdateWishingDataEvent != null)
            {
                UpdateWishingDataEvent(index);
            }
        }

        public Dictionary<int, WishingWellItem> wishingAwardDict = new Dictionary<int, WishingWellItem>();
        public void SetWishingAwardData(int index, WishingWellItem wellItem)
        {
            if (!wishingAwardDict.ContainsKey(index))
            {
                wishingAwardDict.Add(index, wellItem);
            }
            else
            {
                wishingAwardDict[index] = wellItem;
            }
        }

        public bool IsBetterItem()
        {
            return false;
        }

        public bool TryGetPoolDataByIndex(int index, out WishingWellItem wellItem)
        {
            if (poolDataDict.TryGetValue(index, out wellItem))
            {
                if (wellItem.itemId != 0)
                {
                    return true;
                }
            }
            return false;
        }

        public bool TryGetWishDataByIndex(int index, out WishingWellItem wellItem)
        {
            if (wishingDataDict.TryGetValue(index, out wellItem))
            {
                if (wellItem.itemId != 0)
                {
                    return true;
                }
            }
            return false;
        }

        public void SendRefreshPoolInfo(int refreshType)
        {
            CAA07_tagCMActWishingRefresh wishingRefresh = new CAA07_tagCMActWishingRefresh();
            wishingRefresh.IsFree = (byte)refreshType;
            GameNetSystem.Instance.SendInfo(wishingRefresh);
        }

        public void SendGetAwardQuest()
        {
            CA504_tagCMPlayerGetReward getReward = new CA504_tagCMPlayerGetReward();
            getReward.RewardType = (byte)GotServerRewardType.Def_RewardType_WishingWell;
            getReward.DataEx = 0;
            getReward.DataExStrLen = 0;
            getReward.DataExStr = string.Empty;
            GameNetSystem.Instance.SendInfo(getReward);
        }

        public void SendRefreshWishInfo(int poolIndex, int wishIndex)
        {
            CAA06_tagCMActWishing actWishing = new CAA06_tagCMActWishing();
            actWishing.SrcWellType = 0;
            actWishing.SrcIndex = (byte)poolIndex;
            actWishing.DesWellType = 1;
            actWishing.DesIndex = (byte)wishIndex;
            GameNetSystem.Instance.SendInfo(actWishing);

        }
        #endregion

        #region 红点
        public Redpoint wishPoolRedpoint = new Redpoint(MainRedDot.REDPOINT_OPENSERVER, WishRedKey);
        public const int FREEWISH_REDKEY = 2091501;
        public Redpoint freeWishRedpoint = new Redpoint(WishRedKey, FREEWISH_REDKEY);
        public List<Redpoint> wishPointlist = new List<Redpoint>();
        public void SetWishRedpoint()
        {
            wishPointlist.Clear();
            for (int i = 0; i < 5; i++)
            {
                int redKey = WishRedKey * 100 + (i + 2);
                Redpoint redpoint = new Redpoint(WishRedKey, redKey);
                wishPointlist.Add(redpoint);
            }
        }

        private void UpdateFreeWishRedpoint()
        {
            freeWishRedpoint.state = RedPointState.None;
            if (!IsOpen) return;
            for (int i = 0; i < wishPointlist.Count; i++)
            {
                var wishPoint = wishPointlist[i];
                if (wishPoint.state != RedPointState.None)
                {
                    return;
                }
            }

            int second = 0;
            bool isCool = TryGetFreeWishCoolTime(out second);
            if (!isCool)
            {
                freeWishRedpoint.state = RedPointState.Simple;
            }
        }

        private void UpdateRedpoint()
        {
            for (int i = 0; i < wishPointlist.Count; i++)
            {
                var wishPoint = wishPointlist[i];
                wishPoint.state = RedPointState.None;
            }

            if (!IsOpen) return;

            for (int i = 0; i < wishPointlist.Count; i++)
            {
                var wishPoint = wishPointlist[i];
                WishingWellItem wellItem = null;
                bool isWishData = TryGetWishDataByIndex(i, out wellItem);
                if (!isWishData)
                {
                    wishPoint.state = RedPointState.Simple;
                    return;
                }
            }
        }
        #endregion

        public void ResetPoolData()
        {
            freeStartTime = 0;
            poolDataDict.Clear();
            wishingDataDict.Clear();
            wishingAwardDict.Clear();
        }

        public class WishingWellItem
        {
            public int itemId;
            public int itemCount;
            public int rare;

            public WishingWellItem(int id, int count, int rare)
            {
                this.itemId = id;
                this.itemCount = count;
                this.rare = rare;
            }
        }
    }
}