// ***********************************************************************
// Assembly         : Unity
// Author           : Kimch
// Created          : 2019-05-20
// Description      :
// Last Modified By : 
// Last Modified On : 
// ***********************************************************************
// <copyright file= "ItemProxy" company="Kunpo"></copyright>
// <summary></summary>
// ***********************************************************************
namespace G
{
	using System.Collections.Generic;
	using F;
	using F.Item;

	partial class ItemProxy
	{
		private const string EQUIPMENT_KEY = "equipments";
		private const string PROP_KEY = "props";
		private const string GEM_KEY = "gems";
		/// <summary>
		/// 起始Id
		/// </summary>
		private int _uniqueId = 0;

		IItemGroup<EntityItemProp> _propGroup;
		IItemGroup<EntityItemEquipment> _equipmentGroup;
		IItemGroup<EntityItemGem> _gemGroup;
		//IItemGroup<EntityItemSkin> _skinGroup;

		public int uniqueId
		{
			get
			{
				if (_uniqueId == 0)
				{
					int u_id = ArchiveProxy.Instance.GetInt(GlobalDefine.KEY_UNIQUE_ID);
					_uniqueId = u_id > 0 ? u_id : int.MaxValue >> 1;
				}
				_uniqueId++;
				ArchiveProxy.Instance.SetInt(GlobalDefine.KEY_UNIQUE_ID, _uniqueId);
				return _uniqueId;
			}
		}

		private void InitEntity()
		{
			_propGroup = this.GetOrAddEntityGroup<EntityItemProp>();
			_equipmentGroup = this.GetOrAddEntityGroup<EntityItemEquipment>();
			_gemGroup = this.GetOrAddEntityGroup<EntityItemGem>();
			//_skinGroup = this.GetOrAddEntityGroup<EntityItemSkin>();
		}

		private void LoadEntity()
		{
			KFramework.ItemManager.ClearAllEntityItems();
			LoadProps();
			LoadEquipments();
			LoadGems();
			//LoadSkins();
		}

		private void SaveEntity()
		{
			SaveProps();
			SaveEquipments();
			SaveGems();
			//SaveSkins();
		}

		#region API

		/// <summary>
		/// 创建新装备
		/// </summary>
		/// <param name="itemId"></param>
		/// <returns></returns>
		public EntityItemEquipment NewEquipment(int itemId, int quality = 0)
		{
			var equipment = EntityItemEquipment.Create<EntityItemEquipment>(uniqueId, itemId);
			if (_equipmentGroup.AddItem(equipment))
			{
				equipment.GenerateAttributes(0, quality);
				SaveAddEquipment(equipment);
				MissionProxy.Instance.OnEvent(MissionProxy.装备累计获得_数量, 1, equipment.quality);
			}
			return equipment;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="itemId"></param>
		/// <param name="quality"></param>
		/// <returns></returns>
		public EntityItemEquipment NewTemporaryEquipment(int itemId, int quality = 0)
		{
			var equipment = EntityItemEquipment.Create<EntityItemEquipment>(-999, itemId);
			equipment.GenerateAttributes(0, quality);
			return equipment;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="equipment"></param>
		public void RemoveEquipment(EntityItemEquipment equipment)
		{
			if (equipment != null)
			{
				_equipmentGroup.RemoveItem(equipment);
				SaveRemoveEquipment(equipment);
				SaveEquipments();
			}
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="id"></param>
		/// <returns></returns>
		public EntityItemEquipment GetEquipment(int id)
		{
			return id > 0 ? _equipmentGroup.GetItem(id) : null;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <returns></returns>
		public IReadOnlyCollection<EntityItemEquipment> GetEquipments()
		{
			return _equipmentGroup.GetItemCollection();
		}

		/// <summary>
		/// 
		/// </summary>
		/// <returns></returns>
		public int GetEquipmentCount()
		{
			return _equipmentGroup.count;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="equipment"></param>
		private void SaveAddEquipment(EntityItemEquipment equipment)
		{
			if (equipment != null)
			{
				equipment.Save();
				SaveEquipments();
			}
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="equipment"></param>
		private void SaveRemoveEquipment(EntityItemEquipment equipment)
		{
			if (equipment != null)
			{
				equipment.Remove();
			}
		}

		/// <summary>
		/// 
		/// </summary>
		private void SaveEquipments()
		{
			var dataList = ArchiveProxy.Instance.GetIntList(EQUIPMENT_KEY);
			if (dataList != null)
			{
				dataList.Clear();
				foreach (var item in GetEquipments())
				{
					dataList.Add(item.id);
					dataList.Add(item.itemId);
				}
				ArchiveProxy.Instance.SetIntList(EQUIPMENT_KEY, dataList);
			}
		}

		/// <summary>
		/// 
		/// </summary>
		private void LoadEquipments()
		{
			var dataList = ArchiveProxy.Instance.GetIntList(EQUIPMENT_KEY);
			if (dataList != null && dataList.Count > 0)
			{
				for (int i = 0, c = dataList.Count - 1; i < c; i += 2)
				{
					int id = dataList[i];
					int itemId = dataList[i + 1];
					if (id > 0 && itemId > 0)
					{
						var item = GetStaticItem<ItemEquipment>(itemId);
						if (item != null)
						{
							var equipment = EntityItemEquipment.Create<EntityItemEquipment>(id, itemId);
							if (_equipmentGroup.AddItem(equipment))
							{
								equipment.Load();
							}
						}
						else
						{
							var convertItem = GetStaticItem<ItemConvert>(itemId);
							if (convertItem != null)
							{
								var equipment = EntityItemEquipment.Create<EntityItemEquipment>(id, convertItem.newId);
								if (_equipmentGroup.AddItem(equipment))
								{
									equipment.Load();
								}
							}
							else
								EntityItemEquipment.RemoveEquipment(id);
						}
					}
				}
			}
		}

		/////////////////////////////////////////////////////

		public EntityItemProp NewProp(int itemId, int count)
		{
			var prop = _propGroup.GetItem(itemId);
			if (prop == null)
			{
				prop = EntityItemProp.Create<EntityItemProp>(itemId);
				_propGroup.AddItem(prop);
			}
			prop.count += count;
			SaveProps();
			return prop;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="itemId"></param>
		/// <param name="count"></param>
		public void AddProp(int itemId, int count)
		{
			var prop = _propGroup.GetItem(itemId);
			if (prop == null)
			{
				prop = EntityItemProp.Create<EntityItemProp>(itemId);
				_propGroup.AddItem(prop);
			}
			prop.count += count;
			SaveProps();
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="itemId"></param>
		/// <param name="count"></param>
		public void SetPropCount(int itemId, int count)
		{
			var prop = _propGroup.GetItem(itemId);
			if (prop == null)
			{
				prop = EntityItemProp.Create<EntityItemProp>(itemId);
				_propGroup.AddItem(prop);
			}
			prop.count = count;
			SaveProps();
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="id"></param>
		/// <returns></returns>
		public EntityItemProp GetProp(int id)
		{
			if (id > 0)
			{
				var prop = _propGroup.GetItem(id);
				if (prop == null)
				{
					prop = EntityItemProp.Create<EntityItemProp>(id);
					_propGroup.AddItem(prop);
				}
				return prop;
			}
			return null;
		}

		public int GetPropCount(int id)
		{
			if (id > 0)
			{
				return ArchiveProxy.Instance.GetInt(id);
			}
			return 0;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <returns></returns>
		public IReadOnlyCollection<EntityItemProp> GetProps()
		{
			return _propGroup?.GetItemCollection();
		}

		/// <summary>
		/// 
		/// </summary>
		private void SaveProps()
		{
			//var pList = ArchiveProxy.Instance.GetIntList(PROP_KEY);
			//if (pList == null)
			//{
			//	pList = new List<int>();
			//}
			//else
			//{
			//	pList.Clear();
			//}
			//foreach (var item in GetProps())
			//{
			//	pList.Add(item.id);
			//	pList.Add(item.count);
			//}
			//ArchiveProxy.Instance.SetIntList(PROP_KEY, pList);
		}

		/// <summary>
		/// 
		/// </summary>
		private void LoadProps()
		{
			var propItems = GetStaticItems<ItemProp>();
			foreach (var propItem in propItems)
			{
				int type = propItem.type;
				if (type == 2 || type == 8)
				{
					var prop = EntityItemProp.Create<EntityItemProp>(propItem.id);
					if (_propGroup.AddItem(prop))
					{
					}
				}
			}
			//var pList = ArchiveProxy.Instance.GetIntList(PROP_KEY);
			//if (pList != null)
			//{
			//	for (int i = 0; i < pList.Count; i += 2)
			//	{
			//		int id = pList[i];
			//		int count = pList[i + 1];
			//		var prop = EntityItemProp.Create<EntityItemProp>(id, id);
			//		if (_propGroup.AddItem(prop))
			//		{
			//			prop.count = count;
			//		}
			//	}
			//}
		}

		#region Gem

		/// <summary>
		/// 
		/// </summary>
		/// <param name="itemId"></param>
		/// <param name="count"></param>
		/// <returns></returns>
		public EntityItemGem NewGem(int itemId, int count)
		{
			var gem = _gemGroup.GetItem(itemId);
			if (gem == null)
			{
				gem = EntityItemGem.Create<EntityItemGem>(itemId);
				_gemGroup.AddItem(gem);
			}
			gem.count += count;
			SaveGems();
			return gem;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="itemId"></param>
		/// <returns></returns>
		public EntityItemGem NewTemporaryGem(int itemId)
		{
			var gem = EntityItemGem.Create<EntityItemGem>(itemId, itemId);
			return gem;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="itemId"></param>
		/// <param name="count"></param>
		public void SetGemCount(int itemId, int count)
		{
			var gem = _gemGroup.GetItem(itemId);
			if (gem == null)
			{
				gem = EntityItemGem.Create<EntityItemGem>(itemId);
				_gemGroup.AddItem(gem);
			}
			gem.count = count;
			SaveGems();
			MissionProxy.Instance.OnEvent(MissionProxy.累计获得宝石);
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="itemId"></param>
		/// <param name="count"></param>
		public EntityItemGem AddGem(int itemId, int count)
		{
			var gem = _gemGroup.GetItem(itemId);
			if (gem == null)
			{
				gem = EntityItemGem.Create<EntityItemGem>(itemId);
				_gemGroup.AddItem(gem);
			}
			gem.count += count;
			SaveGems();
			MissionProxy.Instance.OnEvent(MissionProxy.累计获得宝石);
			return gem;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="id"></param>
		/// <returns></returns>
		public EntityItemGem GetGem(int id)
		{
			if (id > 0)
			{
				var gem = _gemGroup.GetItem(id);
				if (gem == null)
				{
					gem = EntityItemGem.Create<EntityItemGem>(id);
					_gemGroup.AddItem(gem);
				}
				return gem;
			}
			return null;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <returns></returns>
		public IReadOnlyCollection<EntityItemGem> GetGems()
		{
			return _gemGroup?.GetItemCollection();
		}

		/// <summary>
		/// 
		/// </summary>
		private void SaveGems()
		{
			//var dataList = ArchiveProxy.Instance.GetIntList(GEM_KEY);
			//if (dataList != null)
			//{
			//	dataList.Clear();
			//	foreach (var item in GetGems())
			//	{
			//		dataList.Add(item.id);
			//		dataList.Add(item.count);
			//	}
			//	ArchiveProxy.Instance.SetIntList(GEM_KEY, dataList);
			//}
		}

		/// <summary>
		/// 
		/// </summary>
		private void LoadGems()
		{
			var gemItems = GetStaticItems<ItemGem>();
			foreach (var gemItem in gemItems)
			{
				var gem = EntityItemGem.Create<EntityItemGem>(gemItem.id);
				if (_gemGroup.AddItem(gem))
				{
				}
			}

			//var dataList = ArchiveProxy.Instance.GetIntList(GEM_KEY);
			//if (dataList != null && dataList.Count > 0)
			//{
			//	for (int i = 0, c = dataList.Count - 1; i < c; i += 2)
			//	{
			//		int id = dataList[i];
			//		int count = dataList[i + 1];
			//		var gem = EntityItemGem.Create<EntityItemGem>(id, id);
			//		if (_gemGroup.AddItem(gem))
			//		{
			//			gem.count = count;
			//		}
			//	}
			//}
		}

		#endregion

		#region Skin

		//public EntityItemSkin GetSkin(int id)
		//{
		//	if (id > 0)
		//	{
		//		var skin = _skinGroup.GetItem(id);
		//		if (skin == null)
		//		{
		//			skin = EntityItemSkin.Create<EntityItemSkin>(id);
		//			_skinGroup.AddItem(skin);
		//		}
		//		return skin;
		//	}
		//	return null;
		//}

		//public IReadOnlyCollection<EntityItemSkin> GetSkins()
		//{
		//	return _skinGroup?.GetItemCollection();
		//}

		//private void LoadSkins()
		//{
		//	var skinItems = GetStaticItems<ItemChaSkin>();
		//	foreach (var skinItem in skinItems)
		//	{
		//		var skin = EntityItemSkin.Create<EntityItemSkin>(skinItem.id);
		//		if (_skinGroup.AddItem(skin))
		//		{
		//		}
		//	}
		//}

		//private void SaveSkins()
		//{
		//}

		#endregion
		/// <summary>
		/// 获取实体
		/// </summary>
		/// <param name="id"></param>
		/// <returns></returns>
		public EntityItem GetEntityItem(int id)
		{
			return KFramework.ItemManager.GetEntityItem(id) as EntityItem;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="entityItem"></param>
		public void RemoveEntityItem(EntityItem entityItem)
		{
			if (entityItem is EntityItemEquipment equipment)
			{
				RemoveEquipment(equipment);
			}
		}

		#endregion

		#region ProxyMethod

		private void AddEntityGroup<TEntity>() where TEntity : class, IItem
		{
			var fullName = Utils.Text.GetFullName<TEntity>();
			KFramework.ItemManager.AddEntityGroup<TEntity>(fullName, out var result);
		}

		/// <summary>
		/// 
		/// </summary>
		/// <typeparam name="TEntity"></typeparam>
		/// <returns></returns>
		private IItemGroup<TEntity> GetOrAddEntityGroup<TEntity>() where TEntity : class, IItem
		{
			var fullName = Utils.Text.GetFullName<TEntity>();
			var group = KFramework.ItemManager.GetGroup<TEntity>(fullName);
			if (group == null)
			{
				KFramework.ItemManager.AddEntityGroup(fullName, out group);
			}
			return group;
		}

		private IReadOnlyCollection<TEntity> GetAllEntityItems<TEntity>() where TEntity : class, IItem
		{
			var fullName = Utils.Text.GetFullName<TEntity>();
			return KFramework.ItemManager.GetEnityItems<TEntity>(fullName);
		}

		private TEntity GetEntityItem<TEntity>(int id) where TEntity : class, IItem
		{
			return KFramework.ItemManager.GetEntityItem(id) as TEntity;
		}

		#endregion
	}
}