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

namespace XMainClient
{
	internal class BroadcastDlg : DlgBase<BroadcastDlg, BroadcastBehaviour>
	{
		public override string fileName
		{
			get
			{
				return "GameSystem/BroadcastDlg";
			}
		}

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

		public override bool isHideChat
		{
			get
			{
				return false;
			}
		}

		private static bool isCameraOpen = false;

		public readonly int max_count = 40;

		public List<BroadNode> barrages = new List<BroadNode>();

		public string lastCahceMsg = string.Empty;

		private Vector3 originPos = Vector3.zero;

		private float closeTime = 0f;

		private float closeDuration = 0.3f;

		private bool isClosing = false;

		private uint timer = 0u;

		protected override void Init()
		{
			base.Init();
			base.uiBehaviour.m_lblCamera.SetText(XStringDefineProxy.GetString("BROAD_CAMERA_OPEN"));
			GameObject tpl = base.uiBehaviour.loopScrool.GetTpl();
			bool flag = tpl != null && tpl.GetComponent<BroadBarrageItem>() == null;
			if (flag)
			{
				tpl.AddComponent<BroadBarrageItem>();
			}
		}

		public override void RegisterEvent()
		{
			base.RegisterEvent();
			base.uiBehaviour.m_btnBarrage.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnEndClick));
			base.uiBehaviour.m_btnCamera.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnCameraClick));
			base.uiBehaviour.m_btnClose.RegisterClickEventHandler(new ButtonClickEventHandler(this.ClosePanel));
			base.uiBehaviour.m_btnShare.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnShareClick));
		}

		protected override void OnShow()
		{
			base.OnShow();
			this.timer = XSingleton<XTimerMgr>.singleton.SetTimer(0.5f, new XTimerMgr.ElapsedEventHandler(this.TimerShow), null);
			this.originPos = DlgBase<BroadMiniDlg, BroadcastMiniBehaviour>.singleton.GetIconPos();
			this.isClosing = false;
			base.uiBehaviour.transform.localPosition = Vector3.zero;
			base.uiBehaviour.transform.localScale = Vector3.one;
		}

		protected override void OnUnload()
		{
			XSingleton<XTimerMgr>.singleton.KillTimer(this.timer);
			base.OnUnload();
		}

		public void Push(string _nickname, string _content)
		{
			BroadNode item = default(BroadNode);
			item.nickname = _nickname;
			item.content = _content;
			bool flag = this.barrages.Count > this.max_count;
			if (flag)
			{
				this.barrages.RemoveRange(0, this.barrages.Count - this.max_count);
			}
			this.barrages.Add(item);
		}

		private void TimerShow(object o)
		{
			this.ShowList();
			this.timer = XSingleton<XTimerMgr>.singleton.SetTimer(0.4f, new XTimerMgr.ElapsedEventHandler(this.TimerShow), null);
		}

		public void ShowList()
		{
			bool flag = base.IsVisible();
			if (flag)
			{
				List<LoopItemData> list = new List<LoopItemData>();
				string b = string.Empty;
				for (int i = 0; i < this.barrages.Count; i++)
				{
					BarrageMsg barrageMsg = new BarrageMsg();
					barrageMsg.LoopID = XSingleton<XCommon>.singleton.XHash(this.barrages[i].content + i);
					barrageMsg.nickname = this.barrages[i].nickname;
					barrageMsg.content = this.barrages[i].content;
					list.Add(barrageMsg);
					b = XSingleton<XCommon>.singleton.StringCombine(barrageMsg.nickname, barrageMsg.content);
				}
				bool flag2 = string.IsNullOrEmpty(this.lastCahceMsg) || this.lastCahceMsg != b;
				if (flag2)
				{
					base.uiBehaviour.loopScrool.Init(list, new DelegateHandler(this.RefreshItem), null, 1, false);
				}
				bool flag3 = this.barrages != null && this.barrages.Count > 0;
				if (flag3)
				{
					int index = this.barrages.Count - 1;
					this.lastCahceMsg = XSingleton<XCommon>.singleton.StringCombine(this.barrages[index].nickname, this.barrages[index].content);
				}
			}
		}

		public override void OnUpdate()
		{
			base.OnUpdate();
			bool flag = this.isClosing;
			if (flag)
			{
				base.uiBehaviour.gameObject.transform.localPosition = Vector3.Lerp(Vector3.zero, this.originPos, (Time.time - this.closeTime) / this.closeDuration);
				base.uiBehaviour.gameObject.transform.localScale = Vector3.Lerp(Vector3.one, 0.1f * Vector3.one, (Time.time - this.closeTime) / this.closeDuration);
				bool flag2 = Time.time - this.closeTime >= this.closeDuration;
				if (flag2)
				{
					this.isClosing = false;
					this.SetVisible(false, true);
					DlgBase<BroadMiniDlg, BroadcastMiniBehaviour>.singleton.Show(true);
				}
			}
		}

		private void RefreshItem(ILoopItemObject item, LoopItemData data)
		{
			BarrageMsg barrageMsg = data as BarrageMsg;
			bool flag = barrageMsg != null;
			if (flag)
			{
				GameObject obj = item.GetObj();
				bool flag2 = obj != null;
				if (flag2)
				{
					BroadBarrageItem component = obj.GetComponent<BroadBarrageItem>();
					bool flag3 = component != null;
					if (flag3)
					{
						component.Refresh(barrageMsg.nickname, barrageMsg.content);
					}
				}
			}
			else
			{
				XSingleton<XDebug>.singleton.AddErrorLog("BroadBarrageItem info is null", null, null, null, null, null);
			}
		}

		private bool OnEndClick(IXUIButton btn)
		{
			XSingleton<XUpdater.XUpdater>.singleton.XBroadCast.StopBroadcast();
			this.ClosePanel(btn);
			return true;
		}

		private bool OnCameraClick(IXUIButton btn)
		{
			bool flag = BroadcastDlg.isCameraOpen;
			if (flag)
			{
				XSingleton<XUpdater.XUpdater>.singleton.XBroadCast.ShowCamera(false);
				BroadcastDlg.isCameraOpen = false;
				base.uiBehaviour.m_lblCamera.SetText(XStringDefineProxy.GetString("BROAD_CAMERA_OPEN"));
			}
			else
			{
				bool flag2 = XSingleton<XUpdater.XUpdater>.singleton.XBroadCast.ShowCamera(true);
				if (flag2)
				{
					BroadcastDlg.isCameraOpen = true;
					base.uiBehaviour.m_lblCamera.SetText(XStringDefineProxy.GetString("BROAD_CAMERA_CLOSE"));
				}
			}
			return true;
		}

		private bool OnShareClick(IXUIButton btn)
		{
			XSingleton<XDebug>.singleton.AddGreenLog("sharebtn click", null, null, null, null, null);
			this.ClosePanel(btn);
			return true;
		}

		private bool ClosePanel(IXUIButton btn)
		{
			bool flag = !this.isClosing;
			if (flag)
			{
				this.closeTime = Time.time;
				this.isClosing = true;
			}
			return true;
		}
	}
}