using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using TableConfig;
using LitJson;

namespace Snxxz.UI
{
    [XLua.Hotfix]
    [XLua.LuaCallCSharp]
    public class CrossServerOneVsOneModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize,ISwitchAccount ,IPlayerLoginOk
    {
        public string PkResultLocalSaveKey { get; private set; }
        public List<CrossServerOneVsOnePkResult> localSaveResults { get; private set; }
        CrossServerRewardModel rewardModel { get { return ModelCenter.Instance.GetModel<CrossServerRewardModel>(); } }
        public event Action UpdateDayAwardsEvent;
        public const int CrossServerDataMapId = 32010;
        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }

        public bool IsMatching { get; set;}
        public DateTime matchStartTime { get; set; }

        public override void Init()
        {
            IsMatching = false;
            ParseFuncConfig();
        }

        public void OnBeforePlayerDataInitialize()
        {
            dungeonModel.updateMissionEvent -= UpdateFBHelp;
            rewardModel.CrossRealmPKAwardStateUpdate -= UpdateDayAwardState;
            CrossServerOneVsOnePlayerInfo.Instance.UpdatePlayerInfoEvent -= UpdateDayAwardState;
            InitData();
        }

        public void OnAfterPlayerDataInitialize()
        {
            int playerId = (int)PlayerDatas.Instance.baseData.PlayerID;
            PkResultLocalSaveKey = StringUtility.Contact("PkResultLocalSaveKey", playerId);
            GetLocalSaveData();
        }

        public void OnSwitchAccount()
        {
            IsMatching = false;
        }

        public void OnPlayerLoginOk()
        {
            rewardModel.CrossRealmPKAwardStateUpdate += UpdateDayAwardState;
            CrossServerOneVsOnePlayerInfo.Instance.UpdatePlayerInfoEvent += UpdateDayAwardState;
            dungeonModel.updateMissionEvent += UpdateFBHelp;
            UpdateDayAwardState();
            if(IsMatching)
            {
                SendCrossMatch(1);
            }
        }

        public override void UnInit()
        {

        }

        private void InitData()
        {
            CrossServerOneVsOnePKSeason.Instance.InitData();
            CrossServerOneVsOnePlayerInfo.Instance.InitData();
            pkResultInfo = new CrossServerOneVsOnePkResult();
        }

        public void UpdateDayAwardState()
        {
            var playerInfo = CrossServerOneVsOnePlayerInfo.Instance;
            for(int i = 0; i < dayAwardTypelist.Count; i++)
            {
                var dayAward = dayAwardTypelist[i];
                int awardType = dayAward.type;
                switch(awardType)
                {
                    case 1:
                        dayAward.IsReceived = rewardModel.IsAwardState(CrossRealmPKAwardStateEnum.DayWinCountAwardState,dayAward.index);
                        dayAward.SetCompletedNum(playerInfo.DayWinCount);
                        break;
                    case 2:
                        dayAward.IsReceived = rewardModel.IsAwardState(CrossRealmPKAwardStateEnum.DayPKCountAwardState,dayAward.index);
                        dayAward.SetCompletedNum(playerInfo.DayPKCount);
                        break;
                }
            }

            if(UpdateDayAwardsEvent != null)
            {
                UpdateDayAwardsEvent();
            }
        }

        private void UpdateFBHelp()
        {
           int dataMapId = dungeonModel.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);
            if (dataMapId != CrossServerDataMapId) return;

            var mission = dungeonModel.mission;
            if(mission.prepareTime > 0)
            {
                if(!WindowCenter.Instance.IsOpen<CrossServerOneVsOneRoundWin>())
                {
                    WindowCenter.Instance.Open<CrossServerOneVsOneRoundWin>();
                }
            }

            if(mission.isStart == 1)
            {
                
            }
        }

        public List<AwardType> sortDayAwardslist = new List<AwardType>();
        public void SortDayAwardsList()
        {
            sortDayAwardslist.Clear();
            sortDayAwardslist.AddRange(dayAwardTypelist);
            sortDayAwardslist.Sort(CompareByCompleteProgress);
        }

        public int CompareByCompleteProgress(AwardType start,AwardType end)
        {
            int x = (int)start.progress;
            int y = (int)end.progress;
            if (x.CompareTo(y) != 0) return x.CompareTo(y);

            x = dayAwardTypelist.IndexOf(start);
            y = dayAwardTypelist.IndexOf(end);
            if (x.CompareTo(y) != 0) return x.CompareTo(y);

            return 0;
        }

        #region 表数据
        public int freeMaxMatchNum { get; private set; } //每日免费匹配次数
        public int buyMaxMatchNum { get; private set; } //每日可购买次数
        public string priceFormula { get;private set;} //购买匹配次数需要价格公式
        public string winStreakScoreFormula { get; private set; } //连胜积分公式
        public List<AwardType> dayAwardTypelist { get; private set; }
        private void ParseFuncConfig()
        {
            var CrossRealmPKAward = Config.Instance.Get<FuncConfigConfig>("CrossRealmPKAward");
            var dayMatchAwardData = JsonMapper.ToObject(CrossRealmPKAward.Numerical1);
            var dayWinAwardData = JsonMapper.ToObject(CrossRealmPKAward.Numerical2);
            dayAwardTypelist = new List<AwardType>();
            int dayWinIndex = 0;
            foreach (var num in dayWinAwardData.Keys)
            {
                int times = int.Parse(num);
                var items = dayWinAwardData[num];
                var awardType = new AwardType(times,1,dayWinIndex);
                dayAwardTypelist.Add(awardType);
                if (items.IsArray)
                {
                    for(int i = 0; i < items.Count; i++)
                    {
                        var itemInfo = items[i];
                        if(itemInfo.IsArray && itemInfo.Count >= 3)
                        {
                            int id = 0;
                            int.TryParse(itemInfo[0].ToString(), out id);
                            int count = 0;
                            int.TryParse(itemInfo[1].ToString(), out count);
                            int isBind = 0;
                            int.TryParse(itemInfo[2].ToString(), out isBind);
                            AwardItem awardItem = new AwardItem(id, count, isBind);
                            awardType.SetAwardItems(awardItem);
                        }
                    }
                }

                dayWinIndex += 1;
            }

            int dayPkIndex = 0;
            foreach (var num in dayMatchAwardData.Keys)
            {
                int times = int.Parse(num);
                var items = dayMatchAwardData[num];
                var awardType = new AwardType(times,2,dayPkIndex);
                dayAwardTypelist.Add(awardType);
                if (items.IsArray)
                {
                    for(int i = 0;i < items.Count; i++)
                    {
                        var itemInfo = items[i];
                        if (itemInfo.IsArray && itemInfo.Count >= 3)
                        {
                            int id = 0;
                            int.TryParse(itemInfo[0].ToString(), out id);
                            int count = 0;
                            int.TryParse(itemInfo[1].ToString(), out count);
                            int isBind = 0;
                            int.TryParse(itemInfo[2].ToString(), out isBind);
                            AwardItem awardItem = new AwardItem(id, count, isBind);
                            awardType.SetAwardItems(awardItem);
                        }
                    }
                }

                dayPkIndex += 1;
            }

            var CrossRealmPKMatchCount = Config.Instance.Get<FuncConfigConfig>("CrossRealmPKMatchCount");
            freeMaxMatchNum = int.Parse(CrossRealmPKMatchCount.Numerical1);
            buyMaxMatchNum = int.Parse(CrossRealmPKMatchCount.Numerical2);
            priceFormula = CrossRealmPKMatchCount.Numerical3;

            var CrossRealmPKScore = Config.Instance.Get<FuncConfigConfig>("CrossRealmPKScore");
            winStreakScoreFormula = CrossRealmPKScore.Numerical3;
        }

        public class AwardType
        {
            public int type { get; private set; } //1 胜利奖励 2 匹配奖励 
            public int index { get; private set; }
            public int num { get; private set;}
            public int curCompletedNum { get; private set; }
            public CompleteProgress progress { get; private set;}
            public bool IsReceived { get; set; }
            public List<AwardItem> awardItems = new List<AwardItem>();
            public AwardType(int _num,int _type,int _index)
            {
                type = _type;
                num = _num;
                index = _index;
                curCompletedNum = 0;
                IsReceived = false;
                progress = CompleteProgress.Completed;
                awardItems.Clear();
            }

            public void SetAwardItems(AwardItem awardItem)
            {
                awardItems.Add(awardItem);
            }

            public void SetCompletedNum(int completedNum)
            {
                curCompletedNum = completedNum;
                if(IsReceived)
                {
                    curCompletedNum = num;
                    progress = CompleteProgress.AlreadyReceived;
                }
                else
                {
                    progress = curCompletedNum < num ? CompleteProgress.UnCompleted : CompleteProgress.Completed;
                }
            }

            public enum CompleteProgress
            {
                Completed = 0, //已达成
                UnCompleted = 1, //未达成
                AlreadyReceived = 2, //已领取
            }
        }

        public struct AwardItem
        {
            public int itemId;
            public int itemCount;
            public int isBind;
            public AwardItem(int _id,int _count,int _isBind)
            {
                itemId = _id;
                itemCount = _count;
                isBind = _isBind;
            }
        }
        #endregion

        #region 协议
        public CrossServerOneVsOnePkResult pkResultInfo { get; private set;}
        public event Action UpdatePkResultEvent;
        public void UpdatePKResultInfo(HC003_tagGCCrossRealmPKOverInfo pKOverInfo)
        {
            pkResultInfo = new CrossServerOneVsOnePkResult();
            pkResultInfo.UpdatePkResult(pKOverInfo);
            SetPkInfoLocalSave(pkResultInfo);
            if(UpdatePkResultEvent != null)
            {
                UpdatePkResultEvent();
            }
        }

        /// <summary>
        ///0-取消匹配; 1-进行匹配
        /// </summary>
        /// <param name="type"></param>
        public void SendCrossMatch(int type)
        {
            CC101_tagCMCrossRealmPKMatch match = new CC101_tagCMCrossRealmPKMatch();
            match.Type = (byte)type;
            GameNetSystem.Instance.SendInfo(match);
        }

        public void SendBuyMatchCount()
        {
            CC102_tagCMCrossRealmPKBuy pKBuy = new CC102_tagCMCrossRealmPKBuy();
            GameNetSystem.Instance.SendInfo(pKBuy);
        }
        #endregion

        #region 匹配记录

        private void GetLocalSaveData()
        {
            localSaveResults = new List<CrossServerOneVsOnePkResult>();
            string[] localJsons = LocalSave.GeStringArray(PkResultLocalSaveKey);
            if(localJsons != null)
            {
                for(int i = 0; i < localJsons.Length; i++)
                {
                    CrossServerOneVsOnePkResult resultInfo = JsonMapper.ToObject<CrossServerOneVsOnePkResult>(localJsons[i]);
                    localSaveResults.Add(resultInfo);
                }
            }
        }

        public void SetPkInfoLocalSave(CrossServerOneVsOnePkResult resultInfo)
        {
            if (localSaveResults.Count >= 30)
            {
                localSaveResults.RemoveAt(localSaveResults.Count - 1);
            }
            localSaveResults.Insert(0,resultInfo);
            string[] localJsons = new string[localSaveResults.Count];
            for(int i = 0; i < localJsons.Length; i++)
            {
                string json = JsonMapper.ToJson(localSaveResults[i]);
                localJsons[i] = json;
            }
            LocalSave.SetStringArray(PkResultLocalSaveKey,localJsons);
        }

        #endregion

        #region 红点
        public const int CrossArenaRedKey = 2130101;
        public Redpoint crossArenaRedpoint = new Redpoint(CrossArenaRedKey);
        public const int CrossDayAwardsRedKey = 21301011;
        public Redpoint crossDayAwardsRedpoint = new Redpoint(CrossArenaRedKey,CrossDayAwardsRedKey);
        public const int CrossMatchRedKey = 21301012;
        public Redpoint crossMatchRedpoint = new Redpoint(CrossArenaRedKey, CrossMatchRedKey);
        public void UpdateCrossArenaRedpoint()
        {
            var playerInfo = CrossServerOneVsOnePlayerInfo.Instance;
            var pkSeason = CrossServerOneVsOnePKSeason.Instance;

            if(pkSeason.InDay(TimeUtility.ServerNow) 
                && pkSeason.InOpenTime()
                && playerInfo.GetDayRemainNum() > 0)
            {
                crossMatchRedpoint.state = RedPointState.Simple;
            }
            else
            {
                crossMatchRedpoint.state = RedPointState.None;
            }

         
            bool isReceive = false;
            for(int i = 0; i < dayAwardTypelist.Count; i++)
            {
                var awardType = dayAwardTypelist[i];
                if(awardType.progress == AwardType.CompleteProgress.Completed)
                {
                    isReceive = true;
                    break;
                }
            }

            if(isReceive)
            {
                crossDayAwardsRedpoint.state = RedPointState.Simple;
            }
            else
            {
                crossDayAwardsRedpoint.state = RedPointState.None;
            }
        }
        #endregion
    }
}