using System;
using System.Collections.Generic;
using KKSG;
using UILib;
using UnityEngine;
using XMainClient.UI.UICommon;
using XUpdater;
using XUtliPoolLib;

namespace XMainClient.UI
{
	internal class DragonCrusadeDlg : DlgBase<DragonCrusadeDlg, DragonCrusadeBehavior>
	{
		public override string fileName
		{
			get
			{
				return "DragonCrusade/DragonCrusadeDlg";
			}
		}

		public override bool hideMainMenu
		{
			get
			{
				return true;
			}
		}

		public override bool pushstack
		{
			get
			{
				return true;
			}
		}

		public override bool autoload
		{
			get
			{
				return true;
			}
		}

		public bool isHallUI
		{
			get
			{
				return XSingleton<XGame>.singleton.CurrentStage.Stage == EXStage.Hall;
			}
		}

		public override bool fullscreenui
		{
			get
			{
				return true;
			}
		}

		public override int sysid
		{
			get
			{
				return 50;
			}
		}

		private XDragonCrusadeDocument mDoc = null;

		private GameObject goDragonExpedition = null;

		private IXDragonExpedition ixDragonExpedition = null;

		private XFx _FxFirework = null;

		private const int MAX_RANK = 3;

		public Dictionary<uint, GameObject> listBillBoards = new Dictionary<uint, GameObject>();

		private Vector3 localDefaultScale = new Vector3(-0.02f, 0.02f, 0.02f);

		private Action<bool> mSyncDoneCallBack = null;

		private bool mSyncLoading = false;

		private bool mDoneFinish = false;

		private float intertime = 0.5f;

		private LoadCallBack mDragonExpeditionLoadTask = null;

		private Dictionary<int, XDummy> m_AvatarDummys = new Dictionary<int, XDummy>();

		private class DragonExpeditionLoadTask
		{
			private DragonCrusadeDlg mDlg;

			public DragonExpeditionLoadTask(DragonCrusadeDlg dlg)
			{
				this.mDlg = dlg;
			}

			public void LoadFinish(UnityEngine.Object obj)
			{
				bool flag = this.mDlg != null;
				if (flag)
				{
					this.mDlg.goDragonExpedition = (obj as GameObject);
					this.mDlg.LoadPrefabSyncDone();
					this.mDlg = null;
				}
			}
		}

		protected override void OnLoad()
		{
			base.OnLoad();
			this.mDoc = (XSingleton<XGame>.singleton.Doc.GetXComponent(XDragonCrusadeDocument.uuID) as XDragonCrusadeDocument);
			bool flag = this.mDragonExpeditionLoadTask == null;
			if (flag)
			{
				this.mDragonExpeditionLoadTask = new LoadCallBack(this.LoadFinish);
			}
		}

		protected override void Init()
		{
			base.Init();
			base.uiBehaviour.goLoadingTxt.SetText(XStringDefineProxy.GetString("DragonLoadMessage"));
		}

		private void LoadFinish(UnityEngine.Object obj, object cbOjb)
		{
			bool flag = !base.IsLoaded();
			if (!flag)
			{
				this.goDragonExpedition = (obj as GameObject);
				this.LoadPrefabSyncDone();
			}
		}

		public override void RegisterEvent()
		{
			base.RegisterEvent();
			this.m_uiBehaviour.slideSprite.RegisterSpriteDragEventHandler(new SpriteDragEventHandler(this.OnMonsterDrag));
			this.m_uiBehaviour.slideSprite.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnMouseClick));
			base.uiBehaviour.m_Help.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnHelpClicked));
			this.m_uiBehaviour.m_myRankSpr.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnRankInfo));
			base.uiBehaviour.m_closed.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnClose));
			base.uiBehaviour.m_leftBtn.ID = 1UL;
			base.uiBehaviour.m_rightBtn.ID = 2UL;
		}

		public bool OnHelpClicked(IXUIButton button)
		{
			DlgBase<XCommonHelpTipView, XCommonHelpTipBehaviour>.singleton.ShowHelp(XSysDefine.XSys_DragonCrusade);
			return true;
		}

		protected override void OnHide()
		{
			base.OnHide();
			bool flag = this.ixDragonExpedition != null;
			if (flag)
			{
				this.ixDragonExpedition.GetDragonCamera().enabled = false;
			}
		}

		protected override void OnShow()
		{
			base.OnShow();
			base.Alloc3DAvatarPool("DragonCrusadeDlg");
			bool flag = this.ixDragonExpedition != null;
			if (flag)
			{
				this.ixDragonExpedition.GetDragonCamera().enabled = true;
			}
		}

		protected override void OnUnload()
		{
			this.mDoneFinish = false;
			this.mSyncLoading = false;
			bool flag = this._FxFirework != null;
			if (flag)
			{
				XSingleton<XFxMgr>.singleton.DestroyFx(this._FxFirework, true);
			}
			this._FxFirework = null;
			this.DeleteAvatar();
			this.UnloadPrefab();
			foreach (KeyValuePair<uint, GameObject> keyValuePair in this.listBillBoards)
			{
				XSingleton<XResourceLoaderMgr>.singleton.UnSafeDestroy(keyValuePair.Value, true, false);
			}
			this.listBillBoards.Clear();
			base.OnUnload();
		}

		public override void StackRefresh()
		{
			base.StackRefresh();
			base.Alloc3DAvatarPool("DragonCrusadeDlg");
			bool flag = this.ixDragonExpedition != null;
			if (flag)
			{
				this.ixDragonExpedition.GetDragonCamera().enabled = true;
			}
		}

		public override void OnXNGUIClick(GameObject obj, string path)
		{
			base.OnXNGUIClick(obj, path);
		}

		private void LoadPrefab()
		{
		}

		private void UnloadPrefab()
		{
			this.ixDragonExpedition = null;
			XResourceLoaderMgr.SafeDestroy(ref this.goDragonExpedition, true);
		}

		protected void OnMonsterDrag(IXUIButton button, Vector2 delta)
		{
			bool flag = button.ID == 1UL;
			if (flag)
			{
				delta = Vector2.one * (float)Screen.width;
			}
			else
			{
				delta = Vector2.one * (float)(-(float)Screen.width);
			}
			bool flag2 = this.ixDragonExpedition == null;
			if (!flag2)
			{
				this.ixDragonExpedition.Drag(delta.x);
			}
		}

		protected bool OnMonsterDrag(Vector2 delta)
		{
			bool flag = this.ixDragonExpedition == null;
			bool result;
			if (flag)
			{
				result = true;
			}
			else
			{
				this.ixDragonExpedition.Drag(delta.x);
				result = true;
			}
			return result;
		}

		protected void OnMouseClick(IXUISprite sp)
		{
			bool flag = this.ixDragonExpedition == null;
			if (!flag)
			{
				GameObject gameObject = this.ixDragonExpedition.Click();
				bool flag2 = gameObject != null;
				if (flag2)
				{
					this.OnGateInfo(gameObject.name);
				}
			}
		}

		private bool OnClose(IXUIButton btn)
		{
			this.SetVisible(false, true);
			XSingleton<XTutorialHelper>.singleton.DragonCrusadeOpen = false;
			return true;
		}

		private void OnGateInfo(string gatename)
		{
			DlgBase<DragonCrusadeGateDlg, DragonCrusadeGateBehavior>.singleton.SetVisibleWithAnimation(true, null);
			for (int i = 0; i < XDragonCrusadeDocument._DragonCrusageGateDataInfo.Count; i++)
			{
				DragonCrusageGateData dragonCrusageGateData = XDragonCrusadeDocument._DragonCrusageGateDataInfo[i];
				bool flag = dragonCrusageGateData.expData.ResName == gatename;
				if (flag)
				{
					DlgBase<DragonCrusadeGateDlg, DragonCrusadeGateBehavior>.singleton.SetVisible(true, true);
					DlgBase<DragonCrusadeGateDlg, DragonCrusadeGateBehavior>.singleton.FreshInfo(dragonCrusageGateData);
				}
			}
		}

		public void OnRankInfo(IXUISprite uiSprite)
		{
			DlgBase<DragonCrusadeRankDlg, DragonCrusadeRankBehavior>.singleton.SetVisible(true, true);
			DlgBase<DragonCrusadeRankDlg, DragonCrusadeRankBehavior>.singleton.RefreshRankWindow(this.mDoc.oResRank);
		}

		public void RefreshRank(DERankRes oRes)
		{
			for (int i = 0; i < 3; i++)
			{
				Transform transform = base.uiBehaviour.transform.Find("Bg/MyRank/ScrollView/Tpl" + (i + 1).ToString());
				IXUILabel ixuilabel = transform.Find("Rank").GetComponent("XUILabel") as IXUILabel;
				IXUILabel ixuilabel2 = transform.Find("Name").GetComponent("XUILabel") as IXUILabel;
				IXUILabel ixuilabel3 = transform.Find("Reward").GetComponent("XUILabel") as IXUILabel;
				IXUISprite ixuisprite = transform.transform.Find("RankImage").GetComponent("XUISprite") as IXUISprite;
				DERank derank = (i < oRes.ranks.Count) ? oRes.ranks[i] : null;
				bool flag = derank != null;
				if (flag)
				{
					ixuilabel.SetText("No." + derank.rank);
					bool flag2 = i < 3;
					if (flag2)
					{
						ixuisprite.SetSprite("N" + (i + 1));
						ixuisprite.SetVisible(true);
						ixuilabel.SetVisible(false);
					}
					else
					{
						ixuisprite.SetVisible(false);
						ixuilabel.SetVisible(true);
					}
					ixuilabel2.SetText(derank.rolename);
					string text = string.Empty;
					for (int j = 0; j < derank.reward.Count; j++)
					{
						ItemBrief itemBrief = derank.reward[j];
						ItemList.RowData itemConf = XBagDocument.GetItemConf((int)itemBrief.itemID);
						text += itemBrief.itemCount.ToString();
					}
					ixuilabel3.gameObject.SetActive(true);
					ixuilabel3.SetText(text);
				}
				else
				{
					ixuisprite.SetVisible(false);
					ixuilabel2.SetText("");
					ixuilabel.SetText("");
					ixuilabel3.SetText("");
					ixuilabel3.gameObject.SetActive(false);
				}
			}
			bool flag3 = false;
			for (int k = 0; k < oRes.ranks.Count; k++)
			{
				DERank derank2 = oRes.ranks[k];
				bool flag4 = derank2.roleID == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
				if (flag4)
				{
					flag3 = true;
					base.SetXUILable("Bg/MyRank/My/Rank", derank2.rank.ToString());
					base.SetXUILable("Bg/MyRank/My/Name", XSingleton<XAttributeMgr>.singleton.XPlayerData.Name);
					string text2 = string.Empty;
					for (int l = 0; l < derank2.reward.Count; l++)
					{
						ItemBrief itemBrief2 = derank2.reward[l];
						ItemList.RowData itemConf2 = XBagDocument.GetItemConf((int)itemBrief2.itemID);
						text2 += itemBrief2.itemCount.ToString();
					}
					base.SetXUILable("Bg/MyRank/My/Reward", text2);
					bool flag5 = k < 3;
					if (flag5)
					{
						base.uiBehaviour.mMyRank.SetActive(false);
					}
					break;
				}
			}
			bool flag6 = !flag3;
			if (flag6)
			{
				base.SetXUILable("Bg/MyRank/My/Rank", "");
				base.SetXUILable("Bg/MyRank/My/Name", "");
				base.SetXUILable("Bg/MyRank/My/Reward", "");
			}
		}

		private void InitData()
		{
			for (int i = 0; i < XDragonCrusadeDocument._DragonCrusageGateDataInfo.Count; i++)
			{
				DragonCrusageGateData dragonCrusageGateData = XDragonCrusadeDocument._DragonCrusageGateDataInfo[i];
				Transform go = this.ixDragonExpedition.GetGO(dragonCrusageGateData.expData.ResName);
				bool flag = go == null;
				if (!flag)
				{
					GameObject value = null;
					bool flag2 = !this.listBillBoards.TryGetValue(dragonCrusageGateData.SceneID, out value);
					if (flag2)
					{
						value = this.RefreshGateEnter(dragonCrusageGateData, go.gameObject);
						this.listBillBoards.Add(dragonCrusageGateData.SceneID, value);
					}
					bool flag3 = XDragonCrusadeDocument.SectonChapterMax[dragonCrusageGateData.Chapter] == dragonCrusageGateData.expData.ChapterID[1];
					if (flag3)
					{
						GameObject gameObject = new GameObject("Snap");
						gameObject.transform.parent = go.gameObject.transform;
						bool flag4 = dragonCrusageGateData.expData.SnapPos != null && dragonCrusageGateData.expData.SnapPos.Length == 3;
						if (flag4)
						{
							gameObject.transform.localPosition = new Vector3(dragonCrusageGateData.expData.SnapPos[0], dragonCrusageGateData.expData.SnapPos[1], dragonCrusageGateData.expData.SnapPos[2]);
						}
						else
						{
							gameObject.transform.localPosition = new Vector3(0.1f, -0.26f, -0.49f);
						}
						gameObject.transform.localEulerAngles = new Vector3(0f, 20f, 0f);
						gameObject.transform.localScale = Vector3.one * 1.5f;
						IUIDummy snapShot = XSingleton<XUpdater.XUpdater>.singleton.XPlatform.AddComponent(gameObject, EComponentType.EUIDummy) as IUIDummy;
						this.CreateAvatar(snapShot, dragonCrusageGateData);
					}
				}
			}
		}

		private void UpdateBillBoard()
		{
			foreach (KeyValuePair<uint, GameObject> keyValuePair in this.listBillBoards)
			{
				GameObject value = keyValuePair.Value;
				Vector3 normalized = (value.transform.position - this.ixDragonExpedition.GetDragonCamera().transform.position).normalized;
				value.transform.rotation *= Quaternion.LookRotation(normalized);
			}
		}

		private GameObject RefreshGateEnter(DragonCrusageGateData data, GameObject obj)
		{
			uint sceneID = data.SceneID;
			GameObject gameObject = XSingleton<XResourceLoaderMgr>.singleton.CreateFromPrefab("UI/Billboard/DragonCrusadeBillboard", true, false) as GameObject;
			XSingleton<UiUtility>.singleton.AddChild(obj, gameObject);
			gameObject.name = data.SceneID + "_" + data.expData.ResName;
			gameObject.transform.localScale = this.localDefaultScale;
			gameObject.transform.position = obj.transform.position;
			IXUILabel ixuilabel = gameObject.transform.Find("Name").GetComponent("XUILabel") as IXUILabel;
			ixuilabel.SetText(data.sceneData.Comment);
			return gameObject;
		}

		public void RefreshProgressFromNet()
		{
			bool flag = !this.mDoneFinish;
			if (!flag)
			{
				this.RefreshProgress();
			}
		}

		public void RefreshProgressSync(Action<bool> done)
		{
			bool flag = this.ixDragonExpedition != null;
			if (flag)
			{
				bool flag2 = done != null;
				if (flag2)
				{
					done(true);
				}
				XSingleton<XTutorialHelper>.singleton.DragonCrusadeOpen = true;
			}
			else
			{
				bool flag3 = this.mSyncLoading;
				if (!flag3)
				{
					this.LoadPrefabSync(done);
				}
			}
		}

		private void LoadPrefabSync(Action<bool> done)
		{
			base.uiBehaviour.goLoading.SetActive(true);
			this.mSyncLoading = true;
			this.mDoneFinish = false;
			this.mSyncDoneCallBack = done;
			XSingleton<XResourceLoaderMgr>.singleton.CreateFromPrefabAsync("Common/DragonExpedition", this.mDragonExpeditionLoadTask, null, true);
		}

		public override void OnUpdate()
		{
			base.OnUpdate();
			bool flag = !this.mSyncLoading;
			if (!flag)
			{
				bool flag2 = this.mSyncLoading;
				if (flag2)
				{
				}
				bool flag3 = this.intertime > 0f;
				if (flag3)
				{
					this.intertime -= Time.deltaTime;
				}
				else
				{
					this.intertime = 0.5f;
					bool flag4 = this.mSyncLoading && this.mDoneFinish;
					if (flag4)
					{
						bool flag5 = this.mDragonExpeditionLoadTask != null;
						if (flag5)
						{
							this.mDragonExpeditionLoadTask = null;
						}
						base.uiBehaviour.goLoading.SetActive(false);
						this.mSyncLoading = false;
					}
				}
			}
		}

		private void LoadPrefabSyncDone()
		{
			this.ixDragonExpedition = (this.goDragonExpedition.GetComponent("XDragonExpedition") as IXDragonExpedition);
			this._FxFirework = XSingleton<XFxMgr>.singleton.CreateFx("Effects/FX_Particle/UIfx/UI_lzy_gk", null, true);
			this.InitData();
			this.RefreshProgress();
			this.mDoneFinish = true;
			bool flag = this.mSyncDoneCallBack != null;
			if (flag)
			{
				this.mSyncDoneCallBack(true);
			}
			this.mSyncDoneCallBack = null;
			bool flag2 = this.ixDragonExpedition != null;
			if (flag2)
			{
				this.ixDragonExpedition.GetDragonCamera().enabled = true;
			}
			XSingleton<XTutorialHelper>.singleton.DragonCrusadeOpen = true;
		}

		private void RefreshProgress()
		{
			GameObject gameObject = null;
			for (int i = 0; i < XDragonCrusadeDocument._DragonCrusageGateDataInfo.Count; i++)
			{
				DragonCrusageGateData dragonCrusageGateData = XDragonCrusadeDocument._DragonCrusageGateDataInfo[i];
				DEProgress deProgress = dragonCrusageGateData.deProgress;
				bool flag = this.listBillBoards.TryGetValue(deProgress.sceneID, out gameObject);
				if (flag)
				{
					Transform transform = gameObject.transform.Find("StageConquered");
					Transform transform2 = gameObject.transform.Find("BossHP");
					IXUIProgress ixuiprogress = transform2.GetComponent("XUIProgress") as IXUIProgress;
					ixuiprogress.value = (float)deProgress.bossavghppercent / 100f;
					IXUILabel ixuilabel = gameObject.transform.Find("BossHP/Percent").GetComponent("XUILabel") as IXUILabel;
					ixuilabel.SetText(deProgress.bossavghppercent + "%");
					switch (dragonCrusageGateData.deProgress.state)
					{
					case DEProgressState.DEPS_FINISH:
					{
						transform2.localScale = Vector3.zero;
						transform.gameObject.SetActive(true);
						this.ixDragonExpedition.SetLimitPos(dragonCrusageGateData.expData.LimitPos);
						Transform go = this.ixDragonExpedition.GetGO(dragonCrusageGateData.expData.ResName);
						Renderer component = go.GetComponent<Renderer>();
						Material sharedMaterial = component.sharedMaterial;
						component.material = new Material(sharedMaterial)
						{
							shader = ShaderManager._transparentGrayMaskRNoLight,
							renderQueue = 3002
						};
						break;
					}
					case DEProgressState.DEPS_FIGHT:
					{
						this.ixDragonExpedition.SetLimitPos(dragonCrusageGateData.expData.LimitPos);
						this._FxFirework.Play(gameObject.transform.position, Quaternion.identity, Vector3.one, 1f);
						transform2.localScale = Vector3.one;
						transform.gameObject.SetActive(false);
						bool flag2 = gameObject.transform.parent != null;
						if (flag2)
						{
							this.ixDragonExpedition.Assign(gameObject.transform.parent.localPosition.x);
						}
						break;
					}
					case DEProgressState.DEPS_NOTOPEN:
						transform.gameObject.SetActive(false);
						transform2.localScale = Vector3.zero;
						break;
					}
				}
				base.SetXUILable("Bg/ChallengeCount/Value", string.Format("{0}/{1}", dragonCrusageGateData.leftcount, dragonCrusageGateData.allcount));
			}
		}

		private void CreateAvatar(IUIDummy snapShot, DragonCrusageGateData data)
		{
			XEntityStatistics.RowData byID = XSingleton<XEntityMgr>.singleton.EntityStatistics.GetByID(data.expData.BossID);
			XEntityPresentation.RowData byPresentID = XSingleton<XEntityMgr>.singleton.EntityInfo.GetByPresentID(byID.PresentID);
			bool flag = !this.m_AvatarDummys.ContainsKey((int)data.expData.ChapterID[0]);
			if (flag)
			{
				XDummy xdummy = XSingleton<X3DAvatarMgr>.singleton.CreateCommonEntityDummy(this.m_dummPool, byID.PresentID, snapShot, null, 25f);
				xdummy.Scale = byPresentID.UIAvatarScale;
				xdummy.EngineObject.SetLocalPRS(Vector3.zero, true, Quaternion.identity, true, Vector3.one * 0.3f, true);
				this.m_AvatarDummys.Add((int)data.expData.ChapterID[0], xdummy);
			}
		}

		private void DeleteAvatar()
		{
			base.Return3DAvatarPool();
			this.m_AvatarDummys.Clear();
		}
	}
}