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

namespace XMainClient
{
	internal class XLoginDocument : XSingleton<XLoginDocument>
	{
		public XLoginView View
		{
			get
			{
				return this._view;
			}
			set
			{
				this._view = value;
			}
		}

		public PlatNotice Announcement
		{
			get
			{
				return this._announcement;
			}
		}

		public bool SDKSignOut
		{
			get
			{
				return this._sdk_sign_out;
			}
			set
			{
				this._sdk_sign_out = value;
			}
		}

		private string _openid
		{
			get
			{
				return this.__openid;
			}
			set
			{
				this.__openid = value;
				XFileLog.OpenID = value;
				XSingleton<XUpdater.XUpdater>.singleton.XPlatform.SetApmUserID(value);
			}
		}

		public uint LoginZoneID
		{
			get
			{
				return this._login_zoneid;
			}
		}

		public bool freeflow
		{
			get
			{
				return this._freeflow;
			}
		}

		public int cctype
		{
			get
			{
				return this._cctype;
			}
		}

		private float FetchingElapsed
		{
			get
			{
				return Time.realtimeSinceStartup - this._last_fetch_at;
			}
		}

		private float LoginingElapsed
		{
			get
			{
				return Time.realtimeSinceStartup - this._last_login_at;
			}
		}

		public string Account
		{
			get
			{
				return this._account;
			}
		}

		public string Password
		{
			get
			{
				return this._pwd;
			}
		}

		public string OpenID
		{
			get
			{
				return this._openid;
			}
		}

		public XAuthorizationChannel Channel
		{
			get
			{
				return this._channel;
			}
		}

		public string TokenCache
		{
			get
			{
				return this._token_cache;
			}
		}

		public bool FetchTokenDelay
		{
			get
			{
				return this._fetch_delay;
			}
		}

		public bool LoginDelay
		{
			get
			{
				return this._login_delay;
			}
		}

		public bool Authorized
		{
			get
			{
				return this._authorized;
			}
		}

		public List<string> ZoneList
		{
			get
			{
				return this._zone_list;
			}
		}

		public Dictionary<string, List<int>> ServerCategory
		{
			get
			{
				return this._server_category;
			}
		}

		public uint RoleCountInQueue
		{
			get
			{
				return this._role_count_inqueue;
			}
		}

		public uint LeftTimeInQueue
		{
			get
			{
				return this._left_time_inqueue;
			}
		}

		public List<ServerInfo> BackFlowServerList
		{
			get
			{
				return this._backFlowServerList;
			}
		}

		private static readonly byte _seed = 148;

		private static readonly float _delay_notice_threshold = 0.5f;

		private static readonly float _max_delay_notice_threshold = 10f;

		private static readonly float _max_notice_threshold = 5f;

		private XAuthorizationChannel _channel = XAuthorizationChannel.XAuthorization_Max;

		private XLoginView _view = null;

		private PlatNotice _announcement = null;

		private bool _sdk_sign_out = false;

		private bool _after_login_announcement = false;

		private bool _notification = false;

		private bool _authorized = false;

		private bool _auto_authorization = false;

		private string _account = null;

		private string _pwd = null;

		private string __openid = null;

		private uint _login_zoneid = 0u;

		private bool _freeflow;

		private int _cctype;

		private string _token_cache = null;

		private bool _fetch_delay = false;

		private bool _fetching_token = false;

		private float _last_fetch_at = 0f;

		private bool _authorized_from_login_stage = false;

		private bool _login_delay = false;

		private bool _logining = false;

		private float _last_login_at = 0f;

		private bool _in_server_queue = false;

		private float enterWorldTime = 0f;

		private List<string> _zone_list = new List<string>();

		private Dictionary<string, List<int>> _server_category = new Dictionary<string, List<int>>();

		private Dictionary<int, ServerInfo> _server_dic = new Dictionary<int, ServerInfo>();

		private List<ServerInfo> _backFlowServerList = new List<ServerInfo>();

		public Dictionary<string, FriendServerInfo> FriendServerDic = new Dictionary<string, FriendServerInfo>();

		public List<string> FriendOpenid = new List<string>();

		private uint _role_count_inqueue = 0u;

		private uint _left_time_inqueue = 0u;

		private LoginReconnectInfo _login_reconnect_info = null;

		private uint _query_queue_token = 0u;

		private float[] lastLoginTime = new float[2];

		private StartUpType _LaunchTypeServer = StartUpType.StartUp_Normal;

		private void ResetAccoutInfo()
		{
			this._sdk_sign_out = false;
			this._account = null;
			this._pwd = null;
			this._openid = null;
			this._token_cache = null;
		}

		public void SetChannelByWakeUp()
		{
			switch (this.GetWakeUpType())
			{
			case StartUpType.StartUp_QQ:
				this._channel = XAuthorizationChannel.XAuthorization_QQ;
				break;
			case StartUpType.StartUp_WX:
				this._channel = XAuthorizationChannel.XAuthorization_WeChat;
				break;
			}
		}

		private void SetChannelByLaunchType()
		{
			switch (this.GetLaunchType())
			{
			case StartUpType.StartUp_QQ:
				this._channel = XAuthorizationChannel.XAuthorization_QQ;
				break;
			case StartUpType.StartUp_WX:
				this._channel = XAuthorizationChannel.XAuthorization_WeChat;
				break;
			}
		}

		public void LoadAccount()
		{
			string path = Application.persistentDataPath + "/account.txt";
			bool flag = (int)Application.platform == 7 || (int)Application.platform == 0 || (int)Application.platform == 2;
			if (flag)
			{
				path = Application.dataPath + "/account.txt";
			}
			bool flag2 = !File.Exists(path);
			if (flag2)
			{
				this.SetChannelByLaunchType();
			}
			else
			{
				string text = this.XCryptography(File.ReadAllBytes(path));
				string[] array = text.Split(null);
				int num = 0;
				bool flag3 = int.TryParse(array[0], out num) && num > 0 && num < XFastEnumIntEqualityComparer<XAuthorizationChannel>.ToInt(XAuthorizationChannel.XAuthorization_Max);
				if (flag3)
				{
					this._channel = (XAuthorizationChannel)num;
					this.SetChannelByLaunchType();
					switch (this._channel)
					{
					case XAuthorizationChannel.XAuthorization_Internal:
					{
						bool flag4 = array.Length == 3;
						if (flag4)
						{
							this._account = array[1];
							this._pwd = array[2];
						}
						break;
					}
					}
				}
				else
				{
					this.SetChannelByLaunchType();
				}
			}
		}

		public void DelAccount()
		{
			string path = Application.persistentDataPath + "/account.txt";
			bool flag =(int) Application.platform == 7 || (int)Application.platform == 0 || (int)Application.platform == 2;
			if (flag)
			{
				path = Application.dataPath + "/account.txt";
			}
			try
			{
				bool flag2 = !File.Exists(path);
				if (!flag2)
				{
					File.Delete(path);
				}
			}
			catch (Exception ex)
			{
				XSingleton<XDebug>.singleton.AddErrorLog("Delete account file failed " + ex.Message, null, null, null, null, null);
			}
		}

		public void AutoAuthorization(bool fromLoginStage)
		{
			this.Authorization(this._channel, fromLoginStage, true, this._account, this._pwd);
		}

		public bool CheckLoginBlockTime()
		{
			return Time.time - this.lastLoginTime[1] > XSingleton<XGlobalConfig>.singleton.LoginBlockTime;
		}

		public void Authorization(XAuthorizationChannel channel, bool fromLoginStage, bool auto = false, string account = null, string pwd = null)
		{
			this.lastLoginTime[1] = this.lastLoginTime[0];
			this.lastLoginTime[0] = Time.time;
			this.SetBlockUIVisable(true);
			this._authorized = false;
			this._auto_authorization = auto;
			this._authorized_from_login_stage = fromLoginStage;
			this._fetching_token = true;
			this._last_fetch_at = Time.realtimeSinceStartup;
			switch (channel)
			{
			case XAuthorizationChannel.XAuthorization_Internal:
				this._channel = channel;
				this.InternalAuthorization(account, pwd);
				break;
			case XAuthorizationChannel.XAuthorization_SD:
				this._channel = channel;
				this.PlatformAuthorization();
				break;
			case XAuthorizationChannel.XAuthorization_QQ:
				this._channel = channel;
				this.QQAuthorization(auto);
				break;
			case XAuthorizationChannel.XAuthorization_WeChat:
				this._channel = channel;
				this.WeChatAuthorization(auto);
				break;
			case XAuthorizationChannel.XAuthorization_Guest:
				this._channel = channel;
				this.GuestAuthorization(auto);
				break;
			default:
				this._fetching_token = false;
				break;
			}
		}

		public void ShowAfterLoginAnnouncement()
		{
			bool flag = !this._after_login_announcement;
			if (flag)
			{
				XSingleton<UiUtility>.singleton.ShowAfterLoginAnnouncement(this._announcement);
				this._after_login_announcement = true;
			}
		}

		public void OnError(string notify)
		{
			XSingleton<XPandoraSDKDocument>.singleton.PandoraLogout();
			this._fetching_token = false;
			this._authorized = false;
			this._logining = false;
			this._in_server_queue = false;
			bool flag = this._channel != XAuthorizationChannel.XAuthorization_Internal && this._channel != XAuthorizationChannel.XAuthorization_Max;
			if (flag)
			{
				this.ResetAccoutInfo();
			}
			bool flag2 = !string.IsNullOrEmpty(notify);
			if (flag2)
			{
				XSingleton<UiUtility>.singleton.ShowLoginTip(string.Format("{0} {1}", this.PlatformComment(this._channel), notify));
			}
			this.FromBegining();
		}

		public void OnError()
		{
			this._fetching_token = false;
			this._authorized = false;
			this._logining = false;
			this._in_server_queue = false;
		}

		public void FromBegining()
		{
			XSingleton<XClientNetwork>.singleton.ClearServerInfo();
			this.SetBlockUIVisable(false);
			bool authorized_from_login_stage = this._authorized_from_login_stage;
			if (authorized_from_login_stage)
			{
				XSingleton<XLoginDocument>.singleton.ShowLoginUI();
			}
			else
			{
				this.BackToBegin();
			}
			this._after_login_announcement = false;
			this._authorized_from_login_stage = false;
		}

		public void FromLogining()
		{
			this.SetBlockUIVisable(false);
			bool authorized_from_login_stage = this._authorized_from_login_stage;
			if (authorized_from_login_stage)
			{
				XSingleton<XLoginDocument>.singleton.ShowLoginSelectServerUI();
			}
			else
			{
				this.BackToLogin();
			}
			this._authorized_from_login_stage = false;
		}

		public void RefreshAccessToken(string token)
		{
			this._token_cache = token;
			XSingleton<XDebug>.singleton.AddLog("AccessToken : ", this._token_cache, null, null, null, null, XDebugColor.XDebug_None);
		}

		public void OnAuthorization(string account, string pwd, string openid, XAuthorizationChannel channel)
		{
			this._fetching_token = false;
			this._account = account;
			this._pwd = pwd;
			this._openid = openid;
			this._channel = channel;
			this._token_cache = account;
			bool flag = string.IsNullOrEmpty(account) || string.IsNullOrEmpty(openid);
			if (flag)
			{
				this.OnAuthorizedFailed();
			}
			else
			{
				switch (channel)
				{
				case XAuthorizationChannel.XAuthorization_Internal:
					XSingleton<XClientNetwork>.singleton.Authorization(LoginType.LOGIN_PASSWORD, account, pwd, openid);
					break;
				case XAuthorizationChannel.XAuthorization_SD:
					XSingleton<XClientNetwork>.singleton.Authorization(LoginType.LOGIN_SNDA_PF, account, pwd, openid);
					break;
				case XAuthorizationChannel.XAuthorization_QQ:
					XSingleton<XClientNetwork>.singleton.Authorization(LoginType.LOGIN_QQ_PF, account, pwd, openid);
					break;
				case XAuthorizationChannel.XAuthorization_WeChat:
					XSingleton<XClientNetwork>.singleton.Authorization(LoginType.LGOIN_WECHAT_PF, account, pwd, openid);
					break;
				case XAuthorizationChannel.XAuthorization_Guest:
					XSingleton<XClientNetwork>.singleton.Authorization(LoginType.LOGIN_IOS_GUEST, account, pwd, openid);
					break;
				}
			}
		}

		public void OnAuthorizationSignOut(string msg)
		{
			bool flag = this._channel == XAuthorizationChannel.XAuthorization_Max;
			if (!flag)
			{
				this._sdk_sign_out = true;
				bool flag2 = !XStage.IsConcreteStage(XSingleton<XGame>.singleton.CurrentStage.Stage);
				if (flag2)
				{
					bool flag3 = string.IsNullOrEmpty(msg);
					if (flag3)
					{
						this._authorized = false;
					}
					else
					{
						XSingleton<UiUtility>.singleton.ShowLoginTip(string.Format("{0} {1}", this.PlatformComment(this._channel), msg));
					}
					this.FromBegining();
				}
				else
				{
					XSingleton<XDebug>.singleton.AddLog("OnAuthorizationSignOut " + msg, null, null, null, null, null, XDebugColor.XDebug_None);
					XSingleton<XClientNetwork>.singleton.Close(NetErrCode.Net_NoError);
					bool sceneReady = XSingleton<XScene>.singleton.SceneReady;
					if (sceneReady)
					{
						XSingleton<UiUtility>.singleton.OnFatalErrorClosed(ErrorCode.ERR_AUTH_TOKEN_INVALID);
					}
					else
					{
						XSingleton<XScene>.singleton.Error = ErrorCode.ERR_AUTH_TOKEN_INVALID;
					}
				}
				this._channel = XAuthorizationChannel.XAuthorization_Max;
			}
		}

		public void AuthorizationSignOut()
		{
			bool flag = this._channel == XAuthorizationChannel.XAuthorization_Max;
			if (!flag)
			{
				this._authorized = false;
				bool flag2 = this._channel != XAuthorizationChannel.XAuthorization_Internal && this._channel != XAuthorizationChannel.XAuthorization_Max;
				if (flag2)
				{
					this.ResetAccoutInfo();
					XSingleton<XUpdater.XUpdater>.singleton.XPlatform.LogOut();
				}
				this.DelAccount();
				XSingleton<XPandoraSDKDocument>.singleton.PandoraLogout();
				this._channel = XAuthorizationChannel.XAuthorization_Max;
				this.FromBegining();
			}
		}

		public void OnAuthorized(string identification)
		{
			bool flag = this._channel == XAuthorizationChannel.XAuthorization_SD;
			if (flag)
			{
				this._account = string.Format("{0} ({1})", identification, XStringDefineProxy.GetString("SDO_TOKEN"));
			}
			bool flag2 = this._channel == XAuthorizationChannel.XAuthorization_QQ;
			if (flag2)
			{
				this._account = identification + " (QQ)";
			}
			bool flag3 = this._channel == XAuthorizationChannel.XAuthorization_WeChat;
			if (flag3)
			{
				this._account = string.Format("{0} ({1})", identification, XStringDefineProxy.GetString("WECHAT_TOKEN"));
			}
			bool flag4 = this._channel == XAuthorizationChannel.XAuthorization_Guest;
			if (flag4)
			{
				this._account = string.Format("{0} ({1})", identification, XStringDefineProxy.GetString("GUEST_TOKEN"));
			}
			bool flag5 = !this._auto_authorization || this._authorized_from_login_stage;
			if (flag5)
			{
				XSingleton<UiUtility>.singleton.ShowLoginTip(string.Format("{0} {1}", this.PlatformComment(this._channel), XStringDefineProxy.GetString("AUTHORIZED_SUCCESS")));
			}
			this.SaveAccount();
			this._authorized = true;
			this.ShowLoginSelectServerUI();
			this.SetBlockUIVisable(false);
			XSingleton<XClientNetwork>.singleton.XLoginStep = XLoginStep.Login;
		}

		public void OnAuthorizedFailed()
		{
			XSingleton<UiUtility>.singleton.ShowLoginTip(string.Format("{0} {1}", this.PlatformComment(this._channel), XStringDefineProxy.GetString("AUTHORIZED_FAIL")));
			string sdkconfig = XSingleton<XUpdater.XUpdater>.singleton.XPlatform.GetSDKConfig("get_login_eflag", "");
			bool flag = this._channel != XAuthorizationChannel.XAuthorization_Internal && this._channel != XAuthorizationChannel.XAuthorization_Max;
			if (flag)
			{
				this.ResetAccoutInfo();
			}
			XSingleton<PDatabase>.singleton.playerInfo = null;
			XSingleton<PDatabase>.singleton.friendsInfo = null;
			this._authorized = false;
			this.OnError();
			this.FromBegining();
		}

		public void OnAuthorizedConnectFailed()
		{
			bool flag = this._channel != XAuthorizationChannel.XAuthorization_Internal && this._channel != XAuthorizationChannel.XAuthorization_Max;
			if (flag)
			{
				this.ResetAccoutInfo();
			}
			XSingleton<PDatabase>.singleton.playerInfo = null;
			XSingleton<PDatabase>.singleton.friendsInfo = null;
			XSingleton<UiUtility>.singleton.ShowLoginTip(string.Format("{0} {1}", this.PlatformComment(this._channel), XStringDefineProxy.GetString("AUTHORIZED_CONNECT_FAIL")));
			this._authorized = false;
			this.OnError();
			this.FromBegining();
		}

		public void OnAuthorizedTimeOut()
		{
			bool flag = this._channel != XAuthorizationChannel.XAuthorization_Internal && this._channel != XAuthorizationChannel.XAuthorization_Max;
			if (flag)
			{
				this.ResetAccoutInfo();
			}
			XSingleton<PDatabase>.singleton.playerInfo = null;
			XSingleton<PDatabase>.singleton.friendsInfo = null;
			XSingleton<UiUtility>.singleton.ShowLoginTip(this.PlatformComment(this._channel) + " 授权验证超时");
			this._authorized = false;
			this.FromBegining();
		}

		public void Login()
		{
			this.SetBlockUIVisable(true);
			this._logining = true;
			this._last_login_at = Time.realtimeSinceStartup;
			this._in_server_queue = false;
			XSingleton<XClientNetwork>.singleton.Login();
		}

		public void OnLogin()
		{
			bool authorized_from_login_stage = this._authorized_from_login_stage;
			if (authorized_from_login_stage)
			{
				this._view.TweenAlpha(true);
			}
			XSingleton<XClientNetwork>.singleton.OnLogin();
			this._logining = false;
			this._authorized_from_login_stage = false;
			this._in_server_queue = false;
			this.SetBlockUIVisable(false);
		}

		public StartUpType GetWakeUpType()
		{
			StartUpType startUpType = StartUpType.StartUp_Normal;
			string sdkconfig = XSingleton<XUpdater.XUpdater>.singleton.XPlatform.GetSDKConfig("get_wakeup_info", "");
			XSingleton<XDebug>.singleton.AddLog("[GetLaunchType] wakeupInfo:" + sdkconfig, null, null, null, null, null, XDebugColor.XDebug_None);
			bool flag = sdkconfig == "";
			StartUpType result;
			if (flag)
			{
				result = startUpType;
			}
			else
			{
				Dictionary<string, object> dictionary = Json.Deserialize(sdkconfig) as Dictionary<string, object>;
				object obj = null;
				bool flag2 = dictionary != null && dictionary.TryGetValue("wakeup_platform", out obj);
				if (flag2)
				{
					XSingleton<XDebug>.singleton.AddLog("[GetLaunchType] platform: " + obj.ToString(), null, null, null, null, null, XDebugColor.XDebug_None);
					bool flag3 = (long)obj == 1L;
					if (flag3)
					{
						startUpType = StartUpType.StartUp_WX;
					}
					else
					{
						bool flag4 = (long)obj == 2L;
						if (flag4)
						{
							startUpType = StartUpType.StartUp_QQ;
						}
					}
				}
				result = startUpType;
			}
			return result;
		}

		public StartUpType GetLaunchType()
		{
			StartUpType startUpType = StartUpType.StartUp_Normal;
			string sdkconfig = XSingleton<XUpdater.XUpdater>.singleton.XPlatform.GetSDKConfig("get_wakeup_info", "");
			XSingleton<XDebug>.singleton.AddLog("[GetLaunchType] wakeupInfo:" + sdkconfig, null, null, null, null, null, XDebugColor.XDebug_None);
			bool flag = sdkconfig == "";
			StartUpType result;
			if (flag)
			{
				result = startUpType;
			}
			else
			{
				Dictionary<string, object> dictionary = Json.Deserialize(sdkconfig) as Dictionary<string, object>;
				object obj = null;
				bool flag2 = dictionary != null && dictionary.TryGetValue("wakeup_platform", out obj);
				if (flag2)
				{
					XSingleton<XDebug>.singleton.AddLog("[GetLaunchType] platform: " + obj.ToString(), null, null, null, null, null, XDebugColor.XDebug_None);
					bool flag3 = (long)obj == 1L;
					if (flag3)
					{
						XSingleton<XDebug>.singleton.AddLog("[GetLaunchType] platform == 1", null, null, null, null, null, XDebugColor.XDebug_None);
						object obj2 = null;
						bool flag4 = dictionary.TryGetValue("wakeup_wx_extInfo", out obj2);
						if (flag4)
						{
							bool flag5 = obj2.ToString() == "WX_GameCenter";
							if (flag5)
							{
								startUpType = StartUpType.StartUp_WX;
								XSingleton<XDebug>.singleton.AddLog("[GetLaunchType] StartUpType.StartUp_WX", null, null, null, null, null, XDebugColor.XDebug_None);
							}
						}
					}
					else
					{
						bool flag6 = (long)obj == 2L;
						if (flag6)
						{
							XSingleton<XDebug>.singleton.AddLog("[GetLaunchType] platform == 2", null, null, null, null, null, XDebugColor.XDebug_None);
							object obj3 = null;
							bool flag7 = dictionary.TryGetValue("wakeup_qq_extInfo", out obj3);
							if (flag7)
							{
								bool flag8 = obj3.ToString() == "sq_gamecenter";
								if (flag8)
								{
									startUpType = StartUpType.StartUp_QQ;
									XSingleton<XDebug>.singleton.AddLog("[GetLaunchType] StartUpType.StartUp_QQ", null, null, null, null, null, XDebugColor.XDebug_None);
								}
							}
						}
					}
				}
				result = startUpType;
			}
			return result;
		}

		public void SetLaunchTypeServerInfo(StartUpType type)
		{
			this._LaunchTypeServer = type;
		}

		public StartUpType GetLaunchTypeServerInfo()
		{
			return this._LaunchTypeServer;
		}

		public void EnterToSelectChar()
		{
			XSingleton<XLoginDocument>.singleton.OnLogin();
			EXStage stage = XSingleton<XGame>.singleton.CurrentStage.Stage;
			if (stage != EXStage.Login)
			{
				if (stage == EXStage.SelectChar)
				{
					XSelectcharStage xselectcharStage = XSingleton<XGame>.singleton.CurrentStage as XSelectcharStage;
					xselectcharStage.ReLogined();
				}
			}
			else
			{
				XSingleton<XGame>.singleton.CurrentStage.Play();
			}
		}

		public void CheckQueueState(object o)
		{
			XSingleton<XTimerMgr>.singleton.KillTimer(this._query_queue_token);
			this._query_queue_token = 0u;
			bool flag = !DlgBase<XLoginView, LoginWindowBehaviour>.singleton.IsVisible();
			if (!flag)
			{
				bool flag2 = !this._in_server_queue;
				if (!flag2)
				{
					PtcC2M_CheckQueuingReq ptcC2M_CheckQueuingReq = new PtcC2M_CheckQueuingReq();
					ptcC2M_CheckQueuingReq.Data.iscancel = false;
					XSingleton<XClientNetwork>.singleton.Send(ptcC2M_CheckQueuingReq);
					this._query_queue_token = XSingleton<XTimerMgr>.singleton.SetTimer(5f, new XTimerMgr.ElapsedEventHandler(this.CheckQueueState), null);
				}
			}
		}

		public void CancelQueue()
		{
			PtcC2M_CheckQueuingReq ptcC2M_CheckQueuingReq = new PtcC2M_CheckQueuingReq();
			ptcC2M_CheckQueuingReq.Data.iscancel = true;
			XSingleton<XClientNetwork>.singleton.Send(ptcC2M_CheckQueuingReq);
			this.OnCancelServerQueue();
		}

		public void ShowServerQueue()
		{
			bool flag = !DlgBase<XLoginView, LoginWindowBehaviour>.singleton.IsVisible();
			if (!flag)
			{
				this._in_server_queue = true;
				DlgBase<XLoginView, LoginWindowBehaviour>.singleton.ShowQueue();
				this.CheckQueueState(null);
				this.SetBlockUIVisable(false);
			}
		}

		public void WaitForServerQueue(uint roleCount, uint leftTime)
		{
			this._role_count_inqueue = roleCount;
			this._left_time_inqueue = leftTime;
			bool flag = !DlgBase<XLoginView, LoginWindowBehaviour>.singleton.IsVisible();
			if (!flag)
			{
				DlgBase<XLoginView, LoginWindowBehaviour>.singleton.RefreshQueueState();
			}
		}

		public void OnLoginFailed(string error)
		{
			XSingleton<UiUtility>.singleton.ShowLoginTip(string.Format("{0} {1}", this.PlatformComment(this._channel), string.IsNullOrEmpty(error) ? XStringDefineProxy.GetString("LOGIN_FAIL") : error));
			this._logining = false;
			this._in_server_queue = false;
			this.FromLogining();
		}

		public void OnLoginTimeout()
		{
			XSingleton<UiUtility>.singleton.ShowLoginTip(string.Format("{0} {1}", this.PlatformComment(this._channel), XStringDefineProxy.GetString("LOGIN_TIMEOUT")));
			this._logining = false;
			this._in_server_queue = false;
			this.FromLogining();
		}

		public void OnLoginConnectFailed()
		{
			XSingleton<UiUtility>.singleton.ShowLoginTip(string.Format("{0} {1}", this.PlatformComment(this._channel), XStringDefineProxy.GetString("LOGIN_CONNECT_FAIL")));
			this._logining = false;
			this._in_server_queue = false;
			this.FromLogining();
		}

		public void OnCancelServerQueue()
		{
			XSingleton<UiUtility>.singleton.ShowLoginTip(XStringDefineProxy.GetString("CANCEL_QUEUE"));
			this._logining = false;
			this._in_server_queue = false;
			XSingleton<XClientNetwork>.singleton.Close(NetErrCode.Net_NoError);
			this._authorized_from_login_stage = true;
			this.FromLogining();
		}

		public void EnterWorld(int index)
		{
			bool flag = Time.time - this.enterWorldTime < 2f;
			if (!flag)
			{
				this.enterWorldTime = Time.time;
				bool flag2 = index > 0;
				if (flag2)
				{
					RpcC2M_SelectRoleNew rpcC2M_SelectRoleNew = new RpcC2M_SelectRoleNew();
					rpcC2M_SelectRoleNew.oArg.index = index - 1;
					XSingleton<XClientNetwork>.singleton.Send(rpcC2M_SelectRoleNew);
				}
				XSingleton<XClientNetwork>.singleton.XLoginToken = null;
			}
		}

		public void CreateChar(string name, RoleType type)
		{
			bool flag = Time.time - this.enterWorldTime < 2f;
			if (!flag)
			{
				this.enterWorldTime = Time.time;
				RpcC2M_CreateRoleNew rpcC2M_CreateRoleNew = new RpcC2M_CreateRoleNew();
				rpcC2M_CreateRoleNew.oArg.name = name;
				rpcC2M_CreateRoleNew.oArg.type = type;
				XSingleton<XClientNetwork>.singleton.Send(rpcC2M_CreateRoleNew);
				this.SetBlockUIVisable(true);
			}
		}

		public void OnEnterWorldFailed(string error)
		{
			this.BackToLogin();
			XSingleton<UiUtility>.singleton.ShowLoginTip(string.Format("{0} {1}", this.PlatformComment(this._channel), string.IsNullOrEmpty(error) ? XStringDefineProxy.GetString("ENTER_WORLD_FAIL") : error));
		}

		public void OnEnterWorldTimeOut()
		{
			this.BackToLogin();
			XSingleton<UiUtility>.singleton.ShowLoginTip(string.Format("{0} {1}", this.PlatformComment(this._channel), XStringDefineProxy.GetString("ENTER_WORLD_TIMEOUT")));
		}

		public void EnableSDONotify()
		{
			bool flag = !this._notification;
			if (flag)
			{
				XSingleton<XUpdater.XUpdater>.singleton.XPlatform.ResgiterSDONotification(XSingleton<XClientNetwork>.singleton.ServerID, XSingleton<XEntityMgr>.singleton.Player.Name);
			}
			this._notification = true;
		}

		private void BackToBegin()
		{
			bool flag = XSingleton<XClientNetwork>.singleton.XLoginStep == XLoginStep.Begin;
			if (!flag)
			{
				XSingleton<XAttributeMgr>.singleton.XPlayerCharacters.PlayerBriefInfo.Clear();
				XSingleton<XAttributeMgr>.singleton.XPlayerCharacters.SelectedSlot = 0;
				XSingleton<XClientNetwork>.singleton.XLoginStep = XLoginStep.Begin;
				XSingleton<XGame>.singleton.SwitchTo(EXStage.Login, 3u);
			}
		}

		private void BackToLogin()
		{
			bool flag = XSingleton<XClientNetwork>.singleton.XLoginStep == XLoginStep.Login;
			if (!flag)
			{
				XSingleton<XAttributeMgr>.singleton.XPlayerCharacters.PlayerBriefInfo.Clear();
				XSingleton<XAttributeMgr>.singleton.XPlayerCharacters.SelectedSlot = 0;
				XSingleton<XClientNetwork>.singleton.XLoginStep = XLoginStep.Login;
				XSingleton<XGame>.singleton.SwitchTo(EXStage.Login, 3u);
			}
		}

		private void SaveAccount()
		{
			int num = XFastEnumIntEqualityComparer<XAuthorizationChannel>.ToInt(this._channel);
			string text = Application.persistentDataPath + "/account.txt";
			bool flag = (int)Application.platform == 7 || (int)Application.platform == 0 || (int)Application.platform == 2;
			if (flag)
			{
				text = Application.dataPath + "/account.txt";
			}
			try
			{
				File.WriteAllBytes(text, this.XCryptography(string.Format("{0}\n{1}\n{2}", num, this._account, this._pwd)));
				XSingleton<XUpdater.XUpdater>.singleton.XPlatform.SetNoBackupFlag(text);
			}
			catch (Exception ex)
			{
				XSingleton<XDebug>.singleton.AddErrorLog("Save account file error ", ex.Message, null, null, null, null);
			}
		}

		private void PlatformAuthorization()
		{
			XSingleton<XUpdater.XUpdater>.singleton.XPlatform.OnPlatformLogin();
		}

		private void QQAuthorization(bool auto)
		{
			XSingleton<XUpdater.XUpdater>.singleton.XPlatform.OnQQLogin();
		}

		private void WeChatAuthorization(bool auto)
		{
			XSingleton<XUpdater.XUpdater>.singleton.XPlatform.OnWeChatLogin();
		}

		private void GuestAuthorization(bool auto)
		{
			XSingleton<XUpdater.XUpdater>.singleton.XPlatform.OnGuestLogin();
		}

		private void InternalAuthorization(string account, string pwd)
		{
			this.OnAuthorization(account, pwd, account, XAuthorizationChannel.XAuthorization_Internal);
		}

		public void Update()
		{
			this._fetch_delay = false;
			this._login_delay = false;
			bool fetching_token = this._fetching_token;
			if (fetching_token)
			{
				bool flag = this.FetchingElapsed > XLoginDocument._delay_notice_threshold;
				if (flag)
				{
					this._fetch_delay = true;
				}
				bool flag2 = this.FetchingElapsed > XLoginDocument._max_delay_notice_threshold;
				if (flag2)
				{
					this._fetching_token = false;
					this._fetch_delay = false;
					this.SetBlockUIVisable(false);
				}
			}
			bool flag3 = this._logining && !this._in_server_queue;
			if (flag3)
			{
				bool flag4 = this.LoginingElapsed > XLoginDocument._delay_notice_threshold;
				if (flag4)
				{
					bool flag5 = this.LoginingElapsed > XLoginDocument._max_notice_threshold;
					if (flag5)
					{
						XSingleton<XClientNetwork>.singleton.Close(NetErrCode.Net_NoError);
						this.OnLoginTimeout();
					}
					else
					{
						this._login_delay = true;
					}
				}
			}
		}

		private string PlatformComment(XAuthorizationChannel channel)
		{
			string result;
			switch (channel)
			{
			case XAuthorizationChannel.XAuthorization_Internal:
				result = "";
				break;
			case XAuthorizationChannel.XAuthorization_SD:
				result = XStringDefineProxy.GetString("SDO_TOKEN");
				break;
			case XAuthorizationChannel.XAuthorization_QQ:
				result = "QQ";
				break;
			case XAuthorizationChannel.XAuthorization_WeChat:
				result = XStringDefineProxy.GetString("WECHAT_TOKEN");
				break;
			case XAuthorizationChannel.XAuthorization_Guest:
				result = XStringDefineProxy.GetString("GUEST_TOKEN");
				break;
			default:
				result = "";
				break;
			}
			return result;
		}

		private byte[] XCryptography(string content)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(content);
			for (int i = 0; i < bytes.Length; i++)
			{
				bytes[i] ^= XLoginDocument._seed;
			}
			return bytes;
		}

		private string XCryptography(byte[] content)
		{
			for (int i = 0; i < content.Length; i++)
			{
				content[i] ^= XLoginDocument._seed;
			}
			return Encoding.UTF8.GetString(content);
		}

		public bool IsPublish()
		{
			return XSingleton<XUpdater.XUpdater>.singleton.XPlatform.IsPublish();
		}

		public void SetBlockUIVisable(bool state)
		{
			bool flag = DlgBase<XLoginView, LoginWindowBehaviour>.singleton.IsVisible();
			if (flag)
			{
				DlgBase<XLoginView, LoginWindowBehaviour>.singleton.uiBehaviour.m_BlockWindow.gameObject.SetActive(state);
			}
			bool flag2 = DlgBase<XSelectCharView, SelectCharWindowBehaviour>.singleton.IsVisible();
			if (flag2)
			{
				DlgBase<XSelectCharView, SelectCharWindowBehaviour>.singleton.uiBehaviour.m_block.gameObject.SetActive(state);
			}
		}

		public void ShowLoginUI()
		{
			bool flag = !DlgBase<XLoginView, LoginWindowBehaviour>.singleton.IsVisible();
			if (!flag)
			{
				DlgBase<XLoginView, LoginWindowBehaviour>.singleton.ShowLogin();
			}
		}

		public void ShowLoginSelectServerUI()
		{
			bool flag = !DlgBase<XLoginView, LoginWindowBehaviour>.singleton.IsVisible();
			if (!flag)
			{
				bool flag2 = string.IsNullOrEmpty(XSingleton<XClientNetwork>.singleton.XLoginToken);
				if (flag2)
				{
					XSingleton<XLoginDocument>.singleton.AutoAuthorization(false);
				}
				this.ShowAfterLoginAnnouncement();
				DlgBase<XLoginView, LoginWindowBehaviour>.singleton.ShowSelectServer();
				DlgBase<XLoginView, LoginWindowBehaviour>.singleton.SetCurrentServer();
			}
		}

		public void ShowSelectCharGerenalUI()
		{
			bool flag = !DlgBase<XSelectCharView, SelectCharWindowBehaviour>.singleton.IsVisible();
			if (!flag)
			{
				DlgBase<XSelectCharView, SelectCharWindowBehaviour>.singleton.ShowSelectCharGerenal();
			}
		}

		public void ShowSelectCharSelectedUI(string name, int level)
		{
			bool flag = !DlgBase<XSelectCharView, SelectCharWindowBehaviour>.singleton.IsVisible();
			if (!flag)
			{
				DlgBase<XSelectCharView, SelectCharWindowBehaviour>.singleton.ShowSelectCharSelected(name, level);
			}
		}

		public void ShowSelectCharCreatedUI()
		{
			bool flag = !DlgBase<XSelectCharView, SelectCharWindowBehaviour>.singleton.IsVisible();
			if (!flag)
			{
				DlgBase<XSelectCharView, SelectCharWindowBehaviour>.singleton.ShowSelectCharCreated();
			}
		}

		public void SetLoginZoneID(uint loginZoneId)
		{
			this._login_zoneid = loginZoneId;
		}

		public void SetAnnouncement(PlatNotice announcement)
		{
			this._announcement = announcement;
		}

		public void SetFreeflow(bool _free, int _type)
		{
			this._freeflow = _free;
			this._cctype = _type;
		}

		public void SetGateIPTable(List<SelfServerData> myServersList, byte[] bytes, List<LoginGateData> serverList)
		{
			this._server_dic.Clear();
			this._server_category.Clear();
			this._zone_list.Clear();
			this.BackFlowServerList.Clear();
			for (int i = serverList.Count - 1; i >= 0; i--)
			{
				LoginGateData loginGateData = serverList[i];
				bool isbackflow = loginGateData.isbackflow;
				if (isbackflow)
				{
					bool flag = true;
					for (int j = 0; j < this.BackFlowServerList.Count; j++)
					{
						bool flag2 = this.BackFlowServerList[j].ServerID == loginGateData.serverid;
						if (flag2)
						{
							flag = false;
							break;
						}
					}
					bool flag3 = flag;
					if (flag3)
					{
						this.BackFlowServerList.Add(this.CreateServerInfoData(loginGateData.serverid, loginGateData.servername, loginGateData.zonename, loginGateData.ip, (uint)loginGateData.port, (int)loginGateData.state, (int)loginGateData.flag, loginGateData.backflowlevel));
					}
					serverList.RemoveAt(i);
				}
			}
			string @string = XSingleton<XStringTable>.singleton.GetString("MYSELF_SERVERS");
			this._server_category.Add(@string, new List<int>());
			this._zone_list.Add(@string);
			string string2 = XSingleton<XStringTable>.singleton.GetString("BACK_SERVERS");
			bool flag4 = this.BackFlowServerList.Count > 0;
			if (flag4)
			{
				this._zone_list.Add(string2);
				this._server_category.Add(string2, new List<int>());
			}
			string string3 = XSingleton<XStringTable>.singleton.GetString("FRIENDS_SERVERS");
			this._server_category.Add(string3, new List<int>());
			this._zone_list.Add(string3);
			bool flag5 = myServersList.Count == 0;
			if (flag5)
			{
				XSingleton<UiUtility>.singleton.ShowModalDialog(XStringDefineProxy.GetString("TRUE_NAME_TIP"), XStringDefineProxy.GetString("COMMON_OK"));
			}
			for (int k = 0; k < myServersList.Count; k++)
			{
				this._server_category[@string].Add(myServersList[k].servers.serverid);
				bool flag6 = !this._server_dic.ContainsKey(myServersList[k].servers.serverid);
				if (flag6)
				{
					List<string> list = new List<string>();
					list.Add(string.Format("{0}:{1}", myServersList[k].servers.ip, myServersList[k].servers.port));
					this._server_dic.Add(myServersList[k].servers.serverid, this.CreateServerInfoData(myServersList[k].servers.serverid, myServersList[k].servers.servername, myServersList[k].servers.zonename, myServersList[k].servers.ip, (uint)myServersList[k].servers.port, (int)myServersList[k].servers.state, (int)myServersList[k].servers.flag, myServersList[k].level));
				}
				for (int l = 0; l < this._backFlowServerList.Count; l++)
				{
					bool flag7 = this._backFlowServerList[l].ServerID == myServersList[k].servers.serverid;
					if (flag7)
					{
						this._backFlowServerList[l].Level = myServersList[k].level;
					}
				}
			}
			for (int m = 0; m < serverList.Count; m++)
			{
				bool flag8 = !this._server_category.ContainsKey(serverList[m].zonename);
				if (flag8)
				{
					this._server_category.Add(serverList[m].zonename, new List<int>());
					this._zone_list.Add(serverList[m].zonename);
				}
				this._server_category[serverList[m].zonename].Add(serverList[m].serverid);
				bool flag9 = !this._server_dic.ContainsKey(serverList[m].serverid);
				if (flag9)
				{
					this._server_dic.Add(serverList[m].serverid, this.CreateServerInfoData(serverList[m].serverid, serverList[m].servername, serverList[m].zonename, serverList[m].ip, (uint)serverList[m].port, (int)serverList[m].state, (int)serverList[m].flag, 0u));
				}
			}
			for (int n = 0; n < this.BackFlowServerList.Count; n++)
			{
				this._server_category[string2].Add(this.BackFlowServerList[n].ServerID);
				bool flag10 = !this._server_dic.ContainsKey(this.BackFlowServerList[n].ServerID);
				if (flag10)
				{
					this._server_dic.Add(this.BackFlowServerList[n].ServerID, this.BackFlowServerList[n]);
				}
			}
		}

		public void SetFriendServerList(List<PlatFriendServer> friendList)
		{
			this.FriendServerDic.Clear();
			this.FriendOpenid.Clear();
			for (int i = 0; i < friendList.Count; i++)
			{
				ServerInfo serverData = this.GetServerData(friendList[i].serverid);
				bool flag = serverData == null;
				if (!flag)
				{
					bool flag2 = !XSingleton<XGame>.singleton.IsGMAccount;
					if (flag2)
					{
						bool flag3 = serverData.StateTxt == 6;
						if (flag3)
						{
							goto IL_C4;
						}
					}
					FriendServerInfo friendServerInfo = new FriendServerInfo();
					friendServerInfo.info = friendList[i];
					friendServerInfo.account = "";
					friendServerInfo.icon = "";
					this.FriendServerDic[friendList[i].openid] = friendServerInfo;
					this.FriendOpenid.Add(friendList[i].openid);
				}
				IL_C4:;
			}
			XSingleton<XUpdater.XUpdater>.singleton.XPlatform.SendGameExData("QueryFriends", "");
		}

		public void SetFriendServerIcon()
		{
			for (int i = 0; i < XSingleton<PDatabase>.singleton.friendsInfo.data.Length; i++)
			{
				bool flag = this.FriendServerDic.ContainsKey(XSingleton<PDatabase>.singleton.friendsInfo.data[i].openId);
				if (flag)
				{
					this.FriendServerDic[XSingleton<PDatabase>.singleton.friendsInfo.data[i].openId].account = XSingleton<PDatabase>.singleton.friendsInfo.data[i].nickName;
					this.FriendServerDic[XSingleton<PDatabase>.singleton.friendsInfo.data[i].openId].icon = XSingleton<PDatabase>.singleton.friendsInfo.data[i].pictureLarge;
				}
			}
		}

		public ServerInfo CreateServerInfoData(int serverID, string serverName, string zoneName, string ip, uint port, int state, int stateTxt, uint level)
		{
			return new ServerInfo
			{
				ServerID = serverID,
				ServerName = serverName,
				ZoneName = zoneName,
				Ip = ip,
				Port = port,
				State = state,
				StateTxt = stateTxt,
				Level = level
			};
		}

		public ServerInfo GetServerData(int id)
		{
			ServerInfo serverInfo;
			bool flag = this._server_dic.TryGetValue(id, out serverInfo);
			ServerInfo result;
			if (flag)
			{
				result = serverInfo;
			}
			else
			{
				result = null;
			}
			return result;
		}

		public void OnServerChanged(int id)
		{
			ServerInfo serverData = this.GetServerData(id);
			bool flag = serverData == null;
			if (!flag)
			{
				bool flag2 = XSingleton<XClientNetwork>.singleton.OnServerChanged(serverData);
				if (flag2)
				{
					this._view.SetCurrentServer();
				}
			}
		}

		public bool OnLoginForbidClick(IXUIButton btn)
		{
			DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(false, true);
			this.BackToLogin();
			return true;
		}

		public void SetLoginReconnect(LoginReconnectInfo info)
		{
			this._login_reconnect_info = info;
		}

		public void ShowLoginReconnect()
		{
			bool flag = this._login_reconnect_info == null || this._login_reconnect_info.scenetemplateid == 0u;
			if (!flag)
			{
				SceneTable.RowData sceneData = XSingleton<XSceneMgr>.singleton.GetSceneData(this._login_reconnect_info.scenetemplateid);
				string @string = XStringDefineProxy.GetString("LOGIN_RECONNECT_TIP", new object[]
				{
					(sceneData != null) ? sceneData.Comment : ""
				});
				XSingleton<UiUtility>.singleton.ShowModalDialog(@string, XStringDefineProxy.GetString("COMMON_OK"), XStringDefineProxy.GetString("COMMON_CANCEL"), new ButtonClickEventHandler(this.OnStartLoginReconnectClicked), new ButtonClickEventHandler(this.OnCancelLoginReconnectClicked), false, XTempTipDefine.OD_START, 50);
			}
		}

		private bool OnStartLoginReconnectClicked(IXUIButton btn)
		{
			RpcC2N_LoginReconnectReq rpcC2N_LoginReconnectReq = new RpcC2N_LoginReconnectReq();
			rpcC2N_LoginReconnectReq.oArg.reconnect = true;
			XSingleton<XClientNetwork>.singleton.Send(rpcC2N_LoginReconnectReq);
			this._login_reconnect_info = null;
			this.SetBlockUIVisable(true);
			return true;
		}

		private bool OnCancelLoginReconnectClicked(IXUIButton btn)
		{
			RpcC2N_LoginReconnectReq rpcC2N_LoginReconnectReq = new RpcC2N_LoginReconnectReq();
			rpcC2N_LoginReconnectReq.oArg.reconnect = false;
			XSingleton<XClientNetwork>.singleton.Send(rpcC2N_LoginReconnectReq);
			this._login_reconnect_info = null;
			this.SetBlockUIVisable(true);
			return true;
		}
	}
}