// ***********************************************************************
// Assembly         : Game
// Author           : Kimch
// Created          : 2021-06-18
// Description      :
// Last Modified By : 
// Last Modified On : 
// ***********************************************************************
// <copyright file= "BattleResult" company="Kunpo"></copyright>
// <summary></summary>
// ***********************************************************************

using System.Collections.Generic;
using CodeStage.AntiCheat.ObscuredTypes;

namespace G
{
    /// <summary>
    /// 战斗结果
    /// </summary>
    public class BattleResult
    {
        public bool success;

        public int chapterId;

        private ObscuredInt _levelId;
        public int levelId
        {
            get => _levelId;
            set => _levelId = value;
        }

        private ObscuredInt _stageIndex;
        public int stageIndex
        {
            get => _stageIndex;
            set => _stageIndex = value;
        }

        private ObscuredInt _stageIndexMax;
        public int stageIndexMax
        {
            get => _stageIndexMax;
            set => _stageIndexMax = value;
        }

        public int dropBookId
        {
            get;
            set;
        }

        /// <summary>
        /// 
        /// </summary>
        public readonly List<EntityItemEquipment> equipments = new List<EntityItemEquipment>();
        /// <summary>
        /// 
        /// </summary>
        public readonly Dictionary<int, ObscuredInt> moneyDict = new Dictionary<int, ObscuredInt>();
        /// <summary>
        /// 
        /// </summary>
        public readonly Dictionary<int, ObscuredInt> propDict = new Dictionary<int, ObscuredInt>();

        /// <summary>
        /// 
        /// </summary>
        public ObscuredInt exp;

        /// <summary>
        /// 
        /// </summary>
        public ObscuredInt bossKilled;
        /// <summary>
        /// 
        /// </summary>
        public ObscuredInt minionKilled;

        public int playerDeath;
        public int playerHpPercent;

        public readonly Dictionary<int, int> skillDict = new Dictionary<int, int>();

        public int lastGrade;
        public int currGrade;
        public float lastExpRatio;
        public float currExpRatio;

        /// <summary>
        /// 
        /// </summary>
        public Callback2 callback;
        /// <summary>
        /// 秒
        /// </summary>
        public int duration;
        /// <summary>
        /// 
        /// </summary>
        public string reason;

        /// <summary>
        /// 
        /// </summary>
        public int source;

        /// <summary>
        /// 
        /// </summary>
        public int applyStep = -1;
        /// <summary>
        /// 
        /// </summary>
        public bool isValid
        {
            get { return applyStep != -1; }
        }

        /// <summary>
        /// 
        /// </summary>
        public int levelType
        {
            get { return ItemProxy.Instance.GetStaticItem<ItemLevel>(levelId).type; }
        }

        /// <summary>
        /// 无尽
        /// </summary>
        public bool infinity
        {
            get { return levelType == 2; }
        }

        /// <summary>
        /// 
        /// </summary>
        public bool isSword
        {
            get { return levelType == 4; }
        }

        /// <summary>
        /// 
        /// </summary>
        public bool isNormal
        {
            get { return levelType == 1; }
        }

        /// <summary>
        /// 扫荡
        /// </summary>
        public bool shortcut
        {
            get { return source == 1; }
            set { source = 1; }
        }

        public int coin
        {
            get
            {
                moneyDict.TryGetValue(Item.Id.kCoin, out var count);
                return count;
            }
            set
            {
                moneyDict[Item.Id.kCoin] = value;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <param name="amount"></param>
        public void AddMoney(int id, int amount)
        {
            if (moneyDict.TryGetValue(id, out var count))
                moneyDict[id] = count + amount;
            else
                moneyDict[id] = amount;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <param name="amount"></param>
        public void AddProp(int id, int amount)
        {
            if (amount < 100)
            {
                if (propDict.TryGetValue(id, out var count))
                    propDict[id] = count + amount;
                else
                    propDict[id] = amount;
            }
        }

        public void CastSkill(int skillId)
        {
            if (skillDict.TryGetValue(skillId, out var count))
                skillDict[skillId] = count + 1;
            else
                skillDict[skillId] = 1;
        }

        public void Reset()
        {

        }

        /// <summary>
        /// 
        /// </summary>
        private void ApplyResult()
        {
            foreach (var money in moneyDict)
            {
                MoneyProxy.Instance.AddMoney(money.Key, money.Value);
            }

            foreach (var prop in propDict)
            {
                var propItem = ItemProxy.Instance.GetStaticItem<ItemProp>(prop.Key);
                if (propItem.isGem)
                {
                    ItemProxy.Instance.AddGem(prop.Key, prop.Value);
                }
                else
                {
                    ItemProxy.Instance.AddProp(prop.Key, prop.Value);
                }
            }

            PlayerProxy.Instance.AddExp(exp);

            MissionProxy.Instance.OnEvent(MissionProxy.闯关次数, 1);
            MissionProxy.Instance.OnEvent(MissionProxy.击杀小怪数量, minionKilled);
            MissionProxy.Instance.OnEvent(MissionProxy.击杀大怪数量, bossKilled);
        }

        public void ApplyResult2()
        {
            foreach (var money in moneyDict)
            {
                MoneyProxy.Instance.AddMoney(money.Key, money.Value);
            }

            foreach (var prop in propDict)
            {
                var propItem = ItemProxy.Instance.GetStaticItem<ItemProp>(prop.Key);
                if (propItem.isGem)
                {
                    ItemProxy.Instance.AddGem(prop.Key, prop.Value);
                }
                else
                {
                    ItemProxy.Instance.AddProp(prop.Key, prop.Value);
                }
            }

            PlayerProxy.Instance.AddExp(exp);
        }

        /// <summary>
        /// 
        /// </summary>
        public void ApplyNormal()
        {
            if (applyStep >= 1)
                return;
            applyStep = 1;

            //lastGrade = PlayerProxy.Instance.grade;
            //lastExpRatio = PlayerProxy.Instance.expRatio;

            ApplyResult();

            //currGrade = PlayerProxy.Instance.grade;
            //currExpRatio = PlayerProxy.Instance.expRatio;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public bool ApplyTreble(IList<Item.ItemInfo> rewards)
        {
            if (applyStep >= 2)
                return false;

            applyStep = 2;

            MoneyProxy.Instance.AddCoin(coin * 2);
            rewards.Add(new Item.ItemInfo
            {
                id = Item.Id.kCoin,
                count = coin * 3,
            });

            foreach (var equipment in equipments)
            {
                BagProxy.Instance.NewEquipment(equipment.itemId);
                BagProxy.Instance.NewEquipment(equipment.itemId);

                rewards.Add(new Item.ItemInfo
                {
                    id = equipment.itemId,
                    count = 3,
                });
            }
            return true;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public bool ApplyDouble(IList<Item.ItemInfo> rewards)
        {
            if (applyStep >= 2)
                return false;
            applyStep = 2;

            ApplyResult();

            foreach (var equipment in equipments)
            {
                BagProxy.Instance.NewEquipment(equipment.itemId);
                rewards.Add(new Item.ItemInfo
                {
                    id = equipment.itemId,
                    count = 2,
                });
            }

            rewards.Add(new Item.ItemInfo
            {
                id = Item.Id.kCoin,
                count = coin * 2,
            });

            return true;
        }

        public bool ApplyMultiple(IList<Item.ItemInfo> rewards, int multiple)
        {
            multiple = UnityEngine.Mathf.Clamp(multiple, 1, 10);

            MoneyProxy.Instance.AddCoin(coin * 2);
            rewards.Add(new Item.ItemInfo
            {
                id = Item.Id.kCoin,
                count = coin * 3,
            });

            foreach (var equipment in equipments)
            {
                for (int i = 0; i < multiple; i++)
                {
                    BagProxy.Instance.NewEquipment(equipment.itemId);
                }

                rewards.Add(new Item.ItemInfo
                {
                    id = equipment.itemId,
                    count = multiple,
                });
            }

            return true;
        }
    }
}