using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[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("MUCK-Archipelago")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Muck for Archipelago")]
[assembly: AssemblyTitle("MUCK-Archipelago")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 ARCHIPELAGO
{
	[BepInPlugin("MUCK-Archipelago", "Muck for Archipelago", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		public static Plugin Instance;

		public GameState previousState;

		public Dictionary<string, int> givenPowerups;

		public Harmony harmony = new Harmony("MUCK-Archipelago");

		private async void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Plugin MUCK-Archipelago is loaded!");
			Logger.LogInfo((object)"It's muckin' time");
			harmony.PatchAll();
			if (!File.Exists("ARCHIPELAGO_Powerups.itmlst"))
			{
				Logger.LogInfo((object)"Creatinng ARCHIPELAGO_Powerups.itmlst");
				File.WriteAllText("ARCHIPELAGO_Powerups.itmlst", "Broccoli,0\r\nDumbbell,0\r\nJetpack,0\r\nOrange Juice,0\r\nPeanut Butter,0\r\nBlue Pill,0\r\nRed Pill,0\r\nSneaker,0\r\nRobin Hood Hat,0\r\nSpooo Bean,0\r\nBulldozer,0\r\nHorseshoe,0\r\nDanis Milk,0\r\nPiggybank,0\r\nCrimson Dagger,0\r\nDracula,0\r\nJanniks Frog,0\r\nJuice,0\r\nAdrenaline,0\r\nBerserk,0\r\nCheckered Shirt,0\r\nSniper Scope,0\r\nKnuts Hammer,0\r\nWings of Glory,0\r\nEnforcer,0\r\n");
			}
			if (!File.Exists("ARCHIPELAGO_Locations.lctlst"))
			{
				Logger.LogInfo((object)"Creatinng ARCHIPELAGO_Locations.lctlst");
				File.WriteAllText("ARCHIPELAGO_Locations.lctlst", "PowerupWhite,0\r\nPowerupBlue,0\r\nPowerupOrange,0\r\n");
			}
			Instance = this;
			resetGivenPowerups();
		}

		public void Update()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Invalid comparison between Unknown and I4
			if ((int)previousState == 0 && (int)GameManager.state == 1)
			{
				atGameStart();
			}
			if ((int)GameManager.state == 1)
			{
				try
				{
					updateGivenPowerups(getPowerupsDict());
				}
				catch
				{
				}
			}
			previousState = GameManager.state;
		}

		public void atGameStart()
		{
			resetGivenPowerups();
			updateGivenPowerups(getPowerupsDict());
		}

		public void forceGivePowerup(int powerupId, int count)
		{
			FieldInfo field = ((object)PowerupInventory.Instance).GetType().GetField("powerups", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			int[] array = (int[])field.GetValue(PowerupInventory.Instance);
			array[powerupId] += count;
			field.SetValue(PowerupInventory.Instance, array);
			UiEvents.Instance.AddPowerup(ItemManager.Instance.allPowerups[powerupId]);
			for (int i = 0; i < count; i++)
			{
				PowerupUI.Instance.AddPowerup(powerupId);
			}
		}

		public bool isGamePlaying()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			return (int)GameManager.state == 1;
		}

		public bool isPlayerDead()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			return (int)GameManager.state == 2;
		}

		public void printPowerupList()
		{
			foreach (KeyValuePair<string, int> item in ItemManager.Instance.stringToPowerupId)
			{
				Logger.LogInfo((object)$"name : {item.Key}, id : {item.Value}");
			}
		}

		public Dictionary<string, int> getPowerupsDict()
		{
			string str = File.ReadAllText("ARCHIPELAGO_Powerups.itmlst");
			return strToDict(str);
		}

		public void resetGivenPowerups()
		{
			Logger.LogInfo((object)"Powerup Dict Reset");
			givenPowerups = new Dictionary<string, int>
			{
				{ "Broccoli", 0 },
				{ "Dumbbell", 0 },
				{ "Jetpack", 0 },
				{ "Orange Juice", 0 },
				{ "Peanut Butter", 0 },
				{ "Blue Pill", 0 },
				{ "Red Pill", 0 },
				{ "Sneaker", 0 },
				{ "Robin Hood Hat", 0 },
				{ "Spooo Bean", 0 },
				{ "Bulldozer", 0 },
				{ "Horseshoe", 0 },
				{ "Danis Milk", 0 },
				{ "Piggybank", 0 },
				{ "Crimson Dagger", 0 },
				{ "Dracula", 0 },
				{ "Janniks Frog", 0 },
				{ "Juice", 0 },
				{ "Adrenaline", 0 },
				{ "Berserk", 0 },
				{ "Checkered Shirt", 0 },
				{ "Sniper Scope", 0 },
				{ "Knuts Hammer", 0 },
				{ "Wings of Glory", 0 },
				{ "Enforcer", 0 }
			};
		}

		public void sendLocation(string locationName)
		{
			Dictionary<string, int> dictionary = strToDict(File.ReadAllText("ARCHIPELAGO_Locations.lctlst"));
			dictionary[locationName]++;
			Logger.LogInfo((object)dictToStr(dictionary));
			File.WriteAllText("ARCHIPELAGO_Locations.lctlst", dictToStr(dictionary));
		}

		public static Dictionary<string, int> strToDict(string str)
		{
			string[] array = str.Split(new string[2]
			{
				Environment.NewLine,
				"\n"
			}, StringSplitOptions.None);
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			string[] array2 = array;
			foreach (string text in array2)
			{
				string[] array3 = text.Split(",".ToCharArray());
				dictionary.Add(array3[0], int.Parse(array3[1]));
			}
			return dictionary;
		}

		public static string dictToStr(Dictionary<string, int> dict)
		{
			string text = "";
			bool flag = true;
			foreach (KeyValuePair<string, int> item in dict)
			{
				if (flag)
				{
					text += $"{item.Key},{item.Value}";
					flag = false;
				}
				else
				{
					text += $"\n{item.Key},{item.Value}";
				}
			}
			return text;
		}

		public void updateGivenPowerups(Dictionary<string, int> powerupsToHave)
		{
			foreach (KeyValuePair<string, int> item in powerupsToHave)
			{
				if (item.Value > givenPowerups[item.Key])
				{
					int num = item.Value - givenPowerups[item.Key];
					Logger.LogInfo((object)(item.Key + " : " + num));
					forceGivePowerup(ItemManager.Instance.stringToPowerupId[item.Key], num);
					givenPowerups[item.Key] += num;
				}
			}
		}

		public void win()
		{
			File.WriteAllText("victory", "Bob defeated");
		}
	}
	[HarmonyPatch(typeof(PowerupInventory))]
	[HarmonyPatch("AddPowerup")]
	internal class PatcherAddPowerup
	{
		private static bool Prefix(string name, int powerupId, int objectId)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Invalid comparison between Unknown and I4
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Invalid comparison between Unknown and I4
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Invalid comparison between Unknown and I4
			Vector3 position = ItemManager.Instance.list[objectId].transform.position;
			ParticleSystem component = Object.Instantiate<GameObject>(PowerupInventory.Instance.powerupFx, position, Quaternion.identity).GetComponent<ParticleSystem>();
			MainModule main = component.main;
			((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(ItemManager.Instance.allPowerups[powerupId].GetOutlineColor());
			if ((int)ItemManager.Instance.allPowerups[powerupId].tier == 2)
			{
				((Component)component).gameObject.GetComponent<RandomSfx>().sounds = (AudioClip[])(object)new AudioClip[1] { PowerupInventory.Instance.goodPowerupSfx };
				((Component)component).GetComponent<RandomSfx>().Randomize(0f);
			}
			if ((int)ItemManager.Instance.allPowerups[powerupId].tier == 0)
			{
				Plugin.Instance.sendLocation("PowerupWhite");
			}
			else if ((int)ItemManager.Instance.allPowerups[powerupId].tier == 1)
			{
				Plugin.Instance.sendLocation("PowerupBlue");
			}
			else if ((int)ItemManager.Instance.allPowerups[powerupId].tier == 2)
			{
				Plugin.Instance.sendLocation("PowerupOrange");
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(ServerSend))]
	[HarmonyPatch("GameOver")]
	internal class PatcherGameOver
	{
		private static bool Prefix(int winnerId = -2)
		{
			if (winnerId == -3)
			{
				Plugin.Instance.win();
			}
			return true;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "MUCK-Archipelago";

		public const string PLUGIN_NAME = "Muck for Archipelago";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}