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("CareerWinrateTracker")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("CareerWinrateTracker")]
[assembly: AssemblyTitle("CareerWinrateTracker")]
[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 CareerWinrateTracker
{
	[BepInPlugin("GeeEm.WrestlingEmpire.CareerWinrateTracker", "CareerWinrateTracker", "1.0.3")]
	[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.CareerWinrateTracker";

		public const string PluginName = "CareerWinrateTracker";

		public const string PluginVer = "1.0.3";

		internal static ManualLogSource Log;

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

		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;

		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)");
		}

		private void OnEnable()
		{
			try
			{
				Harmony.PatchAll();
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Loaded CareerWinrateTracker!");
			}
			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 CareerWinrateTracker!");
		}

		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, "CareerWinrates.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, "CareerWinrates.json")))
				{
					return;
				}
				using StreamReader streamReader = File.OpenText(Path.Combine(Paths.ConfigPath, "CareerWinrates.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 ReloadCharacterWinratesSingle()
		{
			if (Characters.wrestler == 0 || NAEEIFNFBBO.CBMHGKFFHJE != 1)
			{
				return;
			}
			LoadWinrateFromFile();
			if (!Winrates.ContainsKey(Characters.wrestler))
			{
				Winrates.Add(Characters.wrestler, new CharacterWinrate());
			}
			if (Winrates.Count > 1)
			{
				foreach (KeyValuePair<int, CharacterWinrate> item in Winrates.ToList())
				{
					if (item.Key != Characters.wrestler)
					{
						Winrates.Remove(item.Key);
					}
				}
			}
			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 CWinrate_UpdateOnDelete(int id)
		{
			ReloadCharacterWinratesSingle();
			if (Winrates.Count > 0 && id < Winrates.First().Key)
			{
				int key = Winrates.First().Key - 1;
				CharacterWinrate value = Winrates.First().Value;
				Winrates.Remove(Winrates.First().Key);
				Winrates.Add(key, value);
			}
			SaveWinrateToFile();
		}

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

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

		[HarmonyPatch(typeof(Scene_Calendar), "Start")]
		[HarmonyPostfix]
		private static void Scene_Calendar_Setup()
		{
			if (NAEEIFNFBBO.CBMHGKFFHJE == 1)
			{
				SetUpGameObjects();
				ReloadCharacterWinratesSingle();
			}
		}

		[HarmonyPatch(typeof(Scene_Calendar), "Update")]
		[HarmonyPostfix]
		private static void Scene_Calendar_Update()
		{
			if (NAEEIFNFBBO.CBMHGKFFHJE != 1)
			{
				return;
			}
			if (Characters.star == 0 || NAEEIFNFBBO.CBMHGKFFHJE != 1)
			{
				WinRate.SetActive(false);
			}
			else if (Characters.foc == Characters.star)
			{
				WinRate.SetActive(true);
				if (!LoadWinrate(Characters.c[Characters.foc].id))
				{
					WinRate.SetActive(false);
				}
			}
			else
			{
				WinRate.SetActive(false);
			}
		}

		[HarmonyPatch(typeof(Scene_Select_Char), "Update")]
		[HarmonyPostfix]
		private static void Scene_Select_Char_Update()
		{
			if (Characters.star == 0 || NAEEIFNFBBO.CBMHGKFFHJE != 1)
			{
				WinRate.SetActive(false);
			}
			else if (Characters.foc == Characters.star)
			{
				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.star == 0 || NAEEIFNFBBO.CBMHGKFFHJE != 1)
			{
				WinRate.SetActive(false);
			}
			else if (Characters.c[IMNHOCBFGHJ.OLMOLOOOIJM[IMNHOCBFGHJ.ODOAPLMOJPD].GOOKPABIPBC[1]].id == Characters.star)
			{
				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 != 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.star == 0 || NAEEIFNFBBO.CBMHGKFFHJE != 1)
			{
				return;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).name != "Game")
			{
				return;
			}
			ReloadCharacterWinratesSingle();
			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>();
		}
	}
}