using System;
using System.Collections.Generic;
using KKSG;
using UILib;
using XMainClient.UI;
using XUtliPoolLib;

namespace XMainClient
{
	internal class XBagDocument : XDocComponent
	{
		public override uint ID
		{
			get
			{
				return XBagDocument.uuID;
			}
		}

		public static DropList DropTable
		{
			get
			{
				return XBagDocument.m_DropTable;
			}
		}

		public static XBagDocument BagDoc
		{
			get
			{
				return XSingleton<XGame>.singleton.Doc.XBagDoc;
			}
		}

		public static PandoraHeart PandoraHeartTable
		{
			get
			{
				return XBagDocument.m_PandoraHeartTable;
			}
		}

		public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("XBagDocument");

		public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();

		private static ItemList m_ItemTable = new ItemList();

		private static DropList m_DropTable = new DropList();

		private static ChestList m_ChestTable = new ChestList();

		private static EquipList m_EquipTable = new EquipList();

		private static EmblemBasic m_EmblemTable = new EmblemBasic();

		private static FashionList m_FashionTable = new FashionList();

		private static PandoraHeart m_PandoraHeartTable = new PandoraHeart();

		private static BagExpandItemListTable m_BagExpandItemListTable = new BagExpandItemListTable();

		private static Dictionary<int, List<ChestList.RowData>> m_ChestRange = new Dictionary<int, List<ChestList.RowData>>();

		private static Dictionary<uint, List<ItemList.RowData>> m_AuctionRange = new Dictionary<uint, List<ItemList.RowData>>();

		public XBag ItemBag;

		public static readonly int EquipMax = XBagDocument.BodyPosition<EquipPosition>(EquipPosition.EQUIP_END);

		public static readonly int FashionMax = XBagDocument.BodyPosition<FashionPosition>(FashionPosition.FASHION_END);

		public static readonly int EmblemMax = XBagDocument.BodyPosition<EmblemPosition>(EmblemPosition.EMBLEM_END);

		public static readonly int VirtualItemMax = XBagDocument.BodyPosition<ItemEnum>(ItemEnum.VIRTUAL_ITEM_MAX);

		public static readonly int ArtifactMax = XBagDocument.BodyPosition<ArtifactPosition>(ArtifactPosition.ARTIFACT_END);

		private static readonly uint ITEM_PROFESSION_MASK = 100000u;

		public static readonly int QualityCount = 6;

		public XBodyBag EquipBag = new XBodyBag(XBagDocument.EquipMax);

		public XBodyBag EmblemBag = new XBodyBag(XBagDocument.EmblemMax);

		public XBodyBag ArtifactBag = new XBodyBag(XBagDocument.ArtifactMax);

		public ulong[] VirtualItems = new ulong[XBagDocument.VirtualItemMax];

		public ulong TearsCount = 0UL;

		public List<BagExpandData> BagExpandDataList = new List<BagExpandData>
		{
			new BagExpandData(BagType.ItemBag),
			new BagExpandData(BagType.EmblemBag),
			new BagExpandData(BagType.EquipBag),
			new BagExpandData(BagType.ArtifactBag)
		};

		public static CVSReader.RowDataCompare<DropList.RowData, int> comp = new CVSReader.RowDataCompare<DropList.RowData, int>(XBagDocument.DropDataCompare);

		private BagExpandItemListTable.RowData m_usedBagExpandRow = null;

		private Dictionary<ulong, uint> basicAttrPool = new Dictionary<ulong, uint>();

		private Dictionary<ulong, uint> equipAdditionalAttrPool = new Dictionary<ulong, uint>();

		private bool getallEquip = false;

		private int fashionIndex = 0;

		private float fashionTime = 0f;

		public void GetItemsByType(ulong typeFilter, ref List<XItem> list)
		{
			for (int i = 0; i < this.ItemBag.Count; i++)
			{
				ulong num = 1UL << (int)this.ItemBag[i].type;
				bool flag = (num & typeFilter) > 0UL;
				if (flag)
				{
					list.Add(this.ItemBag[i]);
				}
			}
		}

		public List<XItem> GetNotBindItemsByType(int typeFilter)
		{
			List<XItem> list = new List<XItem>();
			for (int i = 0; i < this.ItemBag.Count; i++)
			{
				bool bBinding = this.ItemBag[i].bBinding;
				if (!bBinding)
				{
					int num = 1 << (int)this.ItemBag[i].type;
					bool flag = (num & typeFilter) > 0;
					if (flag)
					{
						list.Add(this.ItemBag[i]);
					}
				}
			}
			return list;
		}

		public List<XItem> GetItemsByTypeAndQuality(ulong typeFilter, ItemQuality quality)
		{
			List<XItem> list = new List<XItem>();
			for (int i = 0; i < this.ItemBag.Count; i++)
			{
				ulong num = 1UL << (int)this.ItemBag[i].type;
				bool flag = (num & typeFilter) > 0UL && (ItemQuality)this.ItemBag[i].itemConf.ItemQuality == quality;
				if (flag)
				{
					list.Add(this.ItemBag[i]);
				}
			}
			return list;
		}

		public static void Execute(OnLoadedCallback callback = null)
		{
			XBagDocument.AsyncLoader.AddTask("Table/ItemList", XBagDocument.m_ItemTable, false);
			XBagDocument.AsyncLoader.AddTask("Table/ChestList", XBagDocument.m_ChestTable, false);
			XBagDocument.AsyncLoader.AddTask("Table/EquipList", XBagDocument.m_EquipTable, false);
			XBagDocument.AsyncLoader.AddTask("Table/FashionList", XBagDocument.m_FashionTable, false);
			XBagDocument.AsyncLoader.AddTask("Table/EmblemBasic", XBagDocument.m_EmblemTable, false);
			XBagDocument.AsyncLoader.AddTask("Table/DropList", XBagDocument.m_DropTable, false);
			XBagDocument.AsyncLoader.AddTask("Table/PandoraHeart", XBagDocument.m_PandoraHeartTable, false);
			XBagDocument.AsyncLoader.AddTask("Table/BagExpandItemList", XBagDocument.m_BagExpandItemListTable, false);
			XBagDocument.AsyncLoader.Execute(callback);
			XBagDocument.m_ChestRange.Clear();
			XBagDocument.m_AuctionRange.Clear();
		}

		public static void OnTableLoaded()
		{
			XBagDocument.BuildChestTable();
			XBagDocument.BuildAuctionRange();
		}

		public static void BuildAuctionRange()
		{
			ItemList.RowData[] table = XBagDocument.m_ItemTable.Table;
			int i = 0;
			int num = table.Length;
			while (i < num)
			{
				ItemList.RowData rowData = table[i];
				bool flag = !rowData.CanTrade || rowData.AuctionType == null;
				if (!flag)
				{
					int j = 0;
					int num2 = rowData.AuctionType.Length;
					while (j < num2)
					{
						List<ItemList.RowData> list;
						bool flag2 = !XBagDocument.m_AuctionRange.TryGetValue((uint)rowData.AuctionType[j], out list);
						if (flag2)
						{
							list = new List<ItemList.RowData>();
							XBagDocument.m_AuctionRange.Add((uint)rowData.AuctionType[j], list);
						}
						list.Add(rowData);
						j++;
					}
				}
				i++;
			}
		}

		public static void BuildChestTable()
		{
			int i = 0;
			int num = XBagDocument.m_ChestTable.Table.Length;
			while (i < num)
			{
				List<ChestList.RowData> list;
				bool flag = !XBagDocument.m_ChestRange.TryGetValue(XBagDocument.m_ChestTable.Table[i].ItemID, out list);
				if (flag)
				{
					list = new List<ChestList.RowData>();
					XBagDocument.m_ChestRange.Add(XBagDocument.m_ChestTable.Table[i].ItemID, list);
				}
				list.Add(XBagDocument.m_ChestTable.Table[i]);
				i++;
			}
		}

		public static bool TryGetAuctionList(uint auctionID, out List<ItemList.RowData> list)
		{
			return XBagDocument.m_AuctionRange.TryGetValue(auctionID, out list);
		}

		public static uint GetItemProf(int itemid)
		{
			ItemList.RowData byItemID = XBagDocument.m_ItemTable.GetByItemID(itemid);
			bool flag = byItemID == null;
			uint result;
			if (flag)
			{
				result = 0u;
			}
			else
			{
				result = (uint)byItemID.Profession;
			}
			return result;
		}

		public static int ConvertTemplate(ItemList.RowData rowData)
		{
			bool flag = rowData == null;
			int result;
			if (flag)
			{
				result = 0;
			}
			else
			{
				bool flag2 = rowData.ItemType == 12;
				if (flag2)
				{
					result = rowData.ItemID + (int)(XItemDrawerParam.DefaultProfession * XBagDocument.ITEM_PROFESSION_MASK);
				}
				else
				{
					result = rowData.ItemID;
				}
			}
			return result;
		}

		public static int ConvertTemplate(int itemid)
		{
			ItemList.RowData byItemID = XBagDocument.m_ItemTable.GetByItemID(itemid);
			bool flag = byItemID == null;
			int result;
			if (flag)
			{
				result = itemid;
			}
			else
			{
				result = XBagDocument.ConvertTemplate(byItemID);
			}
			return result;
		}

		public static bool IsProfMatched(uint prof)
		{
			return prof == 0u || prof % 10u == XItemDrawerParam.DefaultProfession;
		}

		public static bool IsProfMatchedFeable(uint prof, uint profecssion, bool feable = false)
		{
			return prof == 0u || (feable ? (prof % 10u == profecssion % 10u) : (prof == profecssion));
		}

		public static bool IsProfMatchedWithFeable(uint prof)
		{
			return prof == 0u || prof == XItemDrawerParam.DefaultProfession;
		}

		public static bool IsProfEqual(uint prof)
		{
			return prof % 10u == XItemDrawerParam.DefaultProfession;
		}

		public static string GetItemSmallIcon(int itemid, uint profession = 0u)
		{
			ItemList.RowData itemConf = XBagDocument.GetItemConf(itemid);
			bool flag = itemConf == null;
			string result;
			if (flag)
			{
				result = string.Empty;
			}
			else
			{
				result = XSingleton<UiUtility>.singleton.ChooseProfString(itemConf.ItemIcon1, profession);
			}
			return result;
		}

		public static void GetItemBigIconAndAtlas(int itemid, out string icon, out string atlas, uint profession = 0u)
		{
			ItemList.RowData itemConf = XBagDocument.GetItemConf(itemid);
			bool flag = itemConf == null;
			if (flag)
			{
				icon = string.Empty;
				atlas = string.Empty;
			}
			else
			{
				icon = XSingleton<UiUtility>.singleton.ChooseProfString(itemConf.ItemIcon, profession);
				atlas = XSingleton<UiUtility>.singleton.ChooseProfString(itemConf.ItemAtlas, profession);
			}
		}

		public static void GetItemSmallIconAndAtlas(int itemid, out string icon, out string atlas, uint profession = 0u)
		{
			ItemList.RowData itemConf = XBagDocument.GetItemConf(itemid);
			bool flag = itemConf == null;
			if (flag)
			{
				icon = string.Empty;
				atlas = string.Empty;
			}
			else
			{
				icon = XSingleton<UiUtility>.singleton.ChooseProfString(itemConf.ItemIcon1, profession);
				atlas = XSingleton<UiUtility>.singleton.ChooseProfString(itemConf.ItemAtlas1, profession);
			}
		}

		public static uint GetAuctionRecommendPrice(int itemID)
		{
			return XBagDocument.m_ItemTable.GetByItemID(itemID).AuctPriceRecommend;
		}

		public static FashionList.RowData GetFashionConf(int itemID)
		{
			return XBagDocument.m_FashionTable.GetByItemID(itemID);
		}

		public static ItemList.RowData GetItemConf(int itemID)
		{
			return XBagDocument.m_ItemTable.GetByItemID(itemID);
		}

		public static EquipList.RowData GetEquipConf(int itemID)
		{
			return XBagDocument.m_EquipTable.GetByItemID(itemID);
		}

		public static BagExpandItemListTable.RowData GetExpandItemConf(uint itemId)
		{
			return XBagDocument.m_BagExpandItemListTable.GetByItemId(itemId);
		}

		public static BagExpandItemListTable.RowData GetExpandItemConfByType(uint itemId)
		{
			return XBagDocument.m_BagExpandItemListTable.GetByType(itemId);
		}

		public static PandoraHeart.RowData GetPandoraHeartConf(int itemID, uint profID)
		{
			for (int i = 0; i < XBagDocument.m_PandoraHeartTable.Table.Length; i++)
			{
				bool flag = ((long)itemID == (long)((ulong)XBagDocument.m_PandoraHeartTable.Table[i].PandoraID) || (long)itemID == (long)((ulong)XBagDocument.m_PandoraHeartTable.Table[i].FireID)) && (profID == XBagDocument.m_PandoraHeartTable.Table[i].ProfID || XBagDocument.m_PandoraHeartTable.Table[i].ProfID == 0u);
				if (flag)
				{
					return XBagDocument.m_PandoraHeartTable.Table[i];
				}
			}
			return null;
		}

		public static EmblemBasic.RowData GetEmblemConf(int emblemID)
		{
			return XBagDocument.m_EmblemTable.GetByEmblemID((uint)emblemID);
		}

		public static ChestList.RowData GetChestConf(int itemID)
		{
			for (int i = 0; i < XBagDocument.m_ChestTable.Table.Length; i++)
			{
				bool flag = XBagDocument.m_ChestTable.Table[i].ItemID == itemID;
				if (flag)
				{
					return XBagDocument.m_ChestTable.Table[i];
				}
			}
			return null;
		}

		public static bool TryGetChestListConf(int itemID, out List<ChestList.RowData> chestList)
		{
			return XBagDocument.m_ChestRange.TryGetValue(itemID, out chestList);
		}

		private static int DropDataCompare(DropList.RowData rowData, int dropID)
		{
			return dropID.CompareTo(rowData.DropID);
		}

		public static bool TryGetDropConf(uint[] dropIDs, ref List<DropList.RowData> dropList)
		{
			bool flag = dropIDs != null;
			if (flag)
			{
				for (int i = 0; i < dropIDs.Length; i++)
				{
					int num;
					int num2;
					CVSReader.GetRowDataListByField<DropList.RowData, int>(XBagDocument.DropTable.Table, (int)dropIDs[i], out num, out num2, XBagDocument.comp);
					bool flag2 = num < 0;
					if (!flag2)
					{
						for (int j = num; j <= num2; j++)
						{
							dropList.Add(XBagDocument.DropTable.Table[j]);
						}
					}
				}
			}
			return dropList.Count > 0;
		}

		public override void OnAttachToHost(XObject host)
		{
			base.OnAttachToHost(host);
			this.ItemBag = new XBag();
		}

		protected override void EventSubscribe()
		{
			base.EventSubscribe();
			base.RegisterEvent(XEventDefine.XEvent_RemoveItem, new XComponent.XEventHandler(this.OnRemoveItem));
			base.RegisterEvent(XEventDefine.XEvent_UpdateItem, new XComponent.XEventHandler(this.OnUpdateItem));
		}

		protected bool OnRemoveItem(XEventArgs args)
		{
			XRemoveItemEventArgs xremoveItemEventArgs = args as XRemoveItemEventArgs;
			foreach (ulong uid in xremoveItemEventArgs.uids)
			{
				this._RemoveCompareAttrsFromPool(uid);
			}
			return true;
		}

		protected bool OnUpdateItem(XEventArgs args)
		{
			XUpdateItemEventArgs xupdateItemEventArgs = args as XUpdateItemEventArgs;
			this._RemoveCompareAttrsFromPool(xupdateItemEventArgs.item.uid);
			return true;
		}

		public override void OnLeaveScene()
		{
			base.OnLeaveScene();
			this.basicAttrPool.Clear();
			this.equipAdditionalAttrPool.Clear();
			this.getallEquip = false;
		}

		public BagExpandData GetBagExpandData(BagType type)
		{
			for (int i = 0; i < this.BagExpandDataList.Count; i++)
			{
				bool flag = this.BagExpandDataList[i].Type == type;
				if (flag)
				{
					return this.BagExpandDataList[i];
				}
			}
			return null;
		}

		public void SwapItem(ulong uid1, ulong uid2)
		{
			int num = 0;
			XItem xitem = null;
			XItem xitem2 = null;
			bool flag = uid1 != 0UL && this.ItemBag.FindItem(uid1, out num);
			if (flag)
			{
				xitem = this.ItemBag[num];
			}
			int num2 = 0;
			XBodyBag xbodyBag = null;
			bool flag2 = false;
			bool flag3 = uid2 != 0UL && this.GetBodyPosByUID(uid2, out num2, out xbodyBag, out flag2);
			if (flag3)
			{
				xitem2 = xbodyBag[num2];
			}
			bool flag4 = xitem != null && xitem2 != null;
			if (flag4)
			{
				bool flag5 = xitem.type != xitem2.type;
				if (!flag5)
				{
					this.ItemBag[num] = xitem2;
					xbodyBag[num2] = xitem;
					this.ItemBag.SortItem();
					XSwapItemEventArgs @event = XEventPool<XSwapItemEventArgs>.GetEvent();
					@event.itemNowOnBody = xitem;
					@event.itemNowInBag = xitem2;
					@event.slot = num2;
					@event.Firer = XSingleton<XGame>.singleton.Doc;
					XSingleton<XEventMgr>.singleton.FireEvent(@event);
				}
			}
			else
			{
				bool flag6 = xitem != null;
				if (flag6)
				{
					xbodyBag = xitem.Description.BodyBag;
					bool flag7 = xbodyBag == null;
					if (!flag7)
					{
						ItemType type = xitem.Type;
						if (type != ItemType.EQUIP)
						{
							if (type != ItemType.EMBLEM)
							{
								if (type == ItemType.ARTIFACT)
								{
									ArtifactListTable.RowData artifactListRowData = ArtifactDocument.GetArtifactListRowData((uint)xitem.itemID);
									num2 = (int)artifactListRowData.ArtifactPos;
									flag2 = true;
								}
							}
							else
							{
								EmblemBasic.RowData emblemConf = XBagDocument.GetEmblemConf(xitem.itemID);
								bool flag8 = !XEmblemDocument.GetFirstEmptyEmblemSlot(this.EmblemBag, emblemConf.EmblemType, out num2);
								if (flag8)
								{
									XSingleton<XDebug>.singleton.AddErrorLog("Failed to equip emblem cause it's full.", null, null, null, null, null);
									return;
								}
							}
						}
						else
						{
							EquipList.RowData equipConf = XBagDocument.GetEquipConf(xitem.itemID);
							num2 = (int)equipConf.EquipPos;
							flag2 = true;
						}
						xbodyBag[num2] = xitem;
						this.ItemBag.RemoveIndex(num);
						XRemoveItemEventArgs event2 = XEventPool<XRemoveItemEventArgs>.GetEvent();
						event2.uids.Add(uid1);
						event2.types.Add(xitem.Type);
						event2.ids.Add(xitem.itemID);
						event2.Firer = XSingleton<XGame>.singleton.Doc;
						XSingleton<XEventMgr>.singleton.FireEvent(event2);
						XLoadEquipEventArgs event3 = XEventPool<XLoadEquipEventArgs>.GetEvent();
						event3.item = xitem;
						event3.slot = num2;
						event3.Firer = XSingleton<XGame>.singleton.Doc;
						XSingleton<XEventMgr>.singleton.FireEvent(event3);
					}
				}
				else
				{
					bool flag9 = xitem2 != null;
					if (flag9)
					{
						xbodyBag[num2] = null;
						this.ItemBag.AddItem(xitem2, true);
						XAddItemEventArgs event4 = XEventPool<XAddItemEventArgs>.GetEvent();
						event4.items.Add(xitem2);
						event4.Firer = XSingleton<XGame>.singleton.Doc;
						event4.bNew = false;
						XSingleton<XEventMgr>.singleton.FireEvent(event4);
						XUnloadEquipEventArgs event5 = XEventPool<XUnloadEquipEventArgs>.GetEvent();
						event5.slot = num2;
						event5.item = xitem2;
						event5.type = xitem2.Type;
						event5.Firer = XSingleton<XGame>.singleton.Doc;
						XSingleton<XEventMgr>.singleton.FireEvent(event5);
					}
				}
			}
		}

		public void UseItem(XItem item, uint opType = 0u)
		{
			RpcC2G_UseItem rpcC2G_UseItem = new RpcC2G_UseItem();
			rpcC2G_UseItem.oArg.uid = item.uid;
			rpcC2G_UseItem.oArg.count = 1u;
			rpcC2G_UseItem.oArg.OpType = opType;
			rpcC2G_UseItem.oArg.itemID = (uint)item.itemID;
			XSingleton<XClientNetwork>.singleton.Send(rpcC2G_UseItem);
		}

		public void UseItem(XItem item, uint opType, uint count)
		{
			RpcC2G_UseItem rpcC2G_UseItem = new RpcC2G_UseItem();
			rpcC2G_UseItem.oArg.uid = item.uid;
			rpcC2G_UseItem.oArg.count = count;
			rpcC2G_UseItem.oArg.OpType = opType;
			XSingleton<XClientNetwork>.singleton.Send(rpcC2G_UseItem);
		}

		private static void MakeXEquipItem(ref XItem item, Item KKSGItem)
		{
			bool flag = item == null;
			if (flag)
			{
				item = XDataPool<XEquipItem>.GetData();
			}
			XEquipItem xequipItem = item as XEquipItem;
			bool flag2 = xequipItem == null;
			if (flag2)
			{
				XSingleton<XDebug>.singleton.AddErrorLog("Cant create XEquipItem", null, null, null, null, null);
			}
			else
			{
				xequipItem.smeltDegreeNum = KKSGItem.smeltCount;
				xequipItem.enhanceInfo.EnhanceLevel = KKSGItem.EnhanceLevel;
				xequipItem.enhanceInfo.EnhanceTimes = KKSGItem.EnhanceCount;
				bool flag3 = KKSGItem.AttrID.Count != KKSGItem.AttrValue.Count;
				if (flag3)
				{
					XSingleton<XDebug>.singleton.AddLog("KKSGItem.EnhanceInfo.AttrID.Count != KKSGItem.EnhanceInfo.AttrValue.Count", null, null, null, null, null, XDebugColor.XDebug_None);
				}
				else
				{
					for (int i = 0; i < KKSGItem.EnhanceAttrId.Count; i++)
					{
						XItemChangeAttr item2;
						item2.AttrID = KKSGItem.EnhanceAttrId[i];
						item2.AttrValue = KKSGItem.EnhanceAttrValue[i];
						xequipItem.enhanceInfo.EnhanceAttr.Add(item2);
					}
					xequipItem.changeAttr.Clear();
					EquipList.RowData equipConf = XBagDocument.GetEquipConf((int)KKSGItem.ItemID);
					bool flag4 = equipConf != null;
					if (flag4)
					{
						for (int j = 0; j < (int)equipConf.Attributes.count; j++)
						{
							XItemChangeAttr item3;
							item3.AttrID = (uint)equipConf.Attributes[j, 0];
							item3.AttrValue = (uint)equipConf.Attributes[j, 1];
							xequipItem.changeAttr.Add(item3);
						}
					}
					bool flag5 = KKSGItem.ItemJade != null;
					if (flag5)
					{
						for (int k = 0; k < KKSGItem.ItemJade.ItemJadeSingle.Count; k++)
						{
							ItemJadeSingle itemJadeSingle = KKSGItem.ItemJade.ItemJadeSingle[k];
							XJadeItem data = XDataPool<XJadeItem>.GetData();
							data.itemID = (int)itemJadeSingle.ItemId;
							data.type = (uint)XFastEnumIntEqualityComparer<ItemType>.ToInt(ItemType.JADE);
							data.uid = 0UL;
							data.itemCount = 1;
							data.bBinding = true;
							for (int l = 0; l < itemJadeSingle.AttrId.Count; l++)
							{
								uint attrID = itemJadeSingle.AttrId[l];
								XItemChangeAttr item4;
								item4.AttrID = attrID;
								item4.AttrValue = itemJadeSingle.AttrValue[l];
								data.changeAttr.Add(item4);
							}
							xequipItem.jadeInfo.jades[(int)itemJadeSingle.SlotPos] = data;
						}
					}
					xequipItem.attrType = AttrType.None;
					bool flag6 = KKSGItem.randAttr != null;
					if (flag6)
					{
						for (int m = 0; m < KKSGItem.randAttr.attrs.Count; m++)
						{
							XItemChangeAttr xitemChangeAttr;
							xitemChangeAttr.AttrID = KKSGItem.randAttr.attrs[m].id;
							xitemChangeAttr.AttrValue = KKSGItem.randAttr.attrs[m].value;
							xequipItem.randAttrInfo.RandAttr.Add(xitemChangeAttr);
							bool flag7 = xequipItem.attrType > AttrType.None;
							if (!flag7)
							{
								bool flag8 = xitemChangeAttr.AttrID == 11u;
								if (flag8)
								{
									xequipItem.attrType = AttrType.Physics;
								}
								else
								{
									bool flag9 = xitemChangeAttr.AttrID == 21u;
									if (flag9)
									{
										xequipItem.attrType = AttrType.Magic;
									}
								}
							}
						}
					}
					bool flag10 = KKSGItem.forge != null;
					if (flag10)
					{
						for (int n = 0; n < KKSGItem.forge.attrs.Count; n++)
						{
							XItemChangeAttr item5;
							item5.AttrID = KKSGItem.forge.attrs[n].id;
							item5.AttrValue = KKSGItem.forge.attrs[n].value;
							xequipItem.forgeAttrInfo.ForgeAttr.Add(item5);
						}
						bool flag11 = KKSGItem.forge.unReplacedAttr != null;
						if (flag11)
						{
							xequipItem.forgeAttrInfo.UnSavedAttrid = KKSGItem.forge.unReplacedAttr.id;
							xequipItem.forgeAttrInfo.UnSavedAttrValue = KKSGItem.forge.unReplacedAttr.value;
						}
						else
						{
							xequipItem.forgeAttrInfo.UnSavedAttrid = 0u;
							xequipItem.forgeAttrInfo.UnSavedAttrValue = 0u;
						}
					}
					bool flag12 = KKSGItem.enchant != null;
					if (flag12)
					{
						xequipItem.enchantInfo.ChooseAttr = KKSGItem.enchant.chooseAttrid;
						bool flag13 = KKSGItem.enchant.chooseAttrid > 0u;
						if (flag13)
						{
							for (int num = 0; num < KKSGItem.enchant.allAttrs.Count; num++)
							{
								XItemChangeAttr item6;
								item6.AttrID = KKSGItem.enchant.allAttrs[num].id;
								item6.AttrValue = KKSGItem.enchant.allAttrs[num].value;
								xequipItem.enchantInfo.AttrList.Add(item6);
							}
							bool flag14 = KKSGItem.enchant.enchantids.Count > 0;
							if (flag14)
							{
								xequipItem.enchantInfo.EnchantIDList = new List<uint>(KKSGItem.enchant.enchantids);
							}
						}
						xequipItem.enchantInfo.EnchantItemID = (int)KKSGItem.enchant.enchantid;
					}
					bool flag15 = KKSGItem.fuse != null;
					if (flag15)
					{
						xequipItem.fuseInfo.BreakNum = KKSGItem.fuse.fuseLevel;
						xequipItem.fuseInfo.FuseExp = KKSGItem.fuse.fuseExpCount;
					}
				}
			}
		}

		private static void MakeXArtifactItem(ref XItem item, Item KKSGItem)
		{
			bool flag = item == null;
			if (flag)
			{
				item = XDataPool<XArtifactItem>.GetData();
			}
			XArtifactItem xartifactItem = item as XArtifactItem;
			bool flag2 = xartifactItem == null;
			if (flag2)
			{
				XSingleton<XDebug>.singleton.AddErrorLog("Can not create artifactItem", null, null, null, null, null);
			}
			else
			{
				xartifactItem.RandAttrInfo.RandAttr.Clear();
				for (int i = 0; i < KKSGItem.AttrID.Count; i++)
				{
					XItemChangeAttr item2;
					item2.AttrID = KKSGItem.AttrID[i];
					item2.AttrValue = KKSGItem.AttrValue[i];
					xartifactItem.RandAttrInfo.RandAttr.Add(item2);
				}
				bool flag3 = KKSGItem.artifact != null;
				if (flag3)
				{
					for (int j = 0; j < KKSGItem.artifact.unReplacedAttr.Count; j++)
					{
						XItemChangeAttr item3 = default(XItemChangeAttr);
						item3.AttrID = KKSGItem.artifact.unReplacedAttr[j].id;
						item3.AttrValue = KKSGItem.artifact.unReplacedAttr[j].value;
						xartifactItem.UnSavedAttr.Add(item3);
					}
				}
				xartifactItem.EffectInfoList.Clear();
				for (int k = 0; k < KKSGItem.effects.Count; k++)
				{
					EffectData effectData = KKSGItem.effects[k];
					XArtifactEffectInfo item4 = default(XArtifactEffectInfo);
					item4.Init();
					item4.EffectId = effectData.effectID;
					item4.SetBaseProf(effectData.effectID);
					item4.IsValid = effectData.isWork;
					xartifactItem.EffectInfoList.Add(item4);
					for (int l = 0; l < effectData.multiParams.Count; l++)
					{
						EffectMultiParams effectMultiParams = effectData.multiParams[l];
						bool flag4 = effectMultiParams == null;
						if (!flag4)
						{
							XArtifactBuffInfo item5 = default(XArtifactBuffInfo);
							item5.Init();
							item5.SetData(effectData.effectID, effectMultiParams.IDType, effectMultiParams.ID, effectMultiParams.effectParams);
							bool flag5 = item4.BuffInfoList.Count == 0;
							if (flag5)
							{
								item4.BuffInfoList.Add(item5);
							}
							else
							{
								for (int m = 0; m < item4.BuffInfoList.Count; m++)
								{
									bool flag6 = item5.SortId > item4.BuffInfoList[item4.BuffInfoList.Count - 1].SortId;
									if (flag6)
									{
										item4.BuffInfoList.Add(item5);
										break;
									}
									bool flag7 = item5.SortId < item4.BuffInfoList[m].SortId;
									if (flag7)
									{
										item4.BuffInfoList.Insert(m, item5);
										break;
									}
								}
							}
						}
					}
				}
			}
		}

		private static void MakeXEmblemItem(ref XItem item, Item KKSGItem)
		{
			bool flag = item == null;
			if (flag)
			{
				item = XDataPool<XEmblemItem>.GetData();
			}
			XBagDocument.MakeXAttrItem(ref item, KKSGItem);
			XEmblemItem xemblemItem = item as XEmblemItem;
			bool flag2 = xemblemItem == null;
			if (flag2)
			{
				XSingleton<XDebug>.singleton.AddErrorLog("Cant create XEmblemItem", null, null, null, null, null);
			}
			else
			{
				xemblemItem.smeltDegreeNum = KKSGItem.smeltCount;
				xemblemItem.emblemInfo.thirdslot = KKSGItem.EmblemThirdSlot;
			}
		}

		private static void MakeXFashionItem(ref XItem item, Item KKSGItem)
		{
			bool flag = item == null;
			if (flag)
			{
				item = XDataPool<XFashionItem>.GetData();
			}
			XFashionItem xfashionItem = item as XFashionItem;
			xfashionItem.fashionLevel = KKSGItem.FashionLevel;
		}

		private static void MakeXJadeItem(ref XItem item, Item KKSGItem)
		{
			bool flag = item == null;
			if (flag)
			{
				item = XDataPool<XJadeItem>.GetData();
			}
			XBagDocument.MakeXAttrItem(ref item, KKSGItem);
			XJadeItem xjadeItem = item as XJadeItem;
			bool flag2 = xjadeItem == null;
			if (flag2)
			{
				XSingleton<XDebug>.singleton.AddErrorLog("Cant create XJadeItem", null, null, null, null, null);
			}
		}

		private static void MakeXAttrItem(ref XItem item, Item KKSGItem)
		{
			bool flag = item == null;
			if (flag)
			{
				XSingleton<XDebug>.singleton.AddErrorLog("XItem == null", null, null, null, null, null);
			}
			else
			{
				XAttrItem xattrItem = item as XAttrItem;
				bool flag2 = xattrItem == null;
				if (flag2)
				{
					XSingleton<XDebug>.singleton.AddErrorLog("Cant create XAttrItem", null, null, null, null, null);
				}
				else
				{
					xattrItem.changeAttr.Clear();
					for (int i = 0; i < KKSGItem.AttrID.Count; i++)
					{
						uint attrID = KKSGItem.AttrID[i];
						XItemChangeAttr item2;
						item2.AttrID = attrID;
						item2.AttrValue = KKSGItem.AttrValue[i];
						xattrItem.changeAttr.Add(item2);
					}
				}
			}
		}

		private static void MakeXLotteryBoxItem(ref XItem item, Item KKSGItem)
		{
			bool flag = item == null;
			if (flag)
			{
				item = XDataPool<XLotteryBoxItem>.GetData();
			}
			XLotteryBoxItem xlotteryBoxItem = item as XLotteryBoxItem;
			int num = 0;
			while (num < KKSGItem.circleDrawDatas.Count && num < XLotteryBoxItem.POOL_SIZE)
			{
				CircleDrawData circleDrawData = KKSGItem.circleDrawDatas[num];
				bool flag2 = (ulong)circleDrawData.index >= (ulong)((long)XLotteryBoxItem.POOL_SIZE);
				if (!flag2)
				{
					XItem xitem = xlotteryBoxItem.itemList[(int)circleDrawData.index];
					xitem.itemID = (int)circleDrawData.itemid;
					xitem.itemCount = (int)circleDrawData.itemcount;
				}
				num++;
			}
		}

		public static XItem MakeXItem(int itemID, bool bBinding = false)
		{
			ItemList.RowData itemConf = XBagDocument.GetItemConf(itemID);
			XItem xitem = null;
			bool flag = itemConf != null;
			if (flag)
			{
				ItemType itemType = (ItemType)itemConf.ItemType;
				ItemType itemType2 = itemType;
				switch (itemType2)
				{
				case ItemType.EQUIP:
					xitem = XDataPool<XEquipItem>.GetData();
					goto IL_7F;
				case ItemType.PECK:
				case ItemType.VIRTUAL_ITEM:
				case ItemType.MATERAIL:
					break;
				case ItemType.FASHION:
					xitem = XDataPool<XFashionItem>.GetData();
					goto IL_7F;
				case ItemType.EMBLEM:
					xitem = XDataPool<XEmblemItem>.GetData();
					goto IL_7F;
				case ItemType.JADE:
					xitem = XDataPool<XJadeItem>.GetData();
					goto IL_7F;
				default:
					if (itemType2 == ItemType.ARTIFACT)
					{
						xitem = XDataPool<XArtifactItem>.GetData();
						goto IL_7F;
					}
					break;
				}
				xitem = XDataPool<XNormalItem>.GetData();
				IL_7F:
				xitem.itemID = itemID;
				xitem.type = (uint)itemConf.ItemType;
				xitem.itemCount = (int)XBagDocument.BagDoc.GetItemCount(itemID);
				xitem.bBinding = bBinding;
				xitem.blocking = 0.0;
				xitem.itemConf = itemConf;
				ItemType itemType3 = itemType;
				switch (itemType3)
				{
				case ItemType.EQUIP:
				{
					EquipList.RowData equipConf = XBagDocument.GetEquipConf(itemID);
					bool flag2 = equipConf != null;
					if (flag2)
					{
						XEquipItem xequipItem = xitem as XEquipItem;
						for (int i = 0; i < equipConf.Attributes.Count; i++)
						{
							XItemChangeAttr item;
							item.AttrID = (uint)equipConf.Attributes[i, 0];
							item.AttrValue = (uint)equipConf.Attributes[i, 1];
							xequipItem.changeAttr.Add(item);
						}
						xequipItem.randAttrInfo.bPreview = true;
						xequipItem.forgeAttrInfo.bPreview = true;
					}
					break;
				}
				case ItemType.PECK:
				case ItemType.VIRTUAL_ITEM:
				case ItemType.MATERAIL:
					break;
				case ItemType.FASHION:
				{
					XFashionDocument specificDocument = XDocuments.GetSpecificDocument<XFashionDocument>(XFashionDocument.uuID);
					SeqListRef<uint> fashionAttr = specificDocument.GetFashionAttr(itemID, 0);
					XFashionItem xfashionItem = xitem as XFashionItem;
					xfashionItem.itemCount = 1;
					for (int j = 0; j < fashionAttr.Count; j++)
					{
						XItemChangeAttr item2;
						item2.AttrID = fashionAttr[j, 0];
						item2.AttrValue = fashionAttr[j, 1];
						xfashionItem.changeAttr.Add(item2);
					}
					break;
				}
				case ItemType.EMBLEM:
				{
					XEmblemItem xemblemItem = xitem as XEmblemItem;
					xemblemItem.emblemInfo.thirdslot = 10u;
					xemblemItem.emblemInfo.level = (uint)itemConf.ReqLevel;
					int num;
					int num2;
					XEquipCreateDocument.GetEmblemAttrDataByID((uint)xitem.itemID, out num, out num2);
					bool flag3 = num >= 0;
					if (flag3)
					{
						for (int k = num; k < num2; k++)
						{
							AttributeEmblem.RowData attributeEmblem = XEquipCreateDocument.GetAttributeEmblem(k);
							bool flag4 = attributeEmblem.Position == 1 || attributeEmblem.Position == 2;
							if (flag4)
							{
								XItemChangeAttr item3;
								item3.AttrID = (uint)attributeEmblem.AttrID;
								item3.AttrValue = attributeEmblem.Range[0];
								xemblemItem.changeAttr.Add(item3);
							}
						}
					}
					break;
				}
				case ItemType.JADE:
				{
					XJadeDocument specificDocument2 = XDocuments.GetSpecificDocument<XJadeDocument>(XJadeDocument.uuID);
					JadeTable.RowData byJadeID = specificDocument2.jadeTable.GetByJadeID((uint)itemID);
					bool flag5 = byJadeID != null;
					if (flag5)
					{
						XJadeItem xjadeItem = xitem as XJadeItem;
						for (int l = 0; l < byJadeID.JadeAttributes.Count; l++)
						{
							XItemChangeAttr item4;
							item4.AttrID = byJadeID.JadeAttributes[l, 0];
							item4.AttrValue = byJadeID.JadeAttributes[l, 1];
							xjadeItem.changeAttr.Add(item4);
						}
					}
					break;
				}
				default:
					if (itemType3 == ItemType.ARTIFACT)
					{
						XArtifactItem xartifactItem = xitem as XArtifactItem;
						xartifactItem.RandAttrInfo.bPreview = true;
					}
					break;
				}
			}
			else
			{
				XSingleton<XDebug>.singleton.AddErrorLog("Cant find item config for id: " + itemID.ToString(), null, null, null, null, null);
			}
			return xitem;
		}

		public static XItem MakeXItem(Item KKSGItem)
		{
			XItem xitem = null;
			ItemType itemType = (ItemType)KKSGItem.ItemType;
			ItemType itemType2 = itemType;
			switch (itemType2)
			{
			case ItemType.EQUIP:
				XBagDocument.MakeXEquipItem(ref xitem, KKSGItem);
				goto IL_8B;
			case ItemType.PECK:
			case ItemType.VIRTUAL_ITEM:
			case ItemType.MATERAIL:
			case ItemType.FRAGMENT:
				break;
			case ItemType.FASHION:
				XBagDocument.MakeXFashionItem(ref xitem, KKSGItem);
				goto IL_8B;
			case ItemType.EMBLEM:
				XBagDocument.MakeXEmblemItem(ref xitem, KKSGItem);
				goto IL_8B;
			case ItemType.JADE:
				XBagDocument.MakeXJadeItem(ref xitem, KKSGItem);
				goto IL_8B;
			case ItemType.LOTTERY_BOX:
				XBagDocument.MakeXLotteryBoxItem(ref xitem, KKSGItem);
				goto IL_8B;
			default:
				if (itemType2 == ItemType.ARTIFACT)
				{
					XBagDocument.MakeXArtifactItem(ref xitem, KKSGItem);
					goto IL_8B;
				}
				break;
			}
			xitem = XDataPool<XNormalItem>.GetData();
			IL_8B:
			xitem.uid = KKSGItem.uid;
			xitem.type = KKSGItem.ItemType;
			xitem.itemID = (int)KKSGItem.ItemID;
			xitem.itemCount = (int)KKSGItem.ItemCount;
			xitem.bBinding = KKSGItem.isbind;
			xitem.itemConf = XBagDocument.GetItemConf(xitem.itemID);
			bool flag = xitem.itemConf == null && xitem.uid > 0UL;
			if (flag)
			{
				XSingleton<XDebug>.singleton.AddGreenLog("Cant find item config for id: ", xitem.itemID.ToString(), ", uid = ", xitem.uid.ToString(), null, null);
			}
			xitem.bexpirationTime = KKSGItem.expirationTime;
			double num = 0.0;
			bool flag2 = KKSGItem.cooldown > 0u;
			if (flag2)
			{
				num = XSingleton<UiUtility>.singleton.TimeFormatLastTime(KKSGItem.cooldown, true);
				bool flag3 = num < 0.0;
				if (flag3)
				{
					num = 0.0;
				}
			}
			xitem.blocking = num;
			return xitem;
		}

		public static XItem MakeFasionItemById(uint id)
		{
			XItem data = XDataPool<XFashionItem>.GetData();
			data.uid = 0UL;
			data.type = 5u;
			data.itemID = (int)id;
			data.itemCount = 1;
			return data;
		}

		public bool GetBodyPosByUID(ulong uid, out int pos, out XBodyBag bag, out bool isEquip)
		{
			bool itemPos = this.EquipBag.GetItemPos(uid, out pos);
			bool result;
			if (itemPos)
			{
				bag = this.EquipBag;
				isEquip = true;
				result = true;
			}
			else
			{
				bool itemPos2 = this.EmblemBag.GetItemPos(uid, out pos);
				if (itemPos2)
				{
					bag = this.EmblemBag;
					isEquip = false;
					result = true;
				}
				else
				{
					bool itemPos3 = this.ArtifactBag.GetItemPos(uid, out pos);
					if (itemPos3)
					{
						bag = this.ArtifactBag;
						isEquip = false;
						result = true;
					}
					else
					{
						bag = null;
						pos = -1;
						isEquip = false;
						result = false;
					}
				}
			}
			return result;
		}

		public XItem GetBodyItemByUID(ulong uid)
		{
			XItem itemByUID = this.EquipBag.GetItemByUID(uid);
			bool flag = itemByUID != null;
			XItem result;
			if (flag)
			{
				result = itemByUID;
			}
			else
			{
				itemByUID = this.EmblemBag.GetItemByUID(uid);
				bool flag2 = itemByUID != null;
				if (flag2)
				{
					result = itemByUID;
				}
				else
				{
					itemByUID = this.ArtifactBag.GetItemByUID(uid);
					bool flag3 = itemByUID != null;
					if (flag3)
					{
						result = itemByUID;
					}
					else
					{
						result = null;
					}
				}
			}
			return result;
		}

		public XItem GetBodyItemByID(int id)
		{
			XItem itemByID = this.EquipBag.GetItemByID(id);
			bool flag = itemByID != null;
			XItem result;
			if (flag)
			{
				result = itemByID;
			}
			else
			{
				itemByID = this.EmblemBag.GetItemByID(id);
				bool flag2 = itemByID != null;
				if (flag2)
				{
					result = itemByID;
				}
				else
				{
					itemByID = this.ArtifactBag.GetItemByID(id);
					bool flag3 = itemByID != null;
					if (flag3)
					{
						result = itemByID;
					}
					else
					{
						result = null;
					}
				}
			}
			return result;
		}

		public int GetBodyItemCountByID(int id)
		{
			int itemCountByID = this.EquipBag.GetItemCountByID(id);
			bool flag = itemCountByID == 0;
			if (flag)
			{
				itemCountByID = this.EmblemBag.GetItemCountByID(id);
			}
			bool flag2 = itemCountByID == 0;
			if (flag2)
			{
				itemCountByID = this.ArtifactBag.GetItemCountByID(id);
			}
			return itemCountByID;
		}

		public XItem GetBagItemByUID(ulong uid)
		{
			int key = 0;
			bool flag = this.ItemBag.FindItem(uid, out key);
			XItem result;
			if (flag)
			{
				result = this.ItemBag[key];
			}
			else
			{
				result = null;
			}
			return result;
		}

		public XItem GetBagItemByUID(string struid)
		{
			ulong uid = 0UL;
			bool flag = ulong.TryParse(struid, out uid);
			XItem result;
			if (flag)
			{
				result = this.GetBagItemByUID(uid);
			}
			else
			{
				result = null;
			}
			return result;
		}

		public XItem GetItemByUID(ulong uid)
		{
			int key = 0;
			XItem bodyItemByUID = this.GetBodyItemByUID(uid);
			bool flag = bodyItemByUID != null;
			XItem result;
			if (flag)
			{
				result = bodyItemByUID;
			}
			else
			{
				bool flag2 = this.ItemBag.FindItem(uid, out key);
				if (flag2)
				{
					result = this.ItemBag[key];
				}
				else
				{
					result = null;
				}
			}
			return result;
		}

		public XItem GetItemByUID(string struid)
		{
			ulong uid = 0UL;
			bool flag = ulong.TryParse(struid, out uid);
			XItem result;
			if (flag)
			{
				result = this.GetItemByUID(uid);
			}
			else
			{
				result = null;
			}
			return result;
		}

		public bool GetItemByItemId(int itemId, out List<XItem> lst)
		{
			return this.ItemBag.FindItemByID(itemId, out lst);
		}

		private static int ItemType2Int(ItemType type)
		{
			return XFastEnumIntEqualityComparer<ItemType>.ToInt(type);
		}

		public static int BodyPosition<T>(T type) where T : struct
		{
			return XFastEnumIntEqualityComparer<T>.ToInt(type);
		}

		internal static void InitAddEquiptItem(ref XBodyBag bag, List<Item> list, int bagSize)
		{
			bool flag = bag == null;
			if (flag)
			{
				bag = new XBodyBag(bagSize);
			}
			for (int i = 0; i < bag.Length; i++)
			{
				bool flag2 = bag[i] != null;
				if (flag2)
				{
					bag[i].Recycle();
					bag[i] = null;
				}
			}
			int num = Math.Min(list.Count, bag.Length);
			for (int j = 0; j < num; j++)
			{
				XItem xitem = XBagDocument.MakeXItem(list[j]);
				bool flag3 = xitem.itemID == 0;
				if (flag3)
				{
					xitem.Recycle();
					xitem = null;
				}
				bag[j] = xitem;
			}
		}

		internal void Init(BagContent Bag)
		{
			XEmblemDocument.HadSlottingNum = (int)Bag.extraSkillEbSlotNum;
			for (int i = 0; i < Bag.expand.Count; i++)
			{
				this.SetBagExpandData(Bag.expand[i], false);
			}
			XBagDocument.InitAddEquiptItem(ref this.EquipBag, Bag.Equips, XBagDocument.EquipMax);
			XBagDocument.InitAddEquiptItem(ref this.EmblemBag, Bag.Emblems, XBagDocument.EmblemMax);
			XBagDocument.InitAddEquiptItem(ref this.ArtifactBag, Bag.Artifacts, XBagDocument.ArtifactMax);
			int count = this.ItemBag.Count;
			for (int j = 0; j < count; j++)
			{
				this.ItemBag[j].Recycle();
			}
			this.ItemBag.Clear();
			for (int k = 0; k < Bag.Items.Count; k++)
			{
				XItem item = XBagDocument.MakeXItem(Bag.Items[k]);
				this.ItemBag.AddItem(item, false);
			}
			int l;
			for (l = 0; l < Bag.virtualitems.Count; l++)
			{
				this.VirtualItems[l] = Bag.virtualitems[l];
			}
			while (l < this.VirtualItems.Length)
			{
				this.VirtualItems[l] = 0UL;
				l++;
			}
			this.ItemBag.SortItem();
			XJadeDocument specificDocument = XDocuments.GetSpecificDocument<XJadeDocument>(XJadeDocument.uuID);
			specificDocument.UpdateRedPoints();
			XEnhanceDocument specificDocument2 = XDocuments.GetSpecificDocument<XEnhanceDocument>(XEnhanceDocument.uuID);
			specificDocument2.UpdateRedPoints();
			XEnchantDocument specificDocument3 = XDocuments.GetSpecificDocument<XEnchantDocument>(XEnchantDocument.uuID);
			specificDocument3.UpdateRedPoints();
			XSingleton<XAttributeMgr>.singleton.XPlayerData.Outlook.enhanceMasterLevel = Bag.enhanceSuit;
			XSingleton<XAttributeMgr>.singleton.XPlayerData.EmblemBag = this.EmblemBag;
			this.TearsCount = (ulong)((long)this.ItemBag.GetItemCount(88));
		}

		public void SetBagExpandData(KKSG.BagExpandData data, bool isShowTip)
		{
			for (int i = 0; i < this.BagExpandDataList.Count; i++)
			{
				bool flag = this.BagExpandDataList[i].Type == data.type;
				if (flag)
				{
					this.BagExpandDataList[i].ExpandNum = data.num;
					this.BagExpandDataList[i].ExpandTimes = data.count;
					if (isShowTip)
					{
						switch (data.type)
						{
						case BagType.EquipBag:
						{
							XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("ExpandEquipBagSuc"), "fece00");
							XCharacterEquipDocument specificDocument = XDocuments.GetSpecificDocument<XCharacterEquipDocument>(XCharacterEquipDocument.uuID);
							specificDocument.RefreshBag();
							break;
						}
						case BagType.EmblemBag:
						{
							XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("ExpandEmblemBagSuc"), "fece00");
							XEmblemDocument specificDocument2 = XDocuments.GetSpecificDocument<XEmblemDocument>(XEmblemDocument.uuID);
							specificDocument2.RefreshBag();
							break;
						}
						case BagType.ArtifactBag:
							XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("ExpandArtifactBagSuc"), "fece00");
							ArtifactBagDocument.Doc.RefreshBag();
							break;
						case BagType.ItemBag:
						{
							XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("ExpandItemBagSuc"), "fece00");
							XCharacterItemDocument specificDocument3 = XDocuments.GetSpecificDocument<XCharacterItemDocument>(XCharacterItemDocument.uuID);
							specificDocument3.RefreshBag();
							break;
						}
						}
					}
					break;
				}
			}
		}

		public void UseBagExpandTicket(BagType type)
		{
			BagExpandItemListTable.RowData expandItemConfByType = XBagDocument.GetExpandItemConfByType((uint)XFastEnumIntEqualityComparer<BagType>.ToInt(type));
			bool flag = expandItemConfByType == null;
			if (!flag)
			{
				this.m_usedBagExpandRow = expandItemConfByType;
				int itemId = (int)expandItemConfByType.ItemId;
				BagExpandData bagExpandData = XBagDocument.BagDoc.GetBagExpandData((BagType)expandItemConfByType.Type);
				bool flag2 = bagExpandData != null;
				if (flag2)
				{
					bool flag3 = (uint)expandItemConfByType.NeedAndOpen.count > bagExpandData.ExpandTimes;
					if (flag3)
					{
						ItemList.RowData itemConf = XBagDocument.GetItemConf(itemId);
						XSingleton<UiUtility>.singleton.ShowModalDialog(string.Format(XSingleton<XStringTable>.singleton.GetString("BagExpandSureTips"), expandItemConfByType.NeedAndOpen[(int)bagExpandData.ExpandTimes, 0], itemConf.ItemName[0], expandItemConfByType.NeedAndOpen[(int)bagExpandData.ExpandTimes, 1]), XStringDefineProxy.GetString("COMMON_OK"), XStringDefineProxy.GetString("COMMON_CANCEL"), new ButtonClickEventHandler(this.ReqUseBagExpandTicket));
					}
					else
					{
						XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<UiUtility>.singleton.GetBagExpandFullTips((BagType)expandItemConfByType.Type), "fece00");
					}
				}
			}
		}

		private bool ReqUseBagExpandTicket(IXUIButton btn)
		{
			BagExpandItemListTable.RowData usedBagExpandRow = this.m_usedBagExpandRow;
			bool flag = usedBagExpandRow == null;
			bool result;
			if (flag)
			{
				result = false;
			}
			else
			{
				int itemId = (int)usedBagExpandRow.ItemId;
				BagExpandData bagExpandData = XBagDocument.BagDoc.GetBagExpandData((BagType)usedBagExpandRow.Type);
				bool flag2 = bagExpandData != null;
				if (flag2)
				{
					ulong itemCount = XBagDocument.BagDoc.GetItemCount(itemId);
					bool flag3 = itemCount >= (ulong)usedBagExpandRow.NeedAndOpen[(int)bagExpandData.ExpandTimes, 0] && itemCount > 0UL;
					if (flag3)
					{
						List<XItem> list;
						bool itemByItemId = this.GetItemByItemId(itemId, out list);
						if (itemByItemId)
						{
							XSingleton<XGame>.singleton.Doc.XBagDoc.UseItem(list[0], 0u);
						}
					}
					else
					{
						XSingleton<UiUtility>.singleton.ShowItemAccess(itemId, null);
					}
				}
				XSingleton<UiUtility>.singleton.CloseModalDlg();
				result = true;
			}
			return result;
		}

		internal ulong GetItemCount(int itemid)
		{
			bool flag = itemid < XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.VIRTUAL_ITEM_MAX);
			ulong result;
			if (flag)
			{
				result = this.GetVirtualItemCount((ItemEnum)itemid);
			}
			else
			{
				result = (ulong)((long)this.ItemBag.GetItemCount(itemid));
			}
			return result;
		}

		internal ulong GetItemCount(int itemid, bool isBind)
		{
			bool flag = itemid < XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.VIRTUAL_ITEM_MAX);
			ulong result;
			if (flag)
			{
				result = this.GetVirtualItemCount((ItemEnum)itemid);
			}
			else
			{
				result = (ulong)((long)this.ItemBag.GetItemCount(itemid, isBind));
			}
			return result;
		}

		internal ulong GetVirtualItemCount(ItemEnum t)
		{
			return this.VirtualItems[XFastEnumIntEqualityComparer<ItemEnum>.ToInt(t)];
		}

		internal ulong GetSkillPointCount(bool isAwakeSkillPoint = false)
		{
			bool flag = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillPageIndex == 0u;
			ulong result;
			if (flag)
			{
				result = this.VirtualItems[XFastEnumIntEqualityComparer<ItemEnum>.ToInt(isAwakeSkillPoint ? ItemEnum.AWAKE_SKILL_POINT : ItemEnum.SKILL_POINT)];
			}
			else
			{
				result = this.VirtualItems[XFastEnumIntEqualityComparer<ItemEnum>.ToInt(isAwakeSkillPoint ? ItemEnum.AWAKE_SKILL_POINT_TWO : ItemEnum.SKILL_POINT_TWO)];
			}
			return result;
		}

		internal void SetVirtualItemCount(int t, ulong Count)
		{
			ulong oldValue = 0UL;
			bool flag = t < XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.VIRTUAL_ITEM_MAX);
			if (flag)
			{
				oldValue = this.VirtualItems[t];
				this.VirtualItems[t] = Count;
			}
			else
			{
				bool flag2 = t == 88;
				if (flag2)
				{
					oldValue = this.TearsCount;
					this.TearsCount = Count;
				}
			}
			bool flag3 = t == 6;
			if (flag3)
			{
				XSingleton<XDebug>.singleton.AddLog("Set fatigue = ", Count.ToString(), null, null, null, null, XDebugColor.XDebug_None);
			}
			XVirtualItemChangedEventArgs @event = XEventPool<XVirtualItemChangedEventArgs>.GetEvent();
			@event.e = (ItemEnum)t;
			@event.newValue = Count;
			@event.oldValue = oldValue;
			@event.itemID = t;
			@event.Firer = XSingleton<XGame>.singleton.Doc;
			XSingleton<XEventMgr>.singleton.FireEvent(@event);
		}

		internal void UpdateItem(Item KKSGItem)
		{
			XItem xitem = XBagDocument.MakeXItem(KKSGItem);
			int key;
			bool flag = this.ItemBag.FindItem(xitem.uid, out key);
			if (flag)
			{
				this.ItemBag[key].Recycle();
				this.ItemBag[key] = xitem;
			}
			else
			{
				bool flag2 = xitem.Type == ItemType.EQUIP;
				if (flag2)
				{
					this.EquipBag.UpdateItem(xitem);
				}
				else
				{
					bool flag3 = xitem.Type == ItemType.EMBLEM;
					if (flag3)
					{
						this.EmblemBag.UpdateItem(xitem);
					}
					else
					{
						bool flag4 = xitem.Type == ItemType.ARTIFACT;
						if (flag4)
						{
							this.ArtifactBag.UpdateItem(xitem);
						}
					}
				}
			}
			XUpdateItemEventArgs @event = XEventPool<XUpdateItemEventArgs>.GetEvent();
			@event.item = xitem;
			@event.Firer = XSingleton<XGame>.singleton.Doc;
			XSingleton<XEventMgr>.singleton.FireEvent(@event);
		}

		internal void AddNewItem(Item KKSGItem)
		{
			XItem item = XBagDocument.MakeXItem(KKSGItem);
			this.ItemBag.AddItem(item, true);
			XAddItemEventArgs @event = XEventPool<XAddItemEventArgs>.GetEvent();
			@event.items.Add(item);
			@event.Firer = XSingleton<XGame>.singleton.Doc;
			XSingleton<XEventMgr>.singleton.FireEvent(@event);
		}

		internal void AddNewItem(List<Item> KKSGItems, bool bIsNew = true)
		{
			XAddItemEventArgs @event = XEventPool<XAddItemEventArgs>.GetEvent();
			@event.Firer = XSingleton<XGame>.singleton.Doc;
			@event.bNew = bIsNew;
			foreach (Item kksgitem in KKSGItems)
			{
				XItem item = XBagDocument.MakeXItem(kksgitem);
				this.ItemBag.AddItem(item, false);
				@event.items.Add(item);
			}
			bool flag = @event.items.Count > 0;
			if (flag)
			{
				this.ItemBag.SortItem();
				XSingleton<XEventMgr>.singleton.FireEvent(@event);
			}
			else
			{
				@event.Recycle();
			}
		}

		internal void RemoveItem(ulong uid)
		{
			int num;
			bool flag = this.ItemBag.FindItem(uid, out num);
			if (flag)
			{
				XRemoveItemEventArgs @event = XEventPool<XRemoveItemEventArgs>.GetEvent();
				@event.uids.Add(uid);
				@event.types.Add(this.ItemBag[num].Type);
				@event.ids.Add(this.ItemBag[num].itemID);
				this.ItemBag.RemoveIndex(num);
				@event.Firer = XSingleton<XGame>.singleton.Doc;
			}
		}

		internal void RemoveItem(List<ulong> uids)
		{
			XRemoveItemEventArgs @event = XEventPool<XRemoveItemEventArgs>.GetEvent();
			@event.Firer = XSingleton<XGame>.singleton.Doc;
			foreach (ulong num in uids)
			{
				int num2;
				bool flag = this.ItemBag.FindItem(num, out num2);
				if (flag)
				{
					XItem xitem = this.ItemBag[num2];
					@event.uids.Add(num);
					@event.types.Add(xitem.Type);
					@event.ids.Add(xitem.itemID);
					xitem.Recycle();
					this.ItemBag.RemoveIndex(num2);
				}
			}
			bool flag2 = @event.uids.Count > 0;
			if (flag2)
			{
				XSingleton<XEventMgr>.singleton.FireEvent(@event);
			}
			else
			{
				@event.Recycle();
			}
		}

		internal void ChangeItemCount(ulong uid, int count, bool bIsNew = true)
		{
			int key;
			bool flag = this.ItemBag.FindItem(uid, out key);
			if (flag)
			{
				XItem xitem = this.ItemBag[key];
				int itemCount = xitem.itemCount;
				xitem.itemCount = count;
				XItemNumChangedEventArgs @event = XEventPool<XItemNumChangedEventArgs>.GetEvent();
				@event.oldCount = itemCount;
				@event.item = xitem;
				@event.Firer = XSingleton<XGame>.singleton.Doc;
				@event.bNew = bIsNew;
				XSingleton<XEventMgr>.singleton.FireEvent(@event);
			}
		}

		internal void FinishItemChange()
		{
			XItemChangeFinishedEventArgs @event = XEventPool<XItemChangeFinishedEventArgs>.GetEvent();
			@event.Firer = XSingleton<XGame>.singleton.Doc;
			XSingleton<XEventMgr>.singleton.FireEvent(@event);
		}

		private void _RemoveCompareAttrsFromPool(ulong uid)
		{
			this.basicAttrPool.Remove(uid);
			this.equipAdditionalAttrPool.Remove(uid);
		}

		public uint GetItemPPT(XAttrItem item, ItemAttrCompareType type)
		{
			bool flag = item == null;
			uint result;
			if (flag)
			{
				result = 0u;
			}
			else
			{
				Dictionary<ulong, uint> dictionary = null;
				if (type != ItemAttrCompareType.IACT_SELF)
				{
					if (type == ItemAttrCompareType.IACT_TOTAL)
					{
						dictionary = this.equipAdditionalAttrPool;
					}
				}
				else
				{
					dictionary = this.basicAttrPool;
				}
				uint num = 0u;
				ulong num2 = item.uid;
				bool flag2 = num2 == 0UL;
				if (flag2)
				{
					num2 = (ulong)((long)item.itemID);
				}
				bool flag3 = !dictionary.TryGetValue(num2, out num);
				if (flag3)
				{
					XEquipItem xequipItem = item as XEquipItem;
					double num3 = 0.0;
					bool flag4 = (type & ItemAttrCompareType.IACT_BASIC) > (ItemAttrCompareType)0;
					if (flag4)
					{
						for (int i = 0; i < item.changeAttr.Count; i++)
						{
							num3 += XSingleton<XPowerPointCalculator>.singleton.GetPPT(item.changeAttr[i], null, -1);
						}
					}
					bool flag5 = xequipItem != null && (type & ItemAttrCompareType.IACT_RANDOM) > (ItemAttrCompareType)0;
					if (flag5)
					{
						for (int j = 0; j < xequipItem.randAttrInfo.RandAttr.Count; j++)
						{
							num3 += XSingleton<XPowerPointCalculator>.singleton.GetPPT(xequipItem.randAttrInfo.RandAttr[j], null, -1);
						}
					}
					bool flag6 = xequipItem != null && (type & ItemAttrCompareType.IACT_FORGE) > (ItemAttrCompareType)0;
					if (flag6)
					{
						for (int k = 0; k < xequipItem.forgeAttrInfo.ForgeAttr.Count; k++)
						{
							num3 += XSingleton<XPowerPointCalculator>.singleton.GetPPT(xequipItem.forgeAttrInfo.ForgeAttr[k], null, -1);
						}
					}
					bool flag7 = xequipItem != null && (type & ItemAttrCompareType.IACT_ENHANCE) > (ItemAttrCompareType)0;
					if (flag7)
					{
						for (int l = 0; l < xequipItem.enhanceInfo.EnhanceAttr.Count; l++)
						{
							num3 += XSingleton<XPowerPointCalculator>.singleton.GetPPT(xequipItem.enhanceInfo.EnhanceAttr[l], null, -1);
						}
					}
					bool flag8 = xequipItem != null && (type & ItemAttrCompareType.IACT_JADE) > (ItemAttrCompareType)0;
					if (flag8)
					{
						for (int m = 0; m < xequipItem.jadeInfo.jades.Length; m++)
						{
							num3 += this.GetItemPPT(xequipItem.jadeInfo.jades[m], ItemAttrCompareType.IACT_SELF);
						}
					}
					num = (uint)num3;
					dictionary.Add(num2, num);
				}
				result = num;
			}
			return result;
		}

		public override void Update(float fDeltaT)
		{
			bool flag = this.ItemBag == null;
			if (!flag)
			{
				int i = 0;
				int count = this.ItemBag.Count;
				while (i < count)
				{
					bool flag2 = !this.ItemBag[i].bBinding && this.ItemBag[i].blocking > 0.0;
					if (flag2)
					{
						this.ItemBag[i].blocking -= (double)fDeltaT;
					}
					i++;
				}
				bool flag3 = this.getallEquip;
				if (flag3)
				{
					this.fashionTime += fDeltaT;
					bool flag4 = this.fashionTime > 0.3f;
					if (flag4)
					{
						this.fashionTime = 0f;
						bool flag5 = this.fashionIndex < XBagDocument.m_FashionTable.Table.Length;
						if (flag5)
						{
							FashionList.RowData[] table = XBagDocument.m_FashionTable.Table;
							int num = this.fashionIndex;
							this.fashionIndex = num + 1;
							FashionList.RowData rowData = table[num];
							string command = string.Format("item {0} 1", rowData.ItemID);
							XSingleton<XCommand>.singleton.ProcessCommand(command);
						}
						else
						{
							this.getallEquip = false;
						}
					}
				}
			}
		}

		public ItemAttrCompareResult IsAttrMorePowerful(XAttrItem left, XAttrItem right, ItemAttrCompareType type = ItemAttrCompareType.IACT_SELF)
		{
			uint itemPPT = this.GetItemPPT(left, type);
			uint itemPPT2 = this.GetItemPPT(right, type);
			bool flag = itemPPT < itemPPT2;
			ItemAttrCompareResult result;
			if (flag)
			{
				result = ItemAttrCompareResult.IACR_SMALLER;
			}
			else
			{
				bool flag2 = itemPPT > itemPPT2;
				if (flag2)
				{
					result = ItemAttrCompareResult.IACR_LARGER;
				}
				else
				{
					result = ItemAttrCompareResult.IACR_EQUAL;
				}
			}
			return result;
		}

		public uint GetArtifactPPT(XAttrItem item)
		{
			bool flag = item == null;
			uint result;
			if (flag)
			{
				result = 0u;
			}
			else
			{
				XArtifactItem xartifactItem = item as XArtifactItem;
				bool flag2 = xartifactItem == null;
				if (flag2)
				{
					result = 0u;
				}
				else
				{
					double num = 0.0;
					for (int i = 0; i < xartifactItem.RandAttrInfo.RandAttr.Count; i++)
					{
						bool flag3 = xartifactItem.RandAttrInfo.RandAttr[i].AttrID == 0u;
						if (!flag3)
						{
							num += XSingleton<XPowerPointCalculator>.singleton.GetPPT(xartifactItem.RandAttrInfo.RandAttr[i], null, -1);
						}
					}
					result = (uint)num;
				}
			}
			return result;
		}

		public void ReqItemSell(ulong uid)
		{
			RpcC2G_ItemSell rpcC2G_ItemSell = new RpcC2G_ItemSell();
			rpcC2G_ItemSell.oArg.uid = uid;
			XSingleton<XClientNetwork>.singleton.Send(rpcC2G_ItemSell);
		}

		public void ReqItemCompose(ulong uid)
		{
			RpcC2G_ItemCompose rpcC2G_ItemCompose = new RpcC2G_ItemCompose();
			rpcC2G_ItemCompose.oArg.uid = uid.ToString();
			XSingleton<XClientNetwork>.singleton.Send(rpcC2G_ItemCompose);
		}

		public static bool ItemCanShowTips(uint itemID)
		{
			ItemList.RowData itemConf = XBagDocument.GetItemConf((int)itemID);
			bool flag = itemConf == null;
			bool result;
			if (flag)
			{
				result = false;
			}
			else
			{
				bool flag2 = itemConf.ShowTips == 0;
				result = !flag2;
			}
			return result;
		}

		protected override void OnReconnected(XReconnectedEventArgs arg)
		{
			this.Init(arg.PlayerInfo.Bag);
			bool flag = XSingleton<XEntityMgr>.singleton.Player == null;
			if (!flag)
			{
				XEquipComponent xequipComponent = XSingleton<XEntityMgr>.singleton.Player.GetXComponent(XEquipComponent.uuID) as XEquipComponent;
				bool flag2 = xequipComponent != null;
				if (flag2)
				{
					xequipComponent.EquipFromAttr();
				}
			}
		}

		public void GetAllEquip()
		{
			this.getallEquip = true;
			this.fashionIndex = 0;
			this.fashionTime = 0.4f;
		}
	}
}