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

namespace Snxxz.UI
{
    public class VipInvestModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk, IOpenServerActivity
    {
        private Dictionary<string, Dictionary<string, List<InvestReward>>> vipInvestDict = new Dictionary<string, Dictionary<string, List<InvestReward>>>();
        private Dictionary<int, List<InvestConfig>> investCycleDict = new Dictionary<int, List<InvestConfig>>(); //每周期数据
        private Dictionary<string, int[]> vipInvestLvlimitDict = new Dictionary<string, int[]>();
        private Dictionary<int, int[]> investGoldDict = new Dictionary<int, int[]>();
        private Dictionary<int, int> investMaxDayDict = new Dictionary<int, int>();
        public int NeedVipLv { get; private set; }

        public bool IsOpen
        {
            get
            {
               return  FuncOpen.Instance.IsFuncOpen(120);
            }
        }

        public bool priorityOpen
        {
            get
            {
                if (redPointStre1.state == RedPointState.None)
                {
                    return false;
                }
                else
                {
                    return true;
                }
            }

        }

        public bool IsAdvance
        {
            get
            {
                return false;
            }
        }

        private bool IsOkBool = false;
        public bool IsRedpoint = false;

        private int DisplayLevel = 0;//显示等级
        private int DisplayDays = 0;//显示天数
        //----
        public override void Init()
        {
            vipInvestDict.Clear();
            investCycleDict.Clear();
            vipInvestLvlimitDict.Clear();
            investGoldDict.Clear();
            investMaxDayDict.Clear();
            OpenServerActivityCenter.Instance.Register(11, this);
            var InvestRedPoint = Config.Instance.Get<FuncConfigConfig>("InvestRedPoint");
            DisplayLevel = int.Parse(InvestRedPoint.Numerical1);
            DisplayDays = int.Parse(InvestRedPoint.Numerical3);
            FuncConfigConfig vipInvestLv = Config.Instance.Get<FuncConfigConfig>("VIPInvest");
            NeedVipLv = int.Parse(vipInvestLv.Numerical2);
            JsonData vipInvestData = JsonMapper.ToObject(vipInvestLv.Numerical1);
            foreach (var index in vipInvestData.Keys)
            {
                if (vipInvestData[index].IsArray)
                {
                    int[] lvs = new int[vipInvestData[index].Count];
                    vipInvestLvlimitDict.Add(index, lvs);
                    for (int i = 0; i < vipInvestData[index].Count; i++)
                    {
                        lvs[i] = int.Parse(vipInvestData[index][i].ToString());
                    }
                }
            }
            FuncConfigConfig InvestGold = Config.Instance.Get<FuncConfigConfig>("InvestCost");
            JsonData goldData = JsonMapper.ToObject(InvestGold.Numerical1);
            foreach (var type in goldData.Keys)
            {
                if (goldData[type].IsArray)
                {
                    int[] golds = new int[goldData[type].Count];
                    investGoldDict.Add(int.Parse(type), golds);
                    for (int i = 0; i < goldData[type].Count; i++)
                    {
                        golds[i] = int.Parse(goldData[type][i].ToString());
                    }
                }
            }
            FuncConfigConfig maxDay = Config.Instance.Get<FuncConfigConfig>("InvestMaxDay");
            JsonData maxDayData = JsonMapper.ToObject(maxDay.Numerical1);
            foreach (var type in maxDayData.Keys)
            {
                investMaxDayDict.Add(int.Parse(type), int.Parse(maxDayData[type].ToString()));
            }

            List<InvestConfig> investlist = Config.Instance.GetAllValues<InvestConfig>();
            if (investlist != null)
            {
                for (int i = 0; i < investlist.Count; i++)
                {
                    SetVipInvestModel(investlist[i]);
                }
            }
        }

        public void OnBeforePlayerDataInitialize()
        {
            IsRedpoint = false;
            IsOkBool = false;
            serverInvestDict.Clear();
        }
        public void OnPlayerLoginOk()
        {
            IsOkBool = true;
            VipInvestRedPoint();
            VipInvestWin.VipInvestRedPointEvent -= VipInvestRedPointEvent;
            VipInvestWin.VipInvestRedPointEvent += VipInvestRedPointEvent;
            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
            IsShowRedPointSimple();
        }

        private void OnFuncStateChangeEvent(int funcOpenID)
        {
            if (funcOpenID == 120)
            {
                IsShowRedPointSimple();
            }
        }
        private void VipInvestRedPointEvent()
        {
            RedPointSate();
        }

        private void SetVipInvestModel(InvestConfig config)
        {
            InvestType type = (InvestType)config.type;
            if (type != InvestType.Vip) return;

            string key = StringUtility.Contact(config.id, config.type, config.needDay);
            int cycle = GetInvestCycle(config.needDay);

            if (!investCycleDict.ContainsKey(cycle))
            {
                List<InvestConfig> list = new List<InvestConfig>();
                list.Add(config);
                investCycleDict.Add(cycle, list);
            }
            else
            {
                investCycleDict[cycle].Add(config);
            }

            if (!vipInvestDict.ContainsKey(key))
            {
                Dictionary<string, List<InvestReward>> rewardDict = new Dictionary<string, List<InvestReward>>();
                vipInvestDict.Add(key, rewardDict);
                JsonData jsonData = JsonMapper.ToObject(config.award);
                foreach (var index in jsonData.Keys)
                {
                    List<InvestReward> rewardlist = new List<InvestReward>();
                    rewardDict.Add(index, rewardlist);
                    if (jsonData[index].IsArray)
                    {
                        for (int i = 0; i < jsonData[index].Count; i++)
                        {
                            JsonData itemData = jsonData[index][i];
                            if (itemData.IsArray)
                            {
                                InvestReward reward = new InvestReward(int.Parse(itemData[0].ToString()), ulong.Parse(itemData[1].ToString())
                                    , int.Parse(itemData[2].ToString()));
                                rewardlist.Add(reward);
                            }
                        }
                    }
                }
            }
            else
            {
                DebugEx.Log("投资表key值重复" + config.id);
            }
        }

        public List<InvestReward> GetInvestRewardlistByID(int id, int type, int day, string index)
        {
            List<InvestReward> rewardlist = null;
            string key = StringUtility.Contact(id, type, day);
            if (vipInvestDict.ContainsKey(key))
            {
                vipInvestDict[key].TryGetValue(index, out rewardlist);
            }
            return rewardlist;
        }

        public List<InvestConfig> GetInvestConfiglistByCycle(int cycle)
        {
            List<InvestConfig> list = null;
            investCycleDict.TryGetValue(cycle, out list);
            return list;
        }

        public int GetInvestGold(int type, int index)
        {
            if (investGoldDict.ContainsKey(type))
            {
                return investGoldDict[type][index];
            }
            return 0;
        }

        public string GetVipInvestIndex()
        {
            int playeLv = PlayerDatas.Instance.baseData.LV;
            foreach (var index in vipInvestLvlimitDict.Keys)
            {
                int[] lvs = vipInvestLvlimitDict[index];
                if (lvs[lvs.Length - 1] >= playeLv)
                {
                    return index;
                }
            }
            return "";
        }

        public int GetMaxDay(InvestType type)
        {
            int day = 0;
            investMaxDayDict.TryGetValue((int)type, out day);
            return day;
        }

        #region 处理服务端的数据
        private Dictionary<int, ServerInvestInfo> serverInvestDict = new Dictionary<int, ServerInvestInfo>();
        public event Action<int> RefreshInvestAct;
        public event Action<int> onStateUpate;

        public void SetServerInvestInfo(HA337_tagMCGoldInvestInfo info)
        {

            if (info.InvestType == 2)
            {
                if (!serverInvestDict.ContainsKey(info.InvestType))
                {
                    ServerInvestInfo investInfo = new ServerInvestInfo();
                    investInfo.type = info.InvestType;
                    investInfo.curDay = (int)info.CurDay;
                    investInfo.investGold = (int)info.InvestGold;

                    if (info.RewardRecordCnt > 1)
                    {
                        investInfo.recordlist = new List<RewardRecord>();
                        investInfo.recordlist.Clear();
                        for (int i = 0; i < info.RewardRecordCnt; i++)
                        {
                            RewardRecord RewardRecord = new RewardRecord();
                            RewardRecord.rewardIndex = info.InvestRewardList[i].RewardIndex;
                            RewardRecord.rewardRecord = info.InvestRewardList[i].RewardValue;
                            investInfo.recordlist.Add(RewardRecord);
                        }
                    }
                    else
                    {
                        if (((int)info.CurDay - 1) < investInfo.recordlist.Count)
                        {
                            RewardRecord RewardRecord = new RewardRecord();
                            RewardRecord.rewardIndex = info.InvestRewardList[0].RewardIndex;
                            RewardRecord.rewardRecord = info.InvestRewardList[0].RewardValue;
                            investInfo.recordlist[((int)info.CurDay - 1)] = RewardRecord;
                        }
                    }
                    serverInvestDict.Add(info.InvestType, investInfo);
                }
                else
                {
                    var serverInvest = serverInvestDict[info.InvestType];
                    serverInvest.type = info.InvestType;
                    serverInvest.curDay = (int)info.CurDay;
                    serverInvest.investGold = (int)info.InvestGold;
                    if (info.RewardRecordCnt > 1)
                    {
                        if (serverInvest.recordlist.Count != 0)
                        {
                            serverInvest.recordlist.Clear();
                        }
                        for (int i = 0; i < info.RewardRecordCnt; i++)
                        {
                            RewardRecord RewardRecord = new RewardRecord();
                            RewardRecord.rewardIndex = info.InvestRewardList[i].RewardIndex;
                            RewardRecord.rewardRecord = info.InvestRewardList[i].RewardValue;
                            serverInvest.recordlist.Add(RewardRecord);
                        }

                    }
                    else
                    {
                        if (((int)info.CurDay - 1) < serverInvest.recordlist.Count)
                        {
                            RewardRecord RewardRecord = new RewardRecord();
                            RewardRecord.rewardIndex = info.InvestRewardList[0].RewardIndex;
                            RewardRecord.rewardRecord = info.InvestRewardList[0].RewardValue;
                            serverInvest.recordlist[((int)info.CurDay - 1)] = RewardRecord;
                        }
                    }
                    serverInvestDict[info.InvestType] = serverInvest;
                }

            }
            if (RefreshInvestAct != null)
            {
                RefreshInvestAct(info.InvestType);
            }
            if (IsOkBool)
            {
                VipInvestRedPoint();
            }
        }

        public ServerInvestInfo GetInvestInfoByType(int type)
        {
            ServerInvestInfo investInfo = default(ServerInvestInfo);
            serverInvestDict.TryGetValue(type, out investInfo);
            return investInfo;
        }

        public void SendGetInvestRewardQuest(int type, int index)
        {
            CA541_tagCMGetInvestReward investReward = new CA541_tagCMGetInvestReward();
            investReward.InvestType = (byte)type;
            investReward.RewardIndex = (byte)index;
            GameNetSystem.Instance.SendInfo(investReward);
        }

        public void SendInvestQuest(int type, int index)
        {
            int gold = GetInvestGold(type, index);
            DebugEx.Log("SendInvestQuest:" + gold);
            CA540_tagCMGoldInvest investGold = new CA540_tagCMGoldInvest();
            investGold.InvestType = (byte)type;
            investGold.InvestGold = (uint)gold;
            GameNetSystem.Instance.SendInfo(investGold);
        }
        #endregion

        public RewardRecordState GetRecordByIndex(int type, int day)
        {
            ServerInvestInfo investInfo = GetInvestInfoByType(type);
            if (investInfo.investGold <= 0) return RewardRecordState.None;
            if (investInfo.recordlist[day - 1].rewardRecord > 0)
            {
                return RewardRecordState.HaveReceive;
            }
            else
            {
                if (investInfo.curDay > day)
                {
                    return RewardRecordState.Miss;
                }
                else if (investInfo.curDay == day)
                {
                    return RewardRecordState.NoReceive;
                }
                else if (investInfo.curDay < day)
                {
                    return RewardRecordState.NoShow;
                }
                return RewardRecordState.NoReceive;
            }
        }

        public int GetInvestCycle(int day)
        {
            int cycle = 0;
            if (day % 7 != 0)
            {
                cycle = day / 7 + 1;
            }
            else
            {
                cycle = day / 7;
            }
            return cycle;
        }

        private int GetInvestCycle1(int Day1)
        {
            int cycle = 0;
            if (Day1 % 7 != 0)
            {
                cycle = Day1 % 7;
            }
            else
            {
                cycle = 7;
            }
            return cycle;
        }

        public override void UnInit()
        {

        }
        ServerInvestInfo InvestInfo;
        int cycle = 0;
        private List<InvestConfig> configlist;
        private const int Redpoint_key1 = 20911;
        public Redpoint redPointStre1 = new Redpoint(209, Redpoint_key1);//Vip 投资红点
        public int JumpIndex = 0;
        private void VipInvestRedPoint()//Vip 投资红点
        {
            JumpIndex = 0;
            redPointStre1.state = RedPointState.None;
            InvestInfo = GetInvestInfoByType((int)InvestType.Vip);
            cycle = GetInvestCycle(InvestInfo.curDay);
            if (InvestInfo.investGold <= 0)
            {
                cycle = 1;
            }
            configlist = GetInvestConfiglistByCycle(cycle);
            if (configlist == null)
            {
                return;
            }
            for (int i = 0; i < configlist.Count; i++)
            {
                InvestConfig config = configlist[i];
                RewardRecordState recordState = GetRecordByIndex((int)InvestType.Vip, config.needDay);
                if (recordState == RewardRecordState.NoReceive)
                {
                    redPointStre1.state = RedPointState.GetReward;                 
                    JumpIndex = i;
                    return;
                }
            }
            if (JumpIndex == 0)
            {
                for (int j = 0; j < configlist.Count; j++)
                {
                    InvestConfig config = configlist[j];
                    RewardRecordState recordState = GetRecordByIndex((int)InvestType.Vip, config.needDay);
                    if (recordState == RewardRecordState.NoShow)
                    {
                        JumpIndex = j;
                        return;
                    }
                }
            }
        }


        private void RedPointSate()//为投资红点
        {
            if (InvestInfo.investGold > 0)
            {
                return;
            }
            if (IsRedpoint)
            {
                redPointStre1.state = RedPointState.Simple;
            }
            else
            {
                VipInvestRedPoint();
            }
        }

        private void IsShowRedPointSimple()
        {
            int GetDayOfYear = DateTime.Now.DayOfYear;
            string strKey = "IsOpenVipRedPoint" + PlayerDatas.Instance.baseData.PlayerID;
            int day = LocalSave.GetInt(strKey);
            if (day != GetDayOfYear)
            {
                if (redPointStre1.state == RedPointState.None
                    && FuncOpen.Instance.IsFuncOpen(120))
                {
                    LocalSave.SetInt(strKey, GetDayOfYear);
                    IsRedpoint = true;
                    RedPointSate();
                }
            }
        }
    }



    public struct InvestReward
    {
        public int id { get; private set; }
        public ulong count { get; private set; }
        public int isBind { get; private set; }

        public InvestReward(int id, ulong count, int isBind)
        {
            this.id = id;
            this.count = count;
            this.isBind = isBind;
        }
    }

    public struct ServerInvestInfo
    {
        public int type;
        public int curDay;
        public int investGold;
        public List<RewardRecord> recordlist;
    }

    public struct RewardRecord
    {
        public int rewardIndex;
        public int rewardRecord;
    }

    public enum InvestType
    {
        None = 0, //无投资
        Month = 1, //月卡投资
        Vip = 2,  //Vip投资
        Gold = 3,  //仙玉投资
    }

    public enum RewardRecordState
    {
        None, //未投注
        NoReceive, //未领取
        HaveReceive, //已领取
        Miss, //已错过
        NoShow,//未到达
    }
}