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

namespace Snxxz.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> onStateUpate;
        public const int WishRedKey = 20915;
        public override void Init()
        {
            ParseConfig();
            OperationTimeHepler.Instance.operationStartEvent += OperationStartEvent;
            OperationTimeHepler.Instance.operationEndEvent += OperationEndEvent;
            OperationTimeHepler.Instance.operationAdvanceEvent += OperationAdvanceEvent;
            OpenServerActivityCenter.Instance.Register((int)OpenServerActivityCenter.OSActivityType.WishingPool, this);
            SetWishRedpoint();
        }

        public void OnBeforePlayerDataInitialize()
        {
            ResetDragData();
            ResetPoolData();
        }

        public void OnPlayerLoginOk()
        {
            UpdateRedpoint();
        }

        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 == 1)
            {
                UpdateRedpoint();
                if (onStateUpate != null)
                {
                    onStateUpate((int)OpenServerActivityCenter.OSActivityType.WishingPool);
                }
            }
        }

        private void OperationAdvanceEvent(Operation type)
        {
            if (type == Operation.WishingWellInfo)
            {
                if (onStateUpate != null)
                {
                    onStateUpate((int)OpenServerActivityCenter.OSActivityType.WishingPool);
                }
            }
        }

        private void OperationStartEvent(Operation type, int state)
        {
            if (type == Operation.WishingWellInfo && state == 1)
            {
                UpdateRedpoint();
                if (onStateUpate != null)
                {
                    onStateUpate((int)OpenServerActivityCenter.OSActivityType.WishingPool);
                }
            }
        }

        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].isBest == 1)
                {
                    return true;
                }
            }
            return false;
        }

        public int handStartIndex { get; private set; }
        public int handEndIndex { get; private set;}
        public event Action UpdateHandMoveEvent;
        public void SetHandMovePos(int wishIndex)
        {
            foreach(var key in poolDataDict.Keys)
            {
                if(poolDataDict[key].itemId != 0)
                {
                    handStartIndex = key;
                    break;
                }
            }
            handEndIndex = wishIndex;
            if(UpdateHandMoveEvent != null)
            {
                UpdateHandMoveEvent();
            }
        }

        #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 void ParseConfig()
        {
            FuncConfigConfig funcConfig = Config.Instance.Get<FuncConfigConfig>("WishingWellCfg");
            freeRefreshCoolTime = int.Parse(funcConfig.Numerical1);
            wishingPriceFormula = funcConfig.Numerical2;
        }
        #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.IsBind,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.IsBind, 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.IsBind, itemInfo.IsSpecial);
                    SetWishingAwardData(i, wellItem);
                }
            }
            UpdateRedpoint();
            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.IsBind, resultInfo.IsSpecial);
                switch (resultInfo.WellType)
                {
                    case 0:
                        SetWishingPoolData(resultInfo.Index, wellItem);
                        break;
                    case 1:
                        SetWishingData(resultInfo.Index, wellItem);
                        break;
                }
            }
            UpdateRedpoint();
        }

        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 UpdateRedpoint()
        {
            int second = 0;
            bool isCool = TryGetFreeWishCoolTime(out second);
            if(IsOpen && !isCool)
            {
                freeWishRedpoint.state = RedPointState.Simple;
            }
            else
            {
                freeWishRedpoint.state = RedPointState.None;
            }

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

            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 isBind;
            public int isBest;
            public WishingWellItem(int id,int count,int isBind,int isBest)
            {
                this.itemId = id;
                this.itemCount = count;
                this.isBind = isBind;
                this.isBest = isBest;
            }
        }
    }
}