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

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

namespace G
{
	/// <summary>
	/// 剑阁
	/// </summary>
	public class SwordProxy : F.GameProxy
	{
		/// <summary>
		/// 
		/// </summary>
		public class SwordInfo
		{
			public readonly ItemSword item;
			public int id => item.id;

			/// <summary>
			/// 
			/// </summary>
			public readonly List<CombatAttribute> attributes = new List<CombatAttribute>(2);

			private ObscuredInt _grade = 0;
			/// <summary>
			/// 等级
			/// </summary>
			public int grade
			{
				get { return _grade; }
				private set
				{
					if (value <= gradeMax && value != grade)
					{
						_grade = value;

						attributes.Clear();
						var gradeItem = ItemProxy.Instance.GetStaticItem<ItemSwordGrade>(value);
						if (gradeItem != null)
						{
							int[][] sources = null;
							switch (id)
							{
								case 1:
									sources = gradeItem.attributes1;
									break;
								case 2:
									sources = gradeItem.attributes2;
									break;
								case 3:
									sources = gradeItem.attributes3;
									break;
								case 4:
									sources = gradeItem.attributes4;
									break;
								case 5:
									sources = gradeItem.attributes5;
									break;
							}
							if (sources != null)
								for (int i = 0; i < sources.Length; i++)
								{
									attributes.Add(new CombatAttribute
									{
										id = (CombatAttributeId)sources[i][0],
										value = sources[i][1],
									});
								}
						}
					}
				}
			}

			/// <summary>
			/// 等级上限
			/// </summary>
			public int gradeMax
			{
				get;
				private set;
			}

			/// <summary>
			/// 
			/// </summary>
			public bool isMaxGrade => grade >= gradeMax;

			/// <summary>
			/// 
			/// </summary>
			public bool isUnlock
			{
				get
				{
					if (grade == 0 && item.unlock > 0)
					{
						var mission = MissionProxy.Instance.GetMission(item.unlock);
						if (mission != null && mission.isCompleted)
						{
							grade = 1;
							Instance.UpdateAttributes(true);
							return true;
						}
						return false;
					}
					return true;
				}
			}

			public bool CheckUnlock(bool updateAttributes)
			{
				if (grade == 0 && item.unlock > 0)
				{
					var mission = MissionProxy.Instance.GetMission(item.unlock);
					if (mission != null && mission.isCompleted)
					{
						grade = 1;
						return true;
					}
					return false;
				}
				return true;
			}

			public string unlockText
			{
				get
				{
					var mission = MissionProxy.Instance.GetMission(item.unlock);
					return mission != null ? mission.description : default;
				}
			}

			/// <summary>
			/// 
			/// </summary>
			public int combatValue
			{
				get
				{
					return item.combatValue[0] + item.combatValue[1] * this.grade;
				}
			}

			Item.ItemInfo _firstCostInfo;
			ObscuredInt _costAddition;

			public Item.ItemInfo upgradeCost
			{
				get
				{
					var result = _firstCostInfo;
					if (this.grade > 0)
						result.count += (this.grade - 1) * _costAddition;
					return result;
				}
			}

			/// <summary>
			/// 
			/// </summary>
			public int status
			{
				get { return this.grade; }
				set { this.grade = value; }
			}

			public SwordInfo(ItemSword swordItem)
			{
				this.item = swordItem;
				this.gradeMax = swordItem.gradeMax;
				if (swordItem.upgradeCost != null && swordItem.upgradeCost.Length > 2)
				{
					_firstCostInfo = Item.ItemInfo.Convert(swordItem.upgradeCost);
					_costAddition = swordItem.upgradeCost[2];
				}
			}

			/// <summary>
			/// 
			/// </summary>
			/// <returns></returns>
			public bool CheckUpgrade()
			{
				return this.grade > 0 && grade < gradeMax;
			}

			/// <summary>
			/// 
			/// </summary>
			/// <returns></returns>
			public int Upgrade()
			{
				if (grade > 0 && grade < gradeMax)
				{
					grade++;
					return 0;
				}
				return 1;
			}

			/// <summary>
			/// 
			/// </summary>
			/// <param name="results"></param>
			/// <returns></returns>
			public int GetAttributes(List<CombatAttribute> results)
			{
				if (grade > 0)
				{
					for (int i = 0; i < attributes.Count; i++)
					{
						var attr = attributes[i];
						results.Add(attr);
					}
				}
				return this.combatValue;
			}
		}

		#region Field

		private ItemSwordTitle _curTitle;
		private ItemSwordTitle _studyTitle;
		private readonly int[] _studyStars = new int[4];
		private int _studyTitleCombatValue;

		readonly Dictionary<int, SwordInfo> _swordInfos = new Dictionary<int, SwordInfo>(5);

		ObscuredInt _swordLevel;
		ObscuredInt _rewardTimestamp;
		Item.ItemInfo _minuteReward;

		#endregion

		#region Property

		/// <summary>
		/// 
		/// </summary>
		public int swordLevel
		{
			get { return _swordLevel; }
			private set
			{
				_swordLevel = value;
				var item = ItemProxy.Instance.GetStaticItem<ItemSwordLevel>(value);
				if (item != null)
				{
					_minuteReward = item.stationRewardInfos;
				}
			}
		}

		/// <summary>
		/// 
		/// </summary>
		public int swordLevelMax => 1000;

		/// <summary>
		/// 
		/// </summary>
		public ItemSwordLevel swordLevelItem
		{
			get => ItemProxy.Instance.GetStaticItem<ItemSwordLevel>(swordLevel);
		}

		public Item.ItemInfo completedReward
		{
			get
			{
				var swordLevelItem = ItemProxy.Instance.GetStaticItem<ItemSwordLevel>(Mathf.Clamp(swordLevel, 1, swordLevelMax));
				if (swordLevelItem != null)
				{
					return swordLevelItem.completedRewardInfos;
				}
				return default;
			}
		}

		/// <summary>
		/// 累计分钟数
		/// </summary>
		public int accumMinute => Mathf.Clamp((Launch.Timestamp - rewardTimestamp) / 60, 0, totalMinute);
		/// <summary>
		/// 
		/// </summary>
		public int totalMinute => 1440;
		/// <summary>
		/// 
		/// </summary>
		public int intervalMinute => 1;
		/// <summary>
		/// 
		/// </summary>
		public bool isFullReward => accumMinute >= totalMinute;
		/// <summary>
		/// 
		/// </summary>
		public bool isHalfReward => accumMinute >= (totalMinute / 2);

		public int rewardTimestamp
		{
			get { return _rewardTimestamp; }
			set
			{
				_rewardTimestamp = value;
			}
		}

		/// <summary>
		/// 
		/// </summary>
		public Item.ItemInfo minuteRewards
		{
			get { return _minuteReward; }
		}

		/// <summary>
		/// 
		/// </summary>
		public Item.ItemInfo adRewards
		{
			get
			{
				var result = _minuteReward;
				result.count *= 480;
				return result;
			}
		}

		#endregion

		#region Method

		/// <summary>
		/// 
		/// </summary>
		/// <returns></returns>
		public ItemSwordTitle GetTitle()
		{
			if (_curTitle == null)
			{
				SetTitle(1, true);
			}
			return _curTitle;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <returns></returns>
		public ItemSwordTitle GetStudyTitle()
		{
			return _studyTitle;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <returns></returns>
		public ItemSwordTitle SetStudyTitle()
		{
			var titles = ItemProxy.Instance.GetStaticItems<ItemSwordTitle>();
			for (int i = 0; i < titles.Count; i++)
			{
				var title = titles[i];
				if (title.studyAdd != null && title.studyAdd.Length > 0)
				{
					_studyTitle = title;
					return _studyTitle;
				}
			}
			return null;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="id"></param>
		/// <param name="save"></param>
		public void SetTitle(int id, bool save = true)
		{
			if (id > 0 && (_curTitle == null || _curTitle.id < id))
			{
				_curTitle = ItemProxy.Instance.GetStaticItem<ItemSwordTitle>(id);

				if (save)
				{
					UpdateAttributes(true);
					SaveSword();
					MissionProxy.Instance.OnEvent2(MissionProxy.境界达到X级, id);
				}
			}
		}

		/// <summary>
		/// 突破
		/// </summary>
		public void UpTitle()
		{
			var currTitle = GetTitle();
			if (currTitle != null && currTitle.isCompleted && currTitle.nextTitle != null)
			{
				currTitle = currTitle.nextTitle;
			}
			SetTitle(currTitle.id, true);
		}
		/// <summary>
		/// 
		/// </summary>
		/// <returns></returns>
		public int[] GetStudyStar()
		{
			return _studyStars;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <returns></returns>
		public int StudyTitle()
		{
			int max = 0;
			for (int i = 0; i < 4; i++)
			{
				if (_studyStars[i] < 10)
				{
					max++;
				}
			}

			if (max > 0)
			{
				int r = Random.Range(0, max);
				for (int i = 0; i < 4; i++)
				{
					if (_studyStars[i] < 10)
					{
						r -= 1;
						if (r < 0)
						{
							_studyStars[i] += 1;
							if (Random.value < GlobalVar.TitleStudyDouble)
							{
								SaveSword();
								UpdateAttributes(true);
								MissionProxy.Instance.OnEvent(MissionProxy.累计境界修炼X次);
								return 1;
							}
						}
					}
				}
				SaveSword();
				UpdateAttributes(true);
				MissionProxy.Instance.OnEvent(MissionProxy.累计境界修炼X次);
				return 2;
			}
			else
			{
				if (_studyTitle.id < _curTitle.id)
				{
					_studyTitle = _studyTitle.nextTitle;
					for (int i = 0; i < 4; i++)
					{
						_studyStars[i] = 0;
					}
					UpdateAttributes(true);
					SaveSword();
					return 3;
				}
			}
			return 0;
		}

		public int GetTitleCombatValue()
		{
			return PlayerProxy.Instance.GetCombatValue(PlayerProxy.ATTRIBUTES_INDEX_TITLE);
		}

		public int GetStudyCombatValue()
		{
			return _studyTitleCombatValue;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <returns></returns>
		public int GetTitleRedPoint()
		{
			var unlocked = FunctionProxy.Instance.GetFunctionUnlock(FunctionProxy.FunctionId.Jingjie);
			if (unlocked)
			{
				var currTitle = GetTitle();
				if (currTitle != null && currTitle.rewardMissionCount > 0)
				{
					return 1;
				}
			}
			return 0;
		}

		private void UpdateAttributes(bool sendNotification)
		{
			int combatValue = 0;

			var results = F.ListPool<CombatAttribute>.Get();
			if (_curTitle != null)
			{
				CombatAttribute.Convert(_curTitle.attributes, results);
				combatValue += _curTitle.combatValue;
			}

			_studyTitleCombatValue = 0;
			if (_studyTitle != null)
			{
				_studyTitleCombatValue = _studyTitle.studyCombatValue;

				var studyAttributes = F.ListPool<CombatAttribute>.Get();
				CombatAttribute.Convert(_studyTitle.attributes, studyAttributes);
				for (int j = 0; j < studyAttributes.Count; j++)
				{
					var attr = studyAttributes[j];
					attr.value = attr.value * _studyTitle.studyAdd[_studyStars[j]] / 100;
					results.Add(attr);
					_studyTitleCombatValue += _studyStars[j] * _studyTitle.starCombatValue;
				}

				combatValue += _studyTitleCombatValue;
				F.ListPool<CombatAttribute>.Release(studyAttributes);
			}

			foreach (var item in _swordInfos.Values)
			{
				if (item.CheckUnlock(false))
				{
					item.GetAttributes(results);
					combatValue += item.combatValue;
				}
			}

			PlayerProxy.Instance.UpdateTitleCombatValue(results, combatValue, sendNotification);
			F.ListPool<CombatAttribute>.Release(results);
		}


		#endregion

		#region Method

		/// <summary>
		/// 
		/// </summary>
		/// <param name="value"></param>
		/// <param name="sendNotification"></param>
		public void SetSwordLevel(int value, bool sendNotification)
		{
			if (swordLevel < value && value <= swordLevelMax)
			{
				if (swordLevel <= 0)
				{
					rewardTimestamp = Launch.Timestamp;
				}

				int count = 0;
				for (int i = Mathf.Max(1, swordLevel); i < value; i++)
				{
					var item = ItemProxy.Instance.GetStaticItem<ItemSwordLevel>(i);
					if (item != null)
					{
						count += item.completedRewardInfos.count;
						if (_settleRewards.id == 0)
							_settleRewards.id = item.completedRewardInfos.id;
					}
				}

				if (count > 0)
				{
					_settleRewards.count += count;
					MoneyProxy.Instance.AddMoney(_settleRewards.id, count);
				}

				swordLevel = value;
				SaveSword();

				//
				var curTitle = GetTitle();
				if (curTitle != null && curTitle.isCompleted)
				{
					UpTitle();
				}

				MissionProxy.Instance.OnEvent2(MissionProxy.剑阁达到层数, value);
			}
		}

		Item.ItemInfo _settleRewards;
		/// <summary>
		/// 结算显示的奖励
		/// </summary>
		/// <returns></returns>
		public Item.ItemInfo GetSettleRewards()
		{
			var result = _settleRewards;
			if (result.count > 0)
				RankingProxy.Instance.UploadSwordRanking(swordLevel);
			_settleRewards.count = 0;
			return result;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="id"></param>
		/// <returns></returns>
		public SwordInfo GetSwordInfo(int id)
		{
			_swordInfos.TryGetValue(id, out var result);
			return result;
		}

		/// <summary>
		/// 获得累计收益
		/// </summary>
		/// <param name="callback"></param>
		public void GetAccumulateGains(Callback2 callback)
		{
			int accum = this.accumMinute;
			if (accum > 0)
			{
				var reward = minuteRewards;
				float addition = 1f;
				reward.count = (int)(reward.count * accum * addition);
				rewardTimestamp = Launch.Timestamp;

				SaveSword();
				RewardProxy.Instance.GetRewardWithUI(reward, (error, message) =>
				{
					callback(error, "");
				});
			}
			else
			{
				callback?.Invoke(1, "还没有收益");
			}

			//if (beauty != null)
			//{
			//	addition += beauty.businessFactor * 0.01f;
			//}
		}

		/// <summary>
		/// 获得广告收益
		/// </summary>
		/// <param name="callback"></param>
		public void GetAdGains(Callback2 callback)
		{
			if (TimeProxy.Instance.CheckTimes(TimeProxy.剑阁广告次数))
			{
				var timeInfo = TimeProxy.Instance.GetTimeInfo2(TimeProxy.剑阁广告次数);
				if (timeInfo.remain == timeInfo.max)
				{
					TimeProxy.Instance.CostTimes(TimeProxy.剑阁广告次数);

					var reward = minuteRewards;
					float addition = 1f;
					reward.count = (int)(reward.count * 480f * addition);
					RewardProxy.Instance.GetRewardWithUI(reward, (err, msg) =>
					{
						callback(err, msg);
					});
					return;
				}

				AdProxy.Instance.PlayAd("sword", "ads_gains",
				(error, message) =>
				{
					if (error == 0)
					{
						TimeProxy.Instance.CostTimes(TimeProxy.剑阁广告次数);

						var reward = minuteRewards;
						float addition = 1f;
						reward.count = (int)(reward.count * 480f * addition);
						RewardProxy.Instance.GetRewardWithUI(reward, (err, msg) =>
						{
							callback(err, msg);
						});
					}
					else
					{
						callback(error, message);
					}
				});
			}
			else
			{
				callback(1, "广告次数不足,请明日再来");
			}
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="id"></param>
		/// <param name="callback"></param>
		public void UpgradeSword(int id, Callback2 callback)
		{
			if (_swordInfos.TryGetValue(id, out var swordInfo))
			{
				if (swordInfo.CheckUpgrade())
				{
					if (MoneyProxy.Instance.CheckAndCostMoney(swordInfo.upgradeCost))
					{
						swordInfo.Upgrade();
						SaveSword();

						UpdateAttributes(true);
						callback(0, "");
					}
					else
					{
						callback(1, KLocalization.GetLocalString(87));
					}
				}
				else
				{
					callback(1, "已满级");
				}
			}
		}

		public int QuickBattle()
		{
			int battleForce = 0;
			var currSwordLevelItem = this.swordLevelItem;
			if (currSwordLevelItem != null)
				battleForce = currSwordLevelItem.requirementCV;

            int targetForce = PlayerProxy.Instance.combatValue - 200000;
            int quickLevel = 0;
            if (targetForce < 7000000)
                quickLevel = targetForce / 10000;
            else
            {
                var swordLevels = ItemProxy.Instance.GetStaticItems<ItemSwordLevel>();
                for (int i = swordLevels.Count - 1; i >= 0; i--)
                {
                    if (swordLevels[i].requirementCV < targetForce)
                    {
                        quickLevel = swordLevels[i].id;
                        break;
                    }
                }
            }
            quickLevel = Mathf.Min(quickLevel, 1000);

            int result = quickLevel - this.swordLevel;
			if (result > 0)
			{
				SetSwordLevel(quickLevel, true);
			}
			return result;
		}

		/// <summary>
		/// 开始战斗
		/// </summary>
		/// <param name="callback"></param>
		public void StartBattle(Callback2 callback)
		{
			LevelProxy.Instance.StartClimb(this.swordLevel);
			callback?.Invoke(0, "");
		}

		void InitSword()
		{
			_curTitle = null;
			_studyTitle = null;
			for (int i = 0; i < _studyStars.Length; i++)
			{
				_studyStars[i] = 0;
			}
			_studyTitleCombatValue = 0;

			_rewardTimestamp = Launch.Timestamp;
			_swordLevel = 0;
			_swordInfos.Clear();
			var swordItems = ItemProxy.Instance.GetStaticItems<ItemSword>();
			if (swordItems != null)
				for (int i = 0; i < swordItems.Count; i++)
				{
					var swordItem = swordItems[i];
					_swordInfos.Add(swordItem.id, new SwordInfo(swordItem));
				}
		}

		const string ARCHIVE_KEY_V1 = "sword_v1";
		const string ARCHIVE_KEY_V2 = "sword_v2";

		void LoadSword()
		{
			var dataList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_V2);
			if (dataList != null && dataList.Count > 0)
			{
				int index = 0;
				int titleId = Mathf.Max(1, dataList.SafeGet(index++));

				SetTitle(titleId, false);

				titleId = dataList.SafeGet(index++);
				_studyTitle = ItemProxy.Instance.GetStaticItem<ItemSwordTitle>(titleId);
				for (int i = 0; i < _studyStars.Length; i++)
				{
					_studyStars[i] = dataList.SafeGet(index++);
				}

				swordLevel = dataList[index++];
				if (swordLevel > 0)
				{
					//MissionProxy.Instance.OnEvent2(MissionProxy.剑阁达到层数, swordLevel);
				}
				_rewardTimestamp = dataList[index++];
				if (_rewardTimestamp <= 0)
				{
					_rewardTimestamp = Launch.Timestamp;
				}

				int count = dataList[index++];
				for (int i = 0; i < count; i++)
				{
					int id = dataList[index++];
					int status = dataList[index++];
					if (_swordInfos.TryGetValue(id, out var swordInfo))
					{
						swordInfo.status = status;
					}
				}
				return;
			}

			dataList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_V1);
			if (dataList != null && dataList.Count > 0)
			{
				int index = 0;
				int titleId = Mathf.Max(1, dataList.SafeGet(index++));

				SetTitle(titleId, false);

				titleId = dataList.SafeGet(index++);
				_studyTitle = ItemProxy.Instance.GetStaticItem<ItemSwordTitle>(titleId);
				for (int i = 0; i < 3; i++)
				{
					_studyStars[i] = dataList.SafeGet(index++);
				}

				swordLevel = dataList[index++];
				if (swordLevel > 0)
				{
					//MissionProxy.Instance.OnEvent2(MissionProxy.剑阁达到层数, swordLevel);
				}
				_rewardTimestamp = dataList[index++];
				if (_rewardTimestamp <= 0)
				{
					_rewardTimestamp = Launch.Timestamp;
				}

				int count = dataList[index++];
				for (int i = 0; i < count; i++)
				{
					int id = dataList[index++];
					int status = dataList[index++];
					if (_swordInfos.TryGetValue(id, out var swordInfo))
					{
						swordInfo.status = status;
					}
				}
			}
			else
			{
				dataList = ArchiveProxy.Instance.GetIntList(TITLE_KEY_V1);
				if (dataList != null && dataList.Count > 0)
				{
					int index = 0;
					int titleId = Mathf.Max(1, dataList.SafeGet(index++));

					SetTitle(titleId, false);

					titleId = dataList.SafeGet(index++);
					_studyTitle = ItemProxy.Instance.GetStaticItem<ItemSwordTitle>(titleId);
					for (int i = 0; i < _studyStars.Length; i++)
					{
						_studyStars[i] = dataList.SafeGet(index++);
					}
				}
			}
		}

		void SaveSword()
		{
			var dataList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_V2);
			if (dataList != null)
			{
				dataList.Clear();

				dataList.Add(_curTitle != null ? _curTitle.id : 0);
				dataList.Add(_studyTitle != null ? _studyTitle.id : 0);
				for (int i = 0; i < _studyStars.Length; i++)
				{
					dataList.Add(_studyStars[i]);
				}

				dataList.Add(this.swordLevel);
				dataList.Add(_rewardTimestamp);

				dataList.Add(_swordInfos.Count);
				foreach (var item in _swordInfos)
				{
					dataList.Add(item.Key);
					dataList.Add(item.Value.status);
				}

				ArchiveProxy.Instance.SetIntList(ARCHIVE_KEY_V2, dataList);
			}

			ArchiveProxy.Instance.RemoveIntList(ARCHIVE_KEY_V1);
			ArchiveProxy.Instance.RemoveIntList(TITLE_KEY_V1);
		}

		private const string TITLE_KEY_V1 = "title";

		#endregion

		#region Proxy && Unity

		public static SwordProxy Instance => GetInstance<SwordProxy>();

		public override void ReadArchive()
		{
			InitSword();
			LoadSword();

			UpdateAttributes(false);
		}

		//private void OnEnable()
		//{
		//	RegisterCommand();
		//}

		//private void OnDisable()
		//{
		//	UnregisterCommand();
		//}

		#endregion

		#region COMMAND

		//public void RegisterCommand()
		//{
		//	GameCommand.Register(GlobalDefine.EVENT_MISSION_CHANGED, TitleMissionCommand.CreateCommand);
		//}

		//public void UnregisterCommand()
		//{
		//	GameCommand.Unregister(GlobalDefine.EVENT_MISSION_CHANGED);
		//}

		//private class TitleMissionCommand : GameCommand
		//{
		//	public override void Execute(INotification notification)
		//	{
		//		if (notification.Name == GlobalDefine.EVENT_MISSION_CHANGED)
		//		{
		//			var curTitle = Instance.GetTitle();
		//			if (curTitle != null)
		//			{
		//				//达到 
		//				MissionProxy.Instance.OnEvent2(MissionProxy.境界系统任务完成X次, curTitle.completedMissionCount, curTitle.id);
		//			}
		//		}
		//	}

		//	static readonly TitleMissionCommand _Default = new TitleMissionCommand();
		//	public static TitleMissionCommand CreateCommand()
		//	{
		//		return _Default;
		//	}
		//}

		#endregion

	}
}