//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Thursday, December 21, 2017
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System;

using LitJson;

namespace Snxxz.UI
{

    [XLua.LuaCallCSharp]
    public class DemonJarModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize, ISwitchAccount, IPlayerLoginOk
    {
        public const int TOTALTIME_LIMIT = 5;

        public const int DEMONJAR_SINGLEMAPID = 52020;
        public const int DEMONJAR_MAPID = 52010;
        public const int DEMONJAR_REDPOINTID = 77001;

        public Redpoint redpoint = new Redpoint(FindPreciousModel.LOOTPRECIOUs_REDPOINTID, DEMONJAR_REDPOINTID);

        public bool oldDouble = false;

        bool m_IsDoubleAward = false;
        public bool isDoubleAward {
            get { return m_IsDoubleAward; }
            set {
                if (m_IsDoubleAward != value)
                {
                    m_IsDoubleAward = value;

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

        bool m_AutoChallenge = false;
        public bool autoChallenge {
            get { return m_AutoChallenge; }
            set {
                if (m_AutoChallenge != value)
                {
                    m_AutoChallenge = value;
                    if (autoChallengeChangeEvent != null)
                    {
                        autoChallengeChangeEvent();
                    }
                }
            }
        }

        public int autoChallengeBoss { get; set; }
        public bool doubleToKillLowerBossHint { get; set; }
        public bool lockSelectedBoss = false;

        int m_SelectedBoss = 0;
        public int selectedBoss {
            get {
                return this.m_SelectedBoss;
            }
            set {
                if (this.m_SelectedBoss != value)
                {
                    this.m_SelectedBoss = value;
                    if (bossSelectedEvent != null)
                    {
                        bossSelectedEvent(value);
                    }
                }
            }
        }

        int demonJarSoulBuf = 0;
        public int demonJarSoulIncreaseDelta { get; set; }

        public event Action<int> bossSelectedEvent;
        public event Action<int> participantChangeEvent;
        public event Action doubleAwardChangeEvent;
        public event Action autoChallengeChangeEvent;

        List<int> sortedBossIds = new List<int>();
        Dictionary<int, DemonJarBossData> demonBosses = new Dictionary<int, DemonJarBossData>();
        Dictionary<int, int> lineToBoss = new Dictionary<int, int>();

        List<AutoChallengeLog> autoChallengeLogs = new List<AutoChallengeLog>();

        FindPreciousModel findPreciousModel { get { return ModelCenter.Instance.GetModel<FindPreciousModel>(); } }
        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
        TreasureModel treasureModel { get { return ModelCenter.Instance.GetModel<TreasureModel>(); } }

        public override void Init()
        {
            doubleToKillLowerBossHint = true;
            ParseConfig();

            dungeonModel.dungeonRecordChangeEvent += OnDungeonRecordUpdate;
            dungeonModel.updateDungeonBuyCnt += OnDungeonBuyCount;
        }

        public override void UnInit()
        {
            dungeonModel.dungeonRecordChangeEvent -= OnDungeonRecordUpdate;
            dungeonModel.updateDungeonBuyCnt -= OnDungeonBuyCount;
        }

        public void OnBeforePlayerDataInitialize()
        {
            PlayerDatas.Instance.playerDataRefreshEvent -= OnPlayerLevelUp;
            ModelCenter.Instance.GetModel<MapModel>().mapLinesUpdateEvent -= OnMapLineUpdateEvent;
        }

        public void OnAfterPlayerDataInitialize()
        {
            var bossId = GetLatestUnLockBoss();
            if (bossId != 0 && !findPreciousModel.IsBossSubscribed(bossId))
            {
                findPreciousModel.RequestSubscribeBoss(bossId, true);
            }

            PlayerDatas.Instance.playerDataRefreshEvent += OnPlayerLevelUp;
            ModelCenter.Instance.GetModel<MapModel>().mapLinesUpdateEvent += OnMapLineUpdateEvent;
        }

        public void OnPlayerLoginOk()
        {
            demonJarSoulIncreaseDelta = 0;

            var bossId = GetLatestUnLockBoss();
            AutoSubscribeLastUnLockBoss(bossId);
            ParseLocalSaveAutoChallengeLogs();
            DemonJarAutoChallenge.Instance.Begin();
        }

        public void OnSwitchAccount()
        {
            doubleToKillLowerBossHint = true;
            autoChallenge = false;
        }

        public bool TryGetBossData(int _bossId, out DemonJarBossData _data)
        {
            return demonBosses.TryGetValue(_bossId, out _data);
        }

        public void RequestSetDoubleAward(bool _double)
        {
            var send = new CB103_tagCMSetFMTDouble();
            send.IsDouble = (byte)(_double ? 1 : 0);

            GameNetSystem.Instance.SendInfo(send);
        }

        public List<int> GetDemonJarBosses()
        {
            var dungeonModel = ModelCenter.Instance.GetModel<DungeonModel>();
            var bosses = new List<int>();
            for (int i = 0; i < sortedBossIds.Count; i++)
            {
                var bossId = sortedBossIds[i];
                var config = DemonJarConfig.Get(bossId);

                var grade = dungeonModel.GetGrade(new Dungeon(DEMONJAR_MAPID, config.LineID));
                if (config.CanEnterTimes > 0 && grade > 0)
                {
                    continue;
                }

                bosses.Add(bossId);
            }

            return new List<int>(bosses);
        }

        public int GetBossIdByLine(int _line)
        {
            if (lineToBoss.ContainsKey(_line))
            {
                return lineToBoss[_line];
            }
            else
            {
                return 0;
            }
        }

        public bool IsBossUnLocked(int _bossId)
        {
            var playerLevel = PlayerDatas.Instance.baseData.LV;
            return demonBosses.ContainsKey(_bossId) && playerLevel >= demonBosses[_bossId].unLockLevel;
        }

        public int GetLatestUnLockBoss()
        {
            if (FuncOpen.Instance.IsFuncOpen(76))
            {
                var latestBossId = sortedBossIds[0];
                for (int i = sortedBossIds.Count - 1; i >= 0; i--)
                {
                    var bossId = sortedBossIds[i];
                    if (demonBosses[bossId].unLockLevel <= PlayerDatas.Instance.baseData.LV)
                    {
                        latestBossId = bossId;
                        break;
                    }
                }

                return latestBossId;
            }
            else
            {
                return sortedBossIds[0];
            }
        }

        public int GetSurplusTimes()
        {
            var totalTimes = dungeonModel.GetTotalTimes(DEMONJAR_MAPID);
            var enterTimes = dungeonModel.GetEnterTimes(DEMONJAR_MAPID);

            return totalTimes - enterTimes;
        }

        public bool IsPersonalBoss(int _bossId)
        {
            if (DemonJarConfig.Has(_bossId))
            {
                var config = DemonJarConfig.Get(_bossId);
                return config.CanEnterTimes != 0;
            }
            else
            {
                return false;
            }
        }

        public List<FakeBossKillRecord> GetFakeBossKillRecords(int _bossId)
        {
            var records = new List<FakeBossKillRecord>();
            var killTime = DateTime.Now;
            var config = DemonJarConfig.Get(_bossId);

            for (int i = 0; i < 5; i++)
            {
                var index = (byte)(UnityEngine.Random.Range(0, GeneralDefine.openJobs.Length));
                var playerName = StringUtility.Contact(RandomNameConfig.GetFirstName(1), RandomNameConfig.GetSecondName(1));

                var exitFakePlayer = false;
                for (int j = 0; j < records.Count; j++)
                {
                    var fakePlayer = records[j];
                    if (fakePlayer.playerName == playerName)
                    {
                        exitFakePlayer = true;
                        break;
                    }
                }

                if (!exitFakePlayer)
                {
                    killTime -= new TimeSpan(UnityEngine.Random.Range(3, 5) * TimeSpan.TicksPerMinute);
                    records.Add(new FakeBossKillRecord(playerName, killTime, UnityEngine.Random.Range(config.KillHurtMin, config.KillHurtMax)));
                }
            }

            return records;
        }

        public void UpdateAutoChallengeLogs()
        {
            autoChallengeLogs.Sort(AutoChallengeLog.SortPredicate);
        }

        private void ParseLocalSaveAutoChallengeLogs()
        {
            autoChallengeLogs.Clear();
            var localSaves = LocalSave.GeStringArray(StringUtility.Contact("DemonJarAutoChallengeLog_", PlayerDatas.Instance.PlayerId));
            if (localSaves != null)
            {
                for (var i = 0; i < localSaves.Length; i++)
                {
                    var log = JsonMapper.ToObject<AutoChallengeLog>(localSaves[i]);
                    if ((TimeUtility.ServerNow - log.time).TotalDays <= 2)
                    {
                        autoChallengeLogs.Add(JsonMapper.ToObject<AutoChallengeLog>(localSaves[i]));
                    }
                }
            }
        }

        public void AddAutoChallengeLog(int bossId, bool isDouble, int rank)
        {
            var newLog = new AutoChallengeLog()
            {
                bossId = bossId,
                isDouble = isDouble,
                rank = rank,
                time = TimeUtility.ServerNow
            };

            autoChallengeLogs.Add(newLog);
            for (var i = autoChallengeLogs.Count - 1; i >= 0; i--)
            {
                var log = autoChallengeLogs[i];
                if ((TimeUtility.ServerNow - log.time).TotalDays > 2)
                {
                    autoChallengeLogs.RemoveAt(i);
                }
            }

            var jsons = new string[autoChallengeLogs.Count];
            for (var i = 0; i < autoChallengeLogs.Count; i++)
            {
                jsons[i] = JsonMapper.ToJson(autoChallengeLogs[i]);
            }

            LocalSave.SetStringArray(StringUtility.Contact("DemonJarAutoChallengeLog_", PlayerDatas.Instance.PlayerId), jsons);
        }

        public List<AutoChallengeLog> GetAutoChallengeLogs()
        {
            return new List<AutoChallengeLog>(autoChallengeLogs);
        }

        public void UpdateDemonJarSoul()
        {
            //demonJarSoulIncreaseDelta = demonJarSoul - demonJarSoulBuf;
            //demonJarSoulBuf = demonJarSoul;
        }

        private void OnPlayerLevelUp(PlayerDataType _type)
        {
            switch (_type)
            {
                case PlayerDataType.LV:
                    if (FuncOpen.Instance.IsFuncOpen(76))
                    {
                        var bossId = GetLatestUnLockBoss();
                        AutoSubscribeLastUnLockBoss(bossId);
                    }

                    if (PlayerDatas.Instance.baseData.LV == GeneralDefine.demonJarRedPoint)
                    {
                        UpdateRedpoint();
                    }
                    break;
            }
        }

        private void UpdateRedpoint()
        {
            if (FuncOpen.Instance.IsFuncOpen(76))
            {
                var count = dungeonModel.GetTotalTimes(DEMONJAR_MAPID) - dungeonModel.GetEnterTimes(DEMONJAR_MAPID);
                redpoint.count = count;
            }
            else
            {
                redpoint.count = 0;
            }

            redpoint.state = redpoint.count > 0 ? RedPointState.Quantity : RedPointState.None;
        }

        private void OnMapLineUpdateEvent(int _mapId)
        {
            if (_mapId != DEMONJAR_MAPID)
            {
                return;
            }

            foreach (var boss in demonBosses.Values)
            {
                if (boss.participant != 0)
                {
                    boss.participant = 0;
                    if (participantChangeEvent != null)
                    {
                        participantChangeEvent(boss.id);
                    }
                }
                else
                {
                    boss.participant = 0;
                }
            }

            var mapModel = ModelCenter.Instance.GetModel<MapModel>();
            var lines = mapModel.GetMapLines(DEMONJAR_MAPID);
            for (int i = 0; i < sortedBossIds.Count; i++)
            {
                var bossId = sortedBossIds[i];
                var bossConfig = DemonJarConfig.Get(bossId);
                if (bossConfig == null)
                {
                    continue;
                }

                for (int j = 0; j < lines.Count; j++)
                {
                    if (lines[j].lineIndex == bossConfig.LineID)
                    {
                        demonBosses[bossId].participant = lines[j].playerCount;
                        if (participantChangeEvent != null)
                        {
                            participantChangeEvent(bossId);
                        }
                        break;
                    }
                }
            }

        }

        private void OnDungeonRecordUpdate(int _dataMapId)
        {
            if (DEMONJAR_MAPID == _dataMapId && PlayerDatas.Instance.baseData.LV >= GeneralDefine.demonJarRedPoint)
            {
                UpdateRedpoint();
            }
        }

        private void OnDungeonBuyCount()
        {
            if (PlayerDatas.Instance.baseData.LV >= GeneralDefine.demonJarRedPoint)
            {
                UpdateRedpoint();
            }
        }

        private void AutoSubscribeLastUnLockBoss(int _bossId)
        {
            if (_bossId == 0)
            {
                return;
            }

            foreach (var boss in demonBosses.Values)
            {
                if (this.findPreciousModel.IsBossAutoSubscribe(boss.id) && boss.id != _bossId)
                {
                    this.findPreciousModel.RequestDeSubscribeBoss(boss.id);
                }
            }

            if (_bossId != 0 && this.findPreciousModel.IsBossNeverSubscribe((int)_bossId))
            {
                var npcConfig = NPCConfig.Get((int)_bossId);
                if (PlayerDatas.Instance.baseData.LV >= npcConfig.NPCLV)
                {
                    var config = DemonJarConfig.Get((int)_bossId);
                    if (config.AutoAttention == 1)
                    {
                        this.findPreciousModel.RequestSubscribeBoss((int)_bossId, true);
                        var model = ModelCenter.Instance.GetModel<DungeonModel>();
                        var grade = model.GetGrade(new Dungeon(DEMONJAR_MAPID, config.LineID));
                        if ((config.CanEnterTimes == 0 || grade == 0) && this.findPreciousModel.IsBossAlive((int)_bossId))
                        {
                            this.findPreciousModel.AddOneBossRebornNotify(_bossId);
                        }
                    }
                }
            }
        }

        private void ParseConfig()
        {
            var demonJarConfigs = DemonJarConfig.GetValues();
            foreach (var config in demonJarConfigs)
            {
                var bossData = demonBosses[config.NPCID] = new DemonJarBossData(config.NPCID);
                var npcConfig = NPCConfig.Get(config.NPCID);
                bossData.unLockLevel = npcConfig.NPCLV;
                lineToBoss[config.LineID] = config.NPCID;
            }

            sortedBossIds.AddRange(demonBosses.Keys);
            sortedBossIds.Sort((int a, int b) =>
            {
                var data1 = demonBosses[a];
                var data2 = demonBosses[b];
                return DemonJarBossData.UnLockLevelCompare(data1, data2);
            });
        }

        public struct FakeBossKillRecord
        {
            public string playerName;
            public DateTime killTime;
            public long hurt;

            public FakeBossKillRecord(string _playerName, DateTime _killTime, int _hurt)
            {
                playerName = _playerName;
                killTime = _killTime;
                hurt = _hurt;
            }

            public override string ToString()
            {
                return Language.Get("FightTreasure_KillTime", killTime.ToString("HH:mm:ss"), playerName);
            }

        }

        public struct AutoChallengeLog
        {
            public int bossId;
            public DateTime time;
            public bool isDouble;
            public int rank;

            public AutoChallengeLog(string dateTime)
            {
                this.bossId = 1000000;
                DateTime.TryParse("", out time);
                this.isDouble = true;
                this.rank = 1;
            }

            public static int SortPredicate(AutoChallengeLog lhs, AutoChallengeLog rhs)
            {
                return lhs.time < rhs.time ? -1 : 1;
            }

        }

    }

    public class DemonJarBossData
    {
        public int id { get; private set; }
        public int unLockLevel { get; set; }
        public int participant { get; set; }

        public DemonJarBossData(int _id)
        {
            this.id = _id;
        }

        public static int UnLockLevelCompare(DemonJarBossData _lhs, DemonJarBossData _rhs)
        {
            return _lhs.unLockLevel < _rhs.unLockLevel ? -1 : 1;
        }
    }



}