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

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

		public XOptionsView View
		{
			get
			{
				return this._view;
			}
			set
			{
				this._view = value;
			}
		}

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

		private XOptionsView _view = null;

		public static readonly int SIGHT_NUM = 3;

		public static readonly int MAGNIFICATION_MULTIPLE = 1000;

		private readonly int[] _QualityLevel = new int[]
		{
			0,
			3,
			5
		};

		private Dictionary<XOptionsDefine, int> options = new Dictionary<XOptionsDefine, int>(default(XFastEnumIntEqualityComparer<XOptionsDefine>));

		private Dictionary<XOptionsDefine, float> floatOptions = new Dictionary<XOptionsDefine, float>(default(XFastEnumIntEqualityComparer<XOptionsDefine>));

		private Dictionary<XOptionsDefine, string> strOptions = new Dictionary<XOptionsDefine, string>(default(XFastEnumIntEqualityComparer<XOptionsDefine>));

		public static Dictionary<string, int> pushSettings = new Dictionary<string, int>();

		public static Dictionary<string, int> localPushSetting = new Dictionary<string, int>();

		public static PushSetting _pushSettingTable = new PushSetting();

		public static PushMessageTable _pushMessageTable = new PushMessageTable();

		public static List<PushSetting.RowData> _pushSetting1 = new List<PushSetting.RowData>();

		public static List<PushSetting.RowData> _pushSetting2 = new List<PushSetting.RowData>();

		public static XOptions _optionsTable = new XOptions();

		public static List<List<List<XOptions.RowData>>> optionsData = new List<List<List<XOptions.RowData>>>();

		public static Dictionary<XOptionsDefine, XOptionsDocument.OptionData> optionsDefault = new Dictionary<XOptionsDefine, XOptionsDocument.OptionData>(default(XFastEnumIntEqualityComparer<XOptionsDefine>));

		public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();

		public bool openVoice = true;

		public float voiceVolme = 1f;

		private float bgmVolme;

		private float mscVolme;

		public bool Flowerrain;

		private static XOptionsDocument.OptionData optionDefault = default(XOptionsDocument.OptionData);

		private float lastSameScreenValue;

		private float lastSound = -1f;

		private float lastMusic = -1f;

		private float lastVoice = -1f;

		private bool openSound;

		private bool openMusic;

		public struct OptionData
		{
			public string[,] val;

			public bool NeedSight;

			public bool[] NeedProfession;

			public void Init()
			{
				this.val = new string[XOptionsDocument.SIGHT_NUM, XGame.RoleCount];
				this.NeedProfession = new bool[XOptionsDocument.SIGHT_NUM];
			}
		}

		public override void OnAttachToHost(XObject host)
		{
			base.OnAttachToHost(host);
			this.LoadSetting();
			this.RefreshLocalSettings();
			XSingleton<XUpdater.XUpdater>.singleton.XPlatform.SendGameExData("push_local_clear", "");
		}

		public static void Execute(OnLoadedCallback callback = null)
		{
			XOptionsDocument.AsyncLoader.AddTask("Table/PushSetting", XOptionsDocument._pushSettingTable, false);
			XOptionsDocument.AsyncLoader.AddTask("Table/PushMessage", XOptionsDocument._pushMessageTable, false);
			XOptionsDocument.AsyncLoader.AddTask("Table/XOptions", XOptionsDocument._optionsTable, false);
			XOptionsDocument.AsyncLoader.Execute(callback);
		}

		public static void OnTableLoaded()
		{
			XOptionsDocument.pushSettings.Clear();
			for (int i = 0; i < XOptionsDocument._pushSettingTable.Table.Length; i++)
			{
				bool flag = XOptionsDocument._pushSettingTable.Table[i].TimeOrSystem == 1u;
				if (flag)
				{
					XOptionsDocument._pushSetting1.Add(XOptionsDocument._pushSettingTable.Table[i]);
				}
				else
				{
					bool flag2 = XOptionsDocument._pushSettingTable.Table[i].TimeOrSystem == 2u;
					if (flag2)
					{
						XOptionsDocument._pushSetting2.Add(XOptionsDocument._pushSettingTable.Table[i]);
					}
				}
				string configKey = XOptionsDocument._pushSettingTable.Table[i].ConfigKey;
				XOptionsDocument.pushSettings.Add(configKey, 1);
			}
			XOptionsDocument.optionsData.Clear();
			for (int j = 0; j < XFastEnumIntEqualityComparer<OptionsBattleTab>.ToInt(OptionsBattleTab.OtherTab); j++)
			{
				XOptionsDocument.optionsData.Add(new List<List<XOptions.RowData>>());
				XOptionsDefine option = XOptionsDefine.OD_VIEW + j;
				XOptions.RowData optionData = XOptionsDocument.GetOptionData(option);
				bool flag3 = optionData.OptionText != null;
				if (flag3)
				{
					for (int k = 0; k < optionData.OptionText.Length; k++)
					{
						XOptionsDocument.optionsData[j].Add(new List<XOptions.RowData>());
					}
				}
				else
				{
					XOptionsDocument.optionsData[j].Add(new List<XOptions.RowData>());
				}
			}
			for (int l = 0; l < XOptionsDocument._optionsTable.Table.Length; l++)
			{
				int id = XOptionsDocument._optionsTable.Table[l].ID;
				int num = XOptionsDocument._optionsTable.Table[l].Classify[0];
				int num2 = XOptionsDocument._optionsTable.Table[l].Classify[1];
				int type = XOptionsDocument._optionsTable.Table[l].Type;
				int sort = XOptionsDocument._optionsTable.Table[l].Sort;
				bool flag4 = id <= 0;
				if (!flag4)
				{
					XOptions.RowData rowData = XOptionsDocument._optionsTable.Table[l];
					bool flag5 = rowData.ID != 0;
					if (flag5)
					{
						XOptionsDocument.optionDefault.Init();
						string[] array = rowData.Default.Split(new char[]
						{
							'|'
						});
						XOptionsDocument.optionDefault.NeedSight = (array.Length != 1);
						for (int m = 0; m < XOptionsDocument.SIGHT_NUM; m++)
						{
							bool flag6 = array.Length == 1;
							string text;
							if (flag6)
							{
								text = array[0];
							}
							else
							{
								text = array[m];
							}
							string[] array2 = text.Split(new char[]
							{
								'='
							});
							XOptionsDocument.optionDefault.NeedProfession[m] = (array2.Length != 1);
							for (int n = 0; n < XGame.RoleCount; n++)
							{
								bool flag7 = array2.Length == 1;
								string text2;
								if (flag7)
								{
									text2 = array2[0];
								}
								else
								{
									text2 = array2[n];
								}
								XOptionsDocument.optionDefault.val[m, n] = text2;
							}
						}
						XOptionsDocument.optionsDefault.Add((XOptionsDefine)rowData.ID, XOptionsDocument.optionDefault);
					}
					bool flag8 = (num == 0 && num2 == 0) || type == 0;
					if (!flag8)
					{
						bool flag9 = XOptionsDocument.optionsData.Count >= num && XOptionsDocument.optionsData[num - 1].Count >= num2;
						if (flag9)
						{
							XOptionsDocument.optionsData[num - 1][num2 - 1].Add(rowData);
						}
						else
						{
							XSingleton<XDebug>.singleton.AddErrorLog("XOptions Table Error! ID:" + rowData.ID, null, null, null, null, null);
						}
					}
				}
			}
			for (int num3 = 0; num3 < XOptionsDocument.optionsData.Count; num3++)
			{
				for (int num4 = 0; num4 < XOptionsDocument.optionsData[num3].Count; num4++)
				{
					XOptionsDocument.optionsData[num3][num4].Sort(new Comparison<XOptions.RowData>(XOptionsDocument.SortCompare));
				}
			}
		}

		public static XOptions.RowData GetOptionData(XOptionsDefine option)
		{
			return XOptionsDocument.GetOptionData(XFastEnumIntEqualityComparer<XOptionsDefine>.ToInt(option));
		}

		public static XOptions.RowData GetOptionData(int optionID)
		{
			return XOptionsDocument._optionsTable.GetByID(optionID);
		}

		private static int SortCompare(XOptions.RowData item1, XOptions.RowData item2)
		{
			int sort = item1.Sort;
			int sort2 = item2.Sort;
			bool flag = sort == sort2;
			int result;
			if (flag)
			{
				result = -item1.ID.CompareTo(item2.ID);
			}
			else
			{
				result = -sort.CompareTo(sort2);
			}
			return result;
		}

		public override void OnEnterSceneFinally()
		{
			SceneTable.RowData sceneData = XSingleton<XSceneMgr>.singleton.GetSceneData(XSingleton<XScene>.singleton.SceneID);
			bool flag = sceneData != null && sceneData.ShieldSight != null;
			if (flag)
			{
				for (int i = 0; i < sceneData.ShieldSight.Length; i++)
				{
					bool flag2 = (int)sceneData.ShieldSight[i] == this.GetValue(XOptionsDefine.OD_VIEW);
					if (flag2)
					{
						this.SetDefaultSight(sceneData.ShieldSight);
						break;
					}
				}
			}
			this.SetBattleOptionValue();
			bool flag3 = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsVisible();
			if (flag3)
			{
				DlgBase<BattleMain, BattleMainBehaviour>.singleton.SetView(XSingleton<XOperationData>.singleton.OperationMode);
			}
			bool flag4 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_HORSE_RACE || XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_WEEKEND4V4_HORSERACING;
			if (flag4)
			{
			}
		}

		private void SetDefaultSight(byte[] shieldSight)
		{
			for (XOperationMode xoperationMode = XOperationMode.X25D; xoperationMode <= XOperationMode.X3D_Free; xoperationMode++)
			{
				bool flag = true;
				for (int i = 0; i < shieldSight.Length; i++)
				{
					bool flag2 = (XOperationMode)shieldSight[i] == xoperationMode;
					if (flag2)
					{
						flag = false;
						break;
					}
				}
				bool flag3 = flag;
				if (flag3)
				{
					this.SetValue(XOptionsDefine.OD_VIEW, XFastEnumIntEqualityComparer<XOperationMode>.ToInt(xoperationMode), false);
					XSingleton<XDebug>.singleton.AddGreenLog("Auto Change Sight:" + xoperationMode.ToString(), null, null, null, null, null);
					return;
				}
			}
			XSingleton<XDebug>.singleton.AddErrorLog("No Default Sight", null, null, null, null, null);
		}

		public override void OnGamePause(bool pause)
		{
			XSingleton<XDebug>.singleton.AddLog("push_local_clear", null, null, null, null, null, XDebugColor.XDebug_None);
			XSingleton<XUpdater.XUpdater>.singleton.XPlatform.SendGameExData("push_local_clear", "");
			if (pause)
			{
				DateTime now = DateTime.Now;
				int hour = now.Hour;
				int minute = now.Minute;
				int num = Convert.ToInt32(DateTime.Now.DayOfWeek.ToString("d"));
				for (int i = 0; i < XOptionsDocument._pushMessageTable.Table.Length; i++)
				{
					PushMessageTable.RowData rowData = XOptionsDocument._pushMessageTable.Table[i];
					bool flag = rowData.IsCommonGlobal == 1u && this.IsPushOpen(rowData.Type);
					if (flag)
					{
						bool flag2 = rowData.WeekDay == null || rowData.WeekDay.Length == 0;
						if (flag2)
						{
							bool flag3 = (ulong)rowData.Time[0] > (ulong)((long)hour) || ((ulong)rowData.Time[0] == (ulong)((long)hour) && (ulong)rowData.Time[1] > (ulong)((long)minute));
							if (flag3)
							{
								XSingleton<XUpdater.XUpdater>.singleton.XPlatform.SendGameExData("push_local", this.MakeJson(rowData, now));
							}
							DateTime date = now.AddDays(1.0);
							XSingleton<XUpdater.XUpdater>.singleton.XPlatform.SendGameExData("push_local", this.MakeJson(rowData, date));
							DateTime date2 = now.AddDays(2.0);
							XSingleton<XUpdater.XUpdater>.singleton.XPlatform.SendGameExData("push_local", this.MakeJson(rowData, date2));
						}
						else
						{
							for (int j = 0; j < rowData.WeekDay.Length; j++)
							{
								bool flag4 = rowData.WeekDay[j] == (uint)num;
								if (flag4)
								{
									bool flag5 = (ulong)rowData.Time[0] > (ulong)((long)hour) || ((ulong)rowData.Time[0] == (ulong)((long)hour) && (ulong)rowData.Time[1] > (ulong)((long)minute));
									if (flag5)
									{
										XSingleton<XUpdater.XUpdater>.singleton.XPlatform.SendGameExData("push_local", this.MakeJson(rowData, now));
									}
								}
								else
								{
									bool flag6 = rowData.WeekDay[j] > (uint)num;
									if (flag6)
									{
										DateTime date3 = now.AddDays((double)((ulong)rowData.WeekDay[j] - (ulong)((long)num)));
										XSingleton<XUpdater.XUpdater>.singleton.XPlatform.SendGameExData("push_local", this.MakeJson(rowData, date3));
									}
								}
							}
						}
					}
				}
			}
			base.OnGamePause(pause);
		}

		private string MakeJson(PushMessageTable.RowData row, DateTime date)
		{
			Dictionary<string, object> dictionary = new Dictionary<string, object>();
			dictionary["title"] = row.Title;
			dictionary["content"] = row.Content;
			dictionary["type"] = 1;
			bool flag = (int)Application.platform == 8;
			if (flag)
			{
				dictionary["date"] = date.ToString("yyyy-MM-dd");
				dictionary["hour"] = ((row.Time[0] < 10u) ? ("0" + row.Time[0].ToString()) : row.Time[0].ToString());
				dictionary["min"] = ((row.Time[1] < 10u) ? ("0" + row.Time[1].ToString()) : row.Time[1].ToString());
			}
			else
			{
				dictionary["date"] = date.ToString("yyyyMMdd");
				dictionary["hour"] = row.Time[0];
				dictionary["min"] = row.Time[1];
			}
			string text = Json.Serialize(dictionary);
			XSingleton<XDebug>.singleton.AddLog(Application.platform.ToString(), " => ", text, null, null, null, XDebugColor.XDebug_None);
			return text;
		}

		private bool IsPushOpen(uint type)
		{
			for (int i = 0; i < XOptionsDocument._pushSettingTable.Table.Length; i++)
			{
				bool flag = XOptionsDocument._pushSettingTable.Table[i].Type == type;
				if (flag)
				{
					return XOptionsDocument.pushSettings[XOptionsDocument._pushSettingTable.Table[i].ConfigKey] == 1;
				}
			}
			return true;
		}

		public void OnBlockOtherPlayers()
		{
			this.ProccessOption(XOptionsDefine.OD_BLOCKOTHERPLAYERS, this.GetValue(XOptionsDefine.OD_BLOCKOTHERPLAYERS));
		}

		protected override void EventSubscribe()
		{
			base.EventSubscribe();
			base.RegisterEvent(XEventDefine.XEvent_AudioOperation, new XComponent.XEventHandler(this.OnChatVoiceHandled));
		}

		public void InitServerConfig(RoleConfig serverConfig)
		{
			bool flag = serverConfig != null;
			if (flag)
			{
				bool flag2 = serverConfig.type.Count != serverConfig.value.Count;
				if (flag2)
				{
					XSingleton<XDebug>.singleton.AddErrorLog("serverConfig.type.Count != serverConfig.value.Count", null, null, null, null, null);
				}
				else
				{
					Type typeFromHandle = typeof(XOptionsDefine);
					for (int i = 0; i < serverConfig.type.Count; i++)
					{
						try
						{
							bool flag3 = XOptionsDocument.pushSettings.ContainsKey(serverConfig.type[i]);
							if (flag3)
							{
								bool flag4 = !XOptionsDocument.localPushSetting.ContainsKey(serverConfig.type[i]);
								if (flag4)
								{
									XOptionsDocument.pushSettings[serverConfig.type[i]] = int.Parse(serverConfig.value[i]);
								}
							}
							else
							{
								XOptionsDefine xoptionsDefine = (XOptionsDefine)Enum.Parse(typeFromHandle, serverConfig.type[i]);
								XOptionsDefine xoptionsDefine2 = xoptionsDefine;
								if (xoptionsDefine2 != XOptionsDefine.OD_TEAM_PASSWORD)
								{
									XOptions.RowData optionData = XOptionsDocument.GetOptionData(xoptionsDefine);
									bool flag5 = optionData != null && optionData.Type != 0;
									if (flag5)
									{
										bool flag6 = optionData.Type == 2;
										if (flag6)
										{
											float value;
											bool flag7 = float.TryParse(serverConfig.value[i], out value);
											if (flag7)
											{
												this.floatOptions[xoptionsDefine] = value;
											}
											this.ProccessOption(xoptionsDefine, this.GetFloatValue(xoptionsDefine));
										}
										else
										{
											int value2;
											bool flag8 = int.TryParse(serverConfig.value[i], out value2);
											if (flag8)
											{
												this.options[xoptionsDefine] = value2;
											}
											this.ProccessOption(xoptionsDefine, this.GetValue(xoptionsDefine));
										}
									}
								}
								else
								{
									this.strOptions.Add(xoptionsDefine, serverConfig.value[i]);
								}
							}
						}
						catch (ArgumentException)
						{
							XSingleton<XDebug>.singleton.AddGreenLog(string.Format("'{0}' is not a member of the XOptionsDefine enumeration.", serverConfig.type[i]), null, null, null, null, null);
						}
					}
				}
			}
		}

		public void RefreshLocalSettings()
		{
			for (XOptionsDefine xoptionsDefine = XOptionsDefine.OD_START; xoptionsDefine != XOptionsDefine.OD_LOCALSETTING_END; xoptionsDefine++)
			{
				this.ProccessOption(xoptionsDefine, this.GetValue(xoptionsDefine));
			}
		}

		public void LoadSetting()
		{
			string path = Application.persistentDataPath + "/options.txt";
			bool flag = (int)Application.platform == 7 || (int)Application.platform == 0 || (int)Application.platform == 2;
			if (flag)
			{
				path = Application.dataPath + "/options.txt";
			}
			this.options.Clear();
			bool flag2 = !File.Exists(path);
			if (!flag2)
			{
				using (StreamReader streamReader = new StreamReader(path))
				{
					Type typeFromHandle = typeof(XOptionsDefine);
					string text;
					while ((text = streamReader.ReadLine()) != null)
					{
						string[] array = text.Split(XGlobalConfig.SpaceSeparator);
						bool flag3 = array.Length != 2;
						if (flag3)
						{
							XSingleton<XDebug>.singleton.AddErrorLog("Option file format error: ", text, null, null, null, null);
						}
						else
						{
							try
							{
								bool flag4 = XOptionsDocument.pushSettings.ContainsKey(array[0]);
								if (flag4)
								{
									int value = int.Parse(array[1]);
									XOptionsDocument.pushSettings[array[0]] = value;
									XOptionsDocument.localPushSetting[array[0]] = value;
								}
								else
								{
									XOptionsDefine key = (XOptionsDefine)Enum.Parse(typeFromHandle, array[0]);
									this.options.Add(key, int.Parse(array[1]));
								}
							}
							catch (ArgumentException)
							{
								XSingleton<XDebug>.singleton.AddErrorLog(string.Format("'{0}' is not a member of the XOptionsDefine enumeration.", array[0]), null, null, null, null, null);
							}
						}
					}
				}
			}
		}

		public void SaveSetting()
		{
			try
			{
				string text = Application.persistentDataPath + "/options.txt";
				bool flag = (int)Application.platform == 7 || (int)Application.platform == 0 || (int)Application.platform == 2;
				if (flag)
				{
					text = Application.dataPath + "/options.txt";
				}
				using (StreamWriter streamWriter = new StreamWriter(text))
				{
					foreach (KeyValuePair<string, int> keyValuePair in XOptionsDocument.localPushSetting)
					{
						streamWriter.Write(keyValuePair.Key);
						streamWriter.Write(' ');
						streamWriter.WriteLine(keyValuePair.Value);
					}
					foreach (KeyValuePair<XOptionsDefine, int> keyValuePair2 in this.options)
					{
						bool flag2 = keyValuePair2.Key >= XOptionsDefine.OD_LOCALSETTING_END;
						if (!flag2)
						{
							streamWriter.Write(keyValuePair2.Key);
							streamWriter.Write(' ');
							streamWriter.WriteLine(keyValuePair2.Value);
						}
					}
					foreach (KeyValuePair<XOptionsDefine, float> keyValuePair3 in this.floatOptions)
					{
						bool flag3 = keyValuePair3.Key >= XOptionsDefine.OD_LOCALSETTING_END;
						if (!flag3)
						{
							streamWriter.Write(keyValuePair3.Key);
							streamWriter.Write(' ');
							streamWriter.WriteLine(keyValuePair3.Value);
						}
					}
					XSingleton<XUpdater.XUpdater>.singleton.XPlatform.SetNoBackupFlag(text);
				}
			}
			catch (Exception)
			{
				XSingleton<XDebug>.singleton.AddErrorLog("Save Setting Error", null, null, null, null, null);
			}
		}

		public void ReqSwitchAccount()
		{
			XSingleton<XClientNetwork>.singleton.Close(NetErrCode.Net_NoError);
			XSingleton<XLoginDocument>.singleton.AuthorizationSignOut();
		}

		public void ReqSwitchChar()
		{
			RpcC2M_ReturnToSelectRole rpc = new RpcC2M_ReturnToSelectRole();
			XSingleton<XClientNetwork>.singleton.Send(rpc);
		}

		public void ReqCustomerService()
		{
			XSingleton<XDebug>.singleton.AddLog("CS coming soon!", null, null, null, null, null, XDebugColor.XDebug_None);
		}

		public void OpenCustomerService()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			RuntimePlatform platform = Application.platform;
			if ((int)platform != 8)
			{
				if ((int)platform != 11)
				{
					XSingleton<XDebug>.singleton.AddGreenLog("CustomerService-Options", null, null, null, null, null);
				}
				else
				{
					dictionary["url"] = XSingleton<XGlobalConfig>.singleton.GetValue("CustomerServiceSetAndroid");
					dictionary["screendir"] = "SENSOR";
					XSingleton<XUpdater.XUpdater>.singleton.XPlatform.SendExtDara("open_url", Json.Serialize(dictionary));
				}
			}
			else
			{
				dictionary["url"] = XSingleton<XGlobalConfig>.singleton.GetValue("CustomerServiceSetApple");
				dictionary["screendir"] = "SENSOR";
				XSingleton<XUpdater.XUpdater>.singleton.XPlatform.SendExtDara("open_url", Json.Serialize(dictionary));
			}
		}

		public void OpenURL(string url)
		{
			Application.OpenURL(url);
		}

		public override void Update(float fDeltaT)
		{
			base.Update(fDeltaT);
			bool flag = DlgBase<XOptionsView, XOptionsBehaviour>.singleton.IsVisible() && this.View.CurrentTab == OptionsTab.OptionTab && (double)Math.Abs(this.lastSameScreenValue - this.View.uiBehaviour.m_SameScreenBar.value) > 1E-05;
			if (flag)
			{
				this.lastSameScreenValue = this.View.uiBehaviour.m_SameScreenBar.value;
				this.View.SameScreenNumChange(this.lastSameScreenValue);
			}
			bool flag2 = DlgBase<XOptionsView, XOptionsBehaviour>.singleton.IsVisible() && this.View.CurrentTab == OptionsTab.OptionTab && (double)Math.Abs(this.lastSound - this.View.uiBehaviour.m_SoundBar.value) > 1E-05;
			if (flag2)
			{
				this.lastSound = this.View.uiBehaviour.m_SoundBar.value;
				this.SetValue(XOptionsDefine.BA_SOUND, (int)(this.lastSound * 100f), false);
				this.ProccessOption(XOptionsDefine.BA_SOUND, (int)(this.lastSound * 100f));
			}
			bool flag3 = DlgBase<XOptionsView, XOptionsBehaviour>.singleton.IsVisible() && this.View.CurrentTab == OptionsTab.OptionTab && (double)Math.Abs(this.lastMusic - this.View.uiBehaviour.m_MusicBar.value) > 1E-05;
			if (flag3)
			{
				this.lastMusic = this.View.uiBehaviour.m_MusicBar.value;
				this.SetValue(XOptionsDefine.BA_MUSIC, (int)(this.lastMusic * 100f), false);
				this.ProccessOption(XOptionsDefine.BA_MUSIC, (int)(this.lastMusic * 100f));
			}
			bool flag4 = DlgBase<XOptionsView, XOptionsBehaviour>.singleton.IsVisible() && this.View.CurrentTab == OptionsTab.OptionTab && (double)Math.Abs(this.lastVoice - this.View.uiBehaviour.m_VoiceBar.value) > 1E-05;
			if (flag4)
			{
				this.lastVoice = this.View.uiBehaviour.m_VoiceBar.value;
				this.SetValue(XOptionsDefine.BA_VOICE, (int)(this.lastVoice * 100f), false);
				this.ProccessOption(XOptionsDefine.BA_VOICE, (int)(this.lastVoice * 100f));
			}
		}

		private PushSetting.RowData GetPushSettingRow(string option)
		{
			for (int i = 0; i < XOptionsDocument._pushSettingTable.Table.Length; i++)
			{
				bool flag = XOptionsDocument._pushSettingTable.Table[i].ConfigKey == option;
				if (flag)
				{
					return XOptionsDocument._pushSettingTable.Table[i];
				}
			}
			return null;
		}

		public void SavePushValue(string option, int value)
		{
			bool flag = XOptionsDocument.pushSettings.ContainsKey(option);
			if (flag)
			{
				XOptionsDocument.pushSettings[option] = value;
				bool flag2 = this.GetPushSettingRow(option).TimeOrSystem == 1u;
				if (flag2)
				{
					XOptionsDocument.localPushSetting[option] = value;
				}
				else
				{
					RpcC2G_SetRoleConfig rpcC2G_SetRoleConfig = new RpcC2G_SetRoleConfig();
					rpcC2G_SetRoleConfig.oArg.type = option;
					rpcC2G_SetRoleConfig.oArg.value = value.ToString();
					XSingleton<XClientNetwork>.singleton.Send(rpcC2G_SetRoleConfig);
				}
			}
			else
			{
				XSingleton<XDebug>.singleton.AddErrorLog("not push type ", option, null, null, null, null);
			}
		}

		private void SaveToCloud(XOptionsDefine option, int value)
		{
			this.SaveToCloud(option, value.ToString());
		}

		private void SaveToCloud(XOptionsDefine option, string value)
		{
			bool flag = option > XOptionsDefine.OD_LOCALSETTING_END;
			if (flag)
			{
				RpcC2G_SetRoleConfig rpcC2G_SetRoleConfig = new RpcC2G_SetRoleConfig();
				rpcC2G_SetRoleConfig.oArg.type = option.ToString();
				rpcC2G_SetRoleConfig.oArg.value = value;
				XSingleton<XClientNetwork>.singleton.Send(rpcC2G_SetRoleConfig);
			}
		}

		public bool SetValue(XOptionsDefine option, int value, bool isMustSave = false)
		{
			bool flag = !isMustSave && this.GetValue(option) == value;
			bool result;
			if (flag)
			{
				result = false;
			}
			else
			{
				this.options[option] = value;
				this.ProccessOption(option, value);
				this.SaveToCloud(option, value);
				result = true;
			}
			return result;
		}

		public bool SetSliderValue(XOptionsDefine option, float value)
		{
			bool flag = this.GetFloatValue(option) == value;
			bool result;
			if (flag)
			{
				result = false;
			}
			else
			{
				this.floatOptions[option] = value;
				this.ProccessOption(option, value);
				this.SaveToCloud(option, value.ToString());
				result = true;
			}
			return result;
		}

		public bool SetValue(XOptionsDefine option, string value)
		{
			bool flag = this.GetStrValue(option) == value;
			bool result;
			if (flag)
			{
				result = false;
			}
			else
			{
				this.strOptions[option] = value;
				this.SaveToCloud(option, value);
				result = true;
			}
			return result;
		}

		public int GetPushValue(string option)
		{
			bool flag = XOptionsDocument.pushSettings.ContainsKey(option);
			int result;
			if (flag)
			{
				result = XOptionsDocument.pushSettings[option];
			}
			else
			{
				result = 0;
			}
			return result;
		}

		public int GetValue(XOptionsDefine option)
		{
			int num;
			bool flag = this.options.TryGetValue(option, out num);
			int result;
			if (flag)
			{
				result = num;
			}
			else
			{
				result = this.GetDefaultValue(option);
			}
			return result;
		}

		public float GetFloatValue(XOptionsDefine option)
		{
			float num;
			bool flag = this.floatOptions.TryGetValue(option, out num);
			float result;
			if (flag)
			{
				result = num;
			}
			else
			{
				result = this.GetDefaultFloatValue(option);
			}
			return result;
		}

		public string GetStrValue(XOptionsDefine option)
		{
			string text;
			bool flag = this.strOptions.TryGetValue(option, out text);
			string result;
			if (flag)
			{
				result = text;
			}
			else
			{
				result = this.GetDefaultStrValue(option);
			}
			return result;
		}

		private void ProccessOption(XOptionsDefine option, int value)
		{
			switch (option)
			{
			case XOptionsDefine.OD_SOUND:
				this.openSound = (value == 1);
				this.SetBGMVolme(this.openSound ? ((this.lastSound == -1f) ? 1f : this.lastSound) : 0f);
				break;
			case XOptionsDefine.BA_SOUND:
			{
				bool flag = this.openSound;
				if (flag)
				{
					this.SetBGMVolme((float)value / 100f);
				}
				break;
			}
			case XOptionsDefine.OD_MUSIC:
				this.openMusic = (value == 1);
				this.SetMuscVolme(this.openMusic ? ((this.lastMusic == -1f) ? 1f : this.lastMusic) : 0f);
				break;
			case XOptionsDefine.BA_MUSIC:
			{
				bool flag2 = this.openMusic;
				if (flag2)
				{
					this.SetMuscVolme((float)value / 100f);
				}
				break;
			}
			case XOptionsDefine.OD_VOICE:
				this.openVoice = (value == 1);
				this.SetVoiceVolme(this.openVoice ? ((this.lastVoice == -1f) ? 1f : this.lastVoice) : 0f);
				break;
			case XOptionsDefine.BA_VOICE:
			{
				bool flag3 = this.openVoice;
				if (flag3)
				{
					this.SetVoiceVolme((float)value / 100f);
				}
				break;
			}
			case (XOptionsDefine)7:
			case (XOptionsDefine)8:
			case (XOptionsDefine)9:
			case (XOptionsDefine)18:
			case (XOptionsDefine)19:
			case XOptionsDefine.OD_TEAM_USE_PASSWORD:
			case XOptionsDefine.OD_3D_TOUCH:
				break;
			case XOptionsDefine.OD_VOLUME:
			{
				bool flag4 = this.View != null;
				if (flag4)
				{
					this.View.SetVolume(value);
				}
				break;
			}
			case XOptionsDefine.OD_RADIO_WIFI:
				XSingleton<XChatIFlyMgr>.singleton.SetChannelAutoPlay(ChatChannelType.ZeroChannel, value == 1);
				break;
			case XOptionsDefine.OD_RADIO_TEAM:
				XSingleton<XChatIFlyMgr>.singleton.SetChannelAutoPlay(ChatChannelType.Team, value == 1);
				break;
			case XOptionsDefine.OD_RADIO_CAMP:
				XSingleton<XChatIFlyMgr>.singleton.SetChannelAutoPlay(ChatChannelType.Camp, value == 1);
				break;
			case XOptionsDefine.OD_RADIO_PRIVATE:
				XSingleton<XChatIFlyMgr>.singleton.SetChannelAutoPlay(ChatChannelType.Friends, value == 1);
				break;
			case XOptionsDefine.OD_RADIO_PUBLIC:
				XSingleton<XChatIFlyMgr>.singleton.SetChannelAutoPlay(ChatChannelType.Guild, value == 1);
				break;
			case XOptionsDefine.OD_RADIO_WORLD:
				XSingleton<XChatIFlyMgr>.singleton.SetChannelAutoPlay(ChatChannelType.World, value == 1);
				break;
			case XOptionsDefine.OD_RADIO_AUTO_PALY:
				XSingleton<XChatIFlyMgr>.singleton.SetChannelAutoPlay(ChatChannelType.Curr, value == 1);
				break;
			case XOptionsDefine.OD_QUALITY:
				this._ProcessQuality(value);
				break;
			case XOptionsDefine.OD_FLOWERRAIN:
				this.Flowerrain = (value == 1);
				break;
			case XOptionsDefine.OD_SAMESCREENNUM:
				XQualitySetting.SetVisibleRoleLevel(value);
				break;
			case XOptionsDefine.OD_RADIO:
				DlgBase<RadioDlg, RadioBehaviour>.singleton.Process(value == 1);
				break;
			case XOptionsDefine.OD_SMOOTH:
				XSingleton<XGameUI>.singleton.SetUIOptOption(false, value == 1, false, true);
				break;
			case XOptionsDefine.OD_RESOLUTION:
				XQualitySetting.SetResolution((XQualitySetting.EResolution)value, false);
				break;
			case XOptionsDefine.OD_POWERSAVE:
				this._ProcessPowerSave(value);
				break;
			case XOptionsDefine.OD_NOTIFICATION:
				this._ProcessNotification(value);
				break;
			case XOptionsDefine.OD_BLOCKOTHERPLAYERS:
				this._ProcessBlockOtherPlayers(value);
				break;
			default:
				switch (option)
				{
				case XOptionsDefine.OD_Gyro:
					XSingleton<XGyroscope>.singleton.Enabled = (value == 1);
					break;
				case XOptionsDefine.OD_Shield_Skill_Fx:
					XSingleton<XInput>.singleton.UpdateShieldOperation();
					break;
				case XOptionsDefine.OD_Shield_Summon:
					XSingleton<XInput>.singleton.UpdateShieldOperation();
					break;
				case XOptionsDefine.OD_Shield_My_Skill_Fx:
					XSingleton<XInput>.singleton.UpdateShieldOperation();
					break;
				}
				break;
			}
		}

		private void ProccessOption(XOptionsDefine option, float value)
		{
		}

		private string GetDefaultStrValue(XOptionsDefine option)
		{
			return string.Empty;
		}

		private float GetDefaultFloatValue(XOptionsDefine option)
		{
			string configurationDefault = this.GetConfigurationDefault(option);
			bool flag = string.IsNullOrEmpty(configurationDefault);
			float result;
			if (flag)
			{
				result = 0f;
			}
			else
			{
				result = float.Parse(configurationDefault);
			}
			return result;
		}

		private int GetDefaultValue(XOptionsDefine option)
		{
			int result;
			switch (option)
			{
			case XOptionsDefine.OD_QUALITY:
				result = XQualitySetting.GetDefaultQualityLevel();
				break;
			case XOptionsDefine.OD_FLOWERRAIN:
				result = ((XQualitySetting.GetDefaultQualityLevel() == XFastEnumIntEqualityComparer<XQualitySetting.ESetting>.ToInt(XQualitySetting.ESetting.ELow)) ? 0 : 1);
				break;
			case XOptionsDefine.OD_SAMESCREENNUM:
				result = XQualitySetting.GetDefalutVisibleRoleLevel();
				break;
			default:
				if (option != XOptionsDefine.OD_RESOLUTION)
				{
					if (option != XOptionsDefine.OD_TAILCAMERA_SPEED)
					{
						string configurationDefault = this.GetConfigurationDefault(option);
						bool flag = string.IsNullOrEmpty(configurationDefault);
						if (flag)
						{
							result = 0;
						}
						else
						{
							result = int.Parse(configurationDefault);
						}
					}
					else
					{
						bool flag2 = XSingleton<XEntityMgr>.singleton.Player != null;
						if (flag2)
						{
							result = XSingleton<XOperationData>.singleton.TailCameraSpeed;
						}
						else
						{
							result = 50;
						}
					}
				}
				else
				{
					result = XQualitySetting.GetDefalutResolution();
				}
				break;
			}
			return result;
		}

		public bool IsShow3DTouch()
		{
			return (int)Application.platform == 8 && XSingleton<XUpdater.XUpdater>.singleton.XPlatform.CheckStatus("Is_3DTouch_Supported", "");
		}

		private void _ProcessPowerSave(int value)
		{
		}

		private void _ProcessNotification(int value)
		{
			XSingleton<XUpdater.XUpdater>.singleton.XPlatform.SetPushStatus(true);
		}

		private void _ProcessQuality(int value)
		{
			XQualitySetting.SetQuality(value, false);
			XQualitySetting.PostSetQuality();
			XQualitySetting.PostSetting();
		}

		private void _ProcessBlockOtherPlayers(int value)
		{
			bool flag = XSingleton<XGame>.singleton.CurrentStage != null && XSingleton<XGame>.singleton.CurrentStage.Stage == EXStage.Hall;
			if (flag)
			{
				XSingleton<XEntityMgr>.singleton.ToggleOtherPlayers(value == 1);
			}
		}

		protected override void OnReconnected(XReconnectedEventArgs arg)
		{
			this.InitServerConfig(arg.PlayerInfo.config);
		}

		private bool OnChatVoiceHandled(XEventArgs e)
		{
			XAudioOperationArgs xaudioOperationArgs = e as XAudioOperationArgs;
			bool isAudioOn = xaudioOperationArgs.IsAudioOn;
			if (isAudioOn)
			{
				float volume = 1f;
				XApolloDocument specificDocument = XDocuments.GetSpecificDocument<XApolloDocument>(XApolloDocument.uuID);
				bool flag = specificDocument != null;
				if (flag)
				{
					bool isRealtimeVoiceOn = specificDocument.IsRealtimeVoiceOn;
					if (isRealtimeVoiceOn)
					{
						volume = (float)XSingleton<XGlobalConfig>.singleton.GetInt("SetMusicVol") / 100f;
					}
				}
				XSingleton<XAudioMgr>.singleton.SetBusStatuMute("bus:/MainGroupControl", volume);
			}
			else
			{
				XSingleton<XAudioMgr>.singleton.SetBusStatuMute("bus:/MainGroupControl", 0f);
			}
			return true;
		}

		public void SetBGMVolme(float vol)
		{
			this.bgmVolme = Mathf.Clamp01(vol);
			XSingleton<XAudioMgr>.singleton.SetBGMVolme(this.bgmVolme);
		}

		public void SetMuscVolme(float vol)
		{
			this.mscVolme = Mathf.Clamp01(vol);
			XSingleton<XAudioMgr>.singleton.SetMscVolme(this.mscVolme);
		}

		public void SetVoiceVolme(float vol)
		{
			this.voiceVolme = vol;
		}

		public string GetConfigurationDefault(XOptionsDefine option)
		{
			XOptionsDocument.OptionData optionData;
			bool flag = XOptionsDocument.optionsDefault.TryGetValue(option, out optionData);
			string result;
			if (flag)
			{
				int num = optionData.NeedSight ? this.GetValue(XOptionsDefine.OD_VIEW) : 1;
				bool flag2 = optionData.NeedProfession[num - 1];
				int num2;
				if (flag2)
				{
					bool flag3 = XSingleton<XAttributeMgr>.singleton.XPlayerData == null;
					if (flag3)
					{
						return null;
					}
					num2 = XFastEnumIntEqualityComparer<RoleType>.ToInt(XSingleton<XAttributeMgr>.singleton.XPlayerData.Profession) % 10;
				}
				else
				{
					num2 = 1;
				}
				result = optionData.val[num - 1, num2 - 1];
			}
			else
			{
				result = null;
			}
			return result;
		}

		public bool SetBattleOptionValue()
		{
			XSingleton<XDebug>.singleton.AddGreenLog("__RefreshBattleOptionValue", null, null, null, null, null);
			XOperationMode value = (XOperationMode)this.GetValue(XOptionsDefine.OD_VIEW);
			XSingleton<XOperationData>.singleton.OperationMode = value;
			XSingleton<XInput>.singleton.UpdateDefaultCameraOperationByScene();
			bool flag = value == XOperationMode.X25D;
			if (flag)
			{
				XSingleton<XOperationData>.singleton.TailCameraSpeed = (int)this.GetFloatValue(XOptionsDefine.OD_TailCameraSpeed25D);
				XSingleton<XOperationData>.singleton.ManualCameraSpeedXInBattle = this.GetFloatValue(XOptionsDefine.OD_ManualCameraSpeedXInBattle25D);
			}
			else
			{
				bool flag2 = value == XOperationMode.X3D;
				if (flag2)
				{
					XSingleton<XOperationData>.singleton.TailCameraSpeed = (int)this.GetFloatValue(XOptionsDefine.OD_TailCameraSpeed3D);
					XSingleton<XOperationData>.singleton.ManualCameraSpeedXInBattle = this.GetFloatValue(XOptionsDefine.OD_ManualCameraSpeedXInBattle3D);
					bool flag3 = XSingleton<XGame>.singleton.CurrentStage.Stage != EXStage.Hall;
					if (flag3)
					{
						XSingleton<XOperationData>.singleton.AllowVertical = (this.GetValue(XOptionsDefine.OD_Vertical3D) == 1);
					}
				}
				else
				{
					bool flag4 = value == XOperationMode.X3D_Free;
					if (flag4)
					{
						XSingleton<XOperationData>.singleton.TailCameraSpeed = (int)this.GetFloatValue(XOptionsDefine.OD_TailCameraSpeed3DFree);
						XSingleton<XOperationData>.singleton.ManualCameraSpeedXInBattle = this.GetFloatValue(XOptionsDefine.OD_ManualCameraSpeedXInBattle3DFree);
						bool flag5 = XSingleton<XGame>.singleton.CurrentStage.Stage != EXStage.Hall;
						if (flag5)
						{
							XSingleton<XOperationData>.singleton.AllowVertical = (this.GetValue(XOptionsDefine.OD_Vertical3DFree) == 1);
						}
						XSingleton<XOperationData>.singleton.CameraDistance = this.GetFloatValue(XOptionsDefine.OD_Distance3DFree);
					}
				}
			}
			XOperateMode value2 = (XOperateMode)this.GetValue(XOptionsDefine.OD_OPERATE);
			int num = this.GetValue(XOptionsDefine.OD_OPERATE) - 1;
			XSingleton<XOperationData>.singleton.ManualCameraSpeedXInHall = this.GetFloatValue(XOptionsDefine.ManualCameraSpeedXInHallAutoLock + num);
			XSingleton<XOperationData>.singleton.ManualCameraDampXInHall = this.GetFloatValue(XOptionsDefine.ManualCameraDampXInHallAutoLock + num);
			XSingleton<XOperationData>.singleton.ManualCameraSpeedYInHall = this.GetFloatValue(XOptionsDefine.ManualCameraSpeedYInHallAutoLock + num);
			XSingleton<XOperationData>.singleton.ManualCameraDampYInHall = this.GetFloatValue(XOptionsDefine.ManualCameraDampYInHallAutoLock + num);
			XSingleton<XOperationData>.singleton.ManualCameraDampXInBattle = this.GetFloatValue(XOptionsDefine.ManualCameraDampXInBattleAutoLock + num);
			XSingleton<XOperationData>.singleton.ManualCameraSpeedYInBattle = this.GetFloatValue(XOptionsDefine.ManualCameraSpeedYInBattleAutoLock + num);
			XSingleton<XOperationData>.singleton.ManualCameraDampYInBattle = this.GetFloatValue(XOptionsDefine.ManualCameraDampYInBattleAutoLock + num);
			XSingleton<XOperationData>.singleton.RangeWeight = (int)this.GetFloatValue(XOptionsDefine.RangeWeightAutoLock + num);
			XSingleton<XOperationData>.singleton.BossWeight = (int)this.GetFloatValue(XOptionsDefine.BossWeightAutoLock + num);
			XSingleton<XOperationData>.singleton.EliteWeight = (int)this.GetFloatValue(XOptionsDefine.EliteWeightAutoLock + num);
			XSingleton<XOperationData>.singleton.EnemyWeight = (int)this.GetFloatValue(XOptionsDefine.EnemyWeightAutoLock + num);
			XSingleton<XOperationData>.singleton.PupetWeight = (int)this.GetFloatValue(XOptionsDefine.PupetWeightAutoLock + num);
			XSingleton<XOperationData>.singleton.RoleWeight = (int)this.GetFloatValue(XOptionsDefine.RoleWeightAutoLock + num);
			XSingleton<XOperationData>.singleton.ImmortalWeight = (int)this.GetFloatValue(XOptionsDefine.ImmortalWeightAutoLock + num);
			XSingleton<XOperationData>.singleton.WithinScope = this.GetFloatValue(XOptionsDefine.WithinScopeAutoLock + num);
			XSingleton<XOperationData>.singleton.WithinRange = this.GetFloatValue(XOptionsDefine.WithinRangeAutoLock + num);
			XSingleton<XOperationData>.singleton.AssistAngle = this.GetFloatValue(XOptionsDefine.AssistAngleAutoLock + num);
			XSingleton<XOperationData>.singleton.ProfRange = this.GetFloatValue(XOptionsDefine.ProfRangeAutoLock + num);
			XSingleton<XOperationData>.singleton.ProfRangeLong = this.GetFloatValue(XOptionsDefine.ProfRangeLongAutoLock + num);
			XSingleton<XOperationData>.singleton.ProfRangeAll = this.GetFloatValue(XOptionsDefine.ProfRangeAllAutoLock + num);
			XSingleton<XOperationData>.singleton.ProfScope = (int)this.GetFloatValue(XOptionsDefine.ProfScopeAutoLock + num);
			XSingleton<XOperationData>.singleton.CameraAdjustScope = (int)this.GetFloatValue(XOptionsDefine.CameraAdjustScopeAutoLock + num);
			XSingleton<XInput>.singleton.UpdateOperationMode();
			XBattleSkillDocument specificDocument = XDocuments.GetSpecificDocument<XBattleSkillDocument>(XBattleSkillDocument.uuID);
			bool flag6 = specificDocument.BattleView != null && specificDocument.BattleView.IsVisible();
			if (flag6)
			{
				specificDocument.BattleView.OnSetOptionsValue();
			}
			return true;
		}
	}
}