using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using WECCL.Utils;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("BookerWinrateTracker")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BookerWinrateTracker")]
[assembly: AssemblyTitle("BookerWinrateTracker")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BookerWinrateTracker
{
	[BepInPlugin("GeeEm.WrestlingEmpire.BookerWinrateTracker", "BookerWinrateTracker", "1.0.6")]
	[HarmonyPatch]
	public class Plugin : BaseUnityPlugin
	{
		public class CharacterWinrate
		{
			public IndividualTypesWinrate Special { get; set; }

			public IndividualTypesWinrate Singles { get; set; }

			public IndividualTypesWinrate Team { get; set; }

			public CharacterWinrate()
			{
				Special = new IndividualTypesWinrate();
				Singles = new IndividualTypesWinrate();
				Team = new IndividualTypesWinrate();
			}

			public int GetTotalWins()
			{
				return Special.Wins + Singles.Wins + Team.Wins;
			}

			public int GetTotalDraws()
			{
				return Special.Draws + Singles.Draws + Team.Draws;
			}

			public int GetTotalLoses()
			{
				return Special.Loses + Singles.Loses + Team.Loses;
			}
		}

		public class IndividualTypesWinrate
		{
			public int Wins = 0;

			public int Draws = 0;

			public int Loses = 0;
		}

		public const string PluginGuid = "GeeEm.WrestlingEmpire.BookerWinrateTracker";

		public const string PluginName = "BookerWinrateTracker";

		public const string PluginVer = "1.0.6";

		internal static ManualLogSource Log;

		internal static readonly Harmony Harmony = new Harmony("GeeEm.WrestlingEmpire.BookerWinrateTracker");

		internal static string PluginPath;

		public static GameObject WinRate;

		public static GameObject RateText;

		public static List<int> winners = new List<int>();

		public static List<int> losers = new List<int>();

		public static List<int> draws = new List<int>();

		public static bool readytosave = false;

		public static Dictionary<int, CharacterWinrate> Winrates;

		public static ConfigEntry<bool> AdvancedDisplay;

		public static ConfigEntry<bool> SkipConfrontations;

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			PluginPath = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			Winrates = new Dictionary<int, CharacterWinrate>();
			AdvancedDisplay = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "AdvancedDisplay", false, "Separate the winrate display into individual types (singles, teams, special)");
			SkipConfrontations = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "SkipConfrontations", false, "Ignore and don't track confrontation type matches");
		}

		private void OnEnable()
		{
			try
			{
				Harmony.PatchAll();
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Loaded BookerWinrateTracker!");
			}
			catch (Exception ex)
			{
				Log.LogError((object)"An error was found! Winrate trackers now require WECCL, make sure you have it too! Error:");
				Log.LogError((object)ex);
				((Behaviour)this).enabled = false;
			}
		}

		private void OnDisable()
		{
			Harmony.UnpatchSelf();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Unloaded BookerWinrateTracker!");
		}

		public static void SaveWinrateToFile()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			using StreamWriter streamWriter = File.CreateText(Path.Combine(Paths.ConfigPath, "BookerWinrates.json"));
			JsonSerializer val = new JsonSerializer();
			val.Serialize((TextWriter)streamWriter, (object)Winrates);
		}

		public static void LoadWinrateFromFile()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			try
			{
				if (!File.Exists(Path.Combine(Paths.ConfigPath, "BookerWinrates.json")))
				{
					return;
				}
				using StreamReader streamReader = File.OpenText(Path.Combine(Paths.ConfigPath, "BookerWinrates.json"));
				JsonSerializer val = new JsonSerializer();
				Winrates = (Dictionary<int, CharacterWinrate>)val.Deserialize((TextReader)streamReader, typeof(Dictionary<int, CharacterWinrate>));
				if (Winrates == null)
				{
					Debug.LogError((object)"Failed to load the winrates for an unknown reason.");
					Winrates = new Dictionary<int, CharacterWinrate>();
				}
			}
			catch (Exception ex)
			{
				Log.LogError((object)"An error has occured while trying to load the winrates from a file. Character winrates will be reset.");
				Log.LogError((object)ex);
				Winrates = new Dictionary<int, CharacterWinrate>();
			}
		}

		public static void ReloadCharacterWinrates()
		{
			if (Characters.booker == 0 || NAEEIFNFBBO.CBMHGKFFHJE != 2)
			{
				return;
			}
			LoadWinrateFromFile();
			foreach (KeyValuePair<int, CharacterWinrate> item in Winrates.ToList())
			{
				if (item.Key > Characters.no_chars)
				{
					Winrates.Remove(item.Key);
				}
				else if (Characters.c[item.Key].fed != Characters.c[Characters.booker].fed)
				{
					Winrates.Remove(item.Key);
				}
			}
			int[] roster = Characters.fedData[Characters.c[Characters.booker].fed].roster;
			foreach (int num in roster)
			{
				if (num != 0 && Characters.c[num].fed == Characters.c[Characters.booker].fed && !Winrates.ContainsKey(num))
				{
					Winrates.Add(num, new CharacterWinrate());
				}
			}
			SaveWinrateToFile();
		}

		public static bool LoadWinrate(int id)
		{
			CharacterWinrate value;
			bool flag = Winrates.TryGetValue(id, out value);
			if (flag)
			{
				if (AdvancedDisplay.Value)
				{
					RateText.GetComponent<Text>().text = "S: " + value.Singles.Wins + "-" + value.Singles.Draws + "-" + value.Singles.Loses + "; T: " + value.Team.Wins + "-" + value.Team.Draws + "-" + value.Team.Loses + "; Sp: " + value.Special.Wins + "-" + value.Special.Draws + "-" + value.Special.Loses;
				}
				else
				{
					RateText.GetComponent<Text>().text = "W-D-L: " + value.GetTotalWins() + "-" + value.GetTotalDraws() + "-" + value.GetTotalLoses();
				}
			}
			return flag;
		}

		public static void SetUpGameObjects()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			WinRate = Object.Instantiate<GameObject>(((Component)Characters.gProfile.transform.Find("Header")).gameObject);
			foreach (Transform item in WinRate.transform)
			{
				Transform val = item;
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
			Object.Destroy((Object)(object)WinRate.GetComponent<Image>());
			WinRate.transform.SetParent(Characters.gProfile.transform);
			WinRate.transform.position = Characters.gProfile.transform.Find("Header").position;
			WinRate.transform.localScale = Characters.gProfile.transform.Find("Header").localScale;
			WinRate.transform.localPosition = new Vector3(WinRate.transform.localPosition.x, -130f, WinRate.transform.localPosition.z);
			RateText = Object.Instantiate<GameObject>(((Component)Characters.gProfile.transform.Find("Header/Name")).gameObject);
			RateText.transform.SetParent(WinRate.transform);
			RateText.GetComponent<Text>().text = "W-D-L: x-x-x";
			RateText.transform.localPosition = new Vector3(128f, 0f, 0f);
			RateText.transform.localScale = Characters.gProfile.transform.Find("Header/Name").localScale;
		}

		[HarmonyPatch(typeof(CharacterUtils), "DeleteCharacter")]
		[HarmonyPrefix]
		private static void BWinrate_UpdateOnDelete(int id)
		{
			LoadWinrateFromFile();
			if (Winrates.Count > 0)
			{
				if (Winrates.ContainsKey(id))
				{
					Winrates.Remove(id);
				}
				foreach (KeyValuePair<int, CharacterWinrate> item in Winrates.ToList())
				{
					if (id < item.Key)
					{
						int key = item.Key - 1;
						CharacterWinrate value = item.Value;
						Winrates.Remove(item.Key);
						Winrates.Add(key, value);
					}
				}
			}
			SaveWinrateToFile();
		}

		[HarmonyPatch(typeof(Scene_Select_Char), "Start")]
		[HarmonyPostfix]
		private static void Scene_Select_Char_Setup()
		{
			SetUpGameObjects();
			ReloadCharacterWinrates();
		}

		[HarmonyPatch(typeof(Scene_News), "Start")]
		[HarmonyPostfix]
		private static void Scene_News_Setup()
		{
			SetUpGameObjects();
			ReloadCharacterWinrates();
		}

		[HarmonyPatch(typeof(Scene_Select_Char), "Update")]
		[HarmonyPostfix]
		private static void Scene_Select_Char_Update()
		{
			if (Characters.booker == 0 || NAEEIFNFBBO.CBMHGKFFHJE != 2)
			{
				WinRate.SetActive(false);
			}
			else if (Characters.c[Characters.foc].fed == Characters.c[Characters.booker].fed)
			{
				WinRate.SetActive(true);
				if (!LoadWinrate(Characters.c[Characters.foc].id))
				{
					WinRate.SetActive(false);
				}
			}
			else
			{
				WinRate.SetActive(false);
			}
		}

		[HarmonyPatch(typeof(Scene_News), "Update")]
		[HarmonyPostfix]
		private static void Scene_News_Update()
		{
			if (Characters.booker == 0 || NAEEIFNFBBO.CBMHGKFFHJE != 2)
			{
				WinRate.SetActive(false);
			}
			else if (Characters.c[IMNHOCBFGHJ.OLMOLOOOIJM[IMNHOCBFGHJ.ODOAPLMOJPD].GOOKPABIPBC[1]].fed == Characters.c[Characters.booker].fed)
			{
				WinRate.SetActive(true);
				if (!LoadWinrate(Characters.c[IMNHOCBFGHJ.OLMOLOOOIJM[IMNHOCBFGHJ.ODOAPLMOJPD].GOOKPABIPBC[1]].id))
				{
					WinRate.SetActive(false);
				}
			}
			else
			{
				WinRate.SetActive(false);
			}
		}

		[HarmonyPatch(typeof(FFCEGMEAIBP), "BAGEPNPJPLD")]
		[HarmonyPostfix]
		private static void FFCEGMEAIBP_BAGEPNPJPLD_Postfix(int KJELLNJFNGO)
		{
			winners = new List<int>();
			draws = new List<int>();
			losers = new List<int>();
			if (NAEEIFNFBBO.CBMHGKFFHJE != 2 || (SkipConfrontations.Value && FFCEGMEAIBP.CBIPLGLDCAG == 1))
			{
				return;
			}
			if (FFCEGMEAIBP.OOODPHNGHGD == 0)
			{
				DFOGOCNBECG[] oAAMGFLINOB = NJBJIIIACEP.OAAMGFLINOB;
				foreach (DFOGOCNBECG val in oAAMGFLINOB)
				{
					if (val.FIEMGOLBHIO == 1)
					{
						draws.Add(val.GOOKPABIPBC);
					}
				}
				return;
			}
			DFOGOCNBECG[] oAAMGFLINOB2 = NJBJIIIACEP.OAAMGFLINOB;
			foreach (DFOGOCNBECG val2 in oAAMGFLINOB2)
			{
				if (val2.FIEMGOLBHIO != 1)
				{
					continue;
				}
				if (FFCEGMEAIBP.OLJFOJOLLOM > 0)
				{
					if (val2.LBCFAJGDKJP == NJBJIIIACEP.OAAMGFLINOB[KJELLNJFNGO].LBCFAJGDKJP)
					{
						winners.Add(val2.GOOKPABIPBC);
					}
					else
					{
						losers.Add(val2.GOOKPABIPBC);
					}
				}
				else if (val2 == NJBJIIIACEP.OAAMGFLINOB[KJELLNJFNGO])
				{
					winners.Add(val2.GOOKPABIPBC);
				}
				else
				{
					losers.Add(val2.GOOKPABIPBC);
				}
			}
		}

		[HarmonyPatch(typeof(LIPNHOMGGHF), "PMIIOCMHEAE")]
		[HarmonyPrefix]
		public static void LIPNHOMGGHF_PMIIOCMHEAE_Prefix()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (Characters.booker == 0 || NAEEIFNFBBO.CBMHGKFFHJE != 2)
			{
				return;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).name != "Game")
			{
				return;
			}
			ReloadCharacterWinrates();
			foreach (int winner in winners)
			{
				if (Winrates.ContainsKey(winner))
				{
					if (FFCEGMEAIBP.OLJFOJOLLOM > 0)
					{
						Winrates[winner].Team.Wins++;
					}
					else if (FFCEGMEAIBP.OLJFOJOLLOM == 0)
					{
						Winrates[winner].Singles.Wins++;
					}
					else if (FFCEGMEAIBP.OLJFOJOLLOM < 0)
					{
						Winrates[winner].Special.Wins++;
					}
				}
			}
			foreach (int draw in draws)
			{
				if (Winrates.ContainsKey(draw))
				{
					if (FFCEGMEAIBP.OLJFOJOLLOM > 0)
					{
						Winrates[draw].Team.Draws++;
					}
					else if (FFCEGMEAIBP.OLJFOJOLLOM == 0)
					{
						Winrates[draw].Singles.Draws++;
					}
					else if (FFCEGMEAIBP.OLJFOJOLLOM < 0)
					{
						Winrates[draw].Special.Draws++;
					}
				}
			}
			foreach (int loser in losers)
			{
				if (Winrates.ContainsKey(loser))
				{
					if (FFCEGMEAIBP.OLJFOJOLLOM > 0)
					{
						Winrates[loser].Team.Loses++;
					}
					else if (FFCEGMEAIBP.OLJFOJOLLOM == 0)
					{
						Winrates[loser].Singles.Loses++;
					}
					else if (FFCEGMEAIBP.OLJFOJOLLOM < 0)
					{
						Winrates[loser].Special.Loses++;
					}
				}
			}
			SaveWinrateToFile();
			winners = new List<int>();
			draws = new List<int>();
			losers = new List<int>();
		}
	}
}