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.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using JetBrains.Annotations;
using Jotunn;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using TranslationsHelper.models;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("FixItFelix.TranslationsHelper")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("FixItFelix.TranslationsHelper")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e3243d22-4307-4008-ba36-9f326008cde5")]
[assembly: AssemblyFileVersion("1.1.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace TranslationsHelper
{
	public static class TranslationsPrinter
	{
		private static readonly string OutputPath = Path.Combine(Paths.BepInExRootPath, "TranslationsPrinterOutput");

		private const string FileSuffix = ".English.yml";

		public static void WriteData(string prefabNamePrefixFilter)
		{
			string prefabNamePrefixFilter2 = prefabNamePrefixFilter;
			IEnumerable<KeyValuePair<string, List<string>>> enumerable;
			if (!(prefabNamePrefixFilter2 == ""))
			{
				enumerable = TranslationsRegistry.ModPrefabTranslations.Where<KeyValuePair<string, List<string>>>((KeyValuePair<string, List<string>> pair) => pair.Key.StartsWith(prefabNamePrefixFilter2));
			}
			else
			{
				IEnumerable<KeyValuePair<string, List<string>>> modPrefabTranslations = TranslationsRegistry.ModPrefabTranslations;
				enumerable = modPrefabTranslations;
			}
			foreach (KeyValuePair<string, List<string>> item in enumerable)
			{
				if (item.Value.Count > 0)
				{
					string filPath = Path.Combine(OutputPath, item.Key + ".English.yml");
					WriteFile((from line in item.Value.Where((string line) => line != "").Distinct()
						orderby line
						select line).ToList(), filPath);
				}
				else
				{
					Logger.LogWarning((object)("mod '" + item.Key + "' does not contain any prefabs for translation"));
				}
			}
		}

		private static void WriteFile(List<string> translations, string filPath)
		{
			if (!Directory.Exists(OutputPath))
			{
				Directory.CreateDirectory(OutputPath);
			}
			File.WriteAllText(filPath, string.Join("\n", translations));
			Logger.LogInfo((object)$"wrote {translations.Count} translations to file '{filPath}'");
		}
	}
	[BepInPlugin("FixItFelix.TranslationsHelper", "TranslationsHelper", "1.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class TranslationsHelperPlugin : BaseUnityPlugin
	{
		private const string PluginAuthor = "FixItFelix";

		private const string PluginName = "TranslationsHelper";

		internal const string PluginVersion = "1.1.0";

		internal const string PluginGuid = "FixItFelix.TranslationsHelper";

		private void Awake()
		{
			ModQuery.Enable();
			PrefabManager.OnPrefabsRegistered += TranslationsRegistry.Initialize;
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new TranslationsPrinterController());
		}
	}
	public class TranslationsPrinterController : ConsoleCommand
	{
		public override string Name => "print_translations_to_file";

		public override string Help => "Write all prefabs loaded in-game into a YAML translations template file inside the BepInEx config folder 'TranslationsPrinterOutput'.";

		public override void Run(string[] args)
		{
			if (args.Length != 0)
			{
				Logger.LogInfo((object)("TranslationsPrinterController called with args '" + string.Join(" - ", args) + "'"));
				TranslationsPrinter.WriteData(args[0]);
			}
			else
			{
				TranslationsPrinter.WriteData("");
			}
		}
	}
	public static class TranslationsRegistry
	{
		public static readonly Dictionary<string, List<string>> ModPrefabTranslations = new Dictionary<string, List<string>>();

		public static void Initialize()
		{
			Logger.LogInfo((object)"scanning loaded prefabs for translations");
			foreach (KeyValuePair<string, List<string>> item in (from pair in ModQuery.GetPrefabs()
				group pair by pair.SourceMod.Name).ToDictionary((IGrouping<string, IModPrefab> group) => group.Key, (IGrouping<string, IModPrefab> group) => group.SelectMany(GetPrefabTranslations).ToList()))
			{
				Logger.LogInfo((object)$"adding {item.Value.Count} translation strings for mod {item.Key}");
				ModPrefabTranslations.Add(item.Key, item.Value);
			}
		}

		private static List<string> GetPrefabTranslations(IModPrefab prefab)
		{
			List<string> list = new List<string>();
			if ((Object)(object)prefab.Prefab == (Object)null)
			{
				return list;
			}
			Logger.LogInfo((object)("scanning prefab '" + ((Object)prefab.Prefab).name + "' for translation"));
			ItemDrop fromItemDrop = default(ItemDrop);
			if (prefab.Prefab.TryGetComponent<ItemDrop>(ref fromItemDrop))
			{
				list.AddRange(new CommonModel(fromItemDrop).Translate());
			}
			Piece fromPiece = default(Piece);
			if (prefab.Prefab.TryGetComponent<Piece>(ref fromPiece))
			{
				list.AddRange(new CommonModel(fromPiece).Translate());
			}
			Character fromCharacter = default(Character);
			if (prefab.Prefab.TryGetComponent<Character>(ref fromCharacter))
			{
				list.AddRange(new NameModel(fromCharacter).Translate());
			}
			Beehive original = default(Beehive);
			if (prefab.Prefab.TryGetComponent<Beehive>(ref original))
			{
				list.AddRange(new BeehiveModel(original).Translate());
			}
			CookingStation original2 = default(CookingStation);
			if (prefab.Prefab.TryGetComponent<CookingStation>(ref original2))
			{
				list.AddRange(new CookingStationModel(original2).Translate());
			}
			Fermenter original3 = default(Fermenter);
			if (prefab.Prefab.TryGetComponent<Fermenter>(ref original3))
			{
				list.AddRange(new FermenterModel(original3).Translate());
			}
			Smelter original4 = default(Smelter);
			if (prefab.Prefab.TryGetComponent<Smelter>(ref original4))
			{
				list.AddRange(new SmelterModel(original4).Translate());
			}
			Incinerator original5 = default(Incinerator);
			if (prefab.Prefab.TryGetComponent<Incinerator>(ref original5))
			{
				list.AddRange(new IncineratorModel(original5).Translate());
			}
			MapTable original6 = default(MapTable);
			if (prefab.Prefab.TryGetComponent<MapTable>(ref original6))
			{
				list.AddRange(new MapTableModel(original6).Translate());
			}
			OfferingBowl original7 = default(OfferingBowl);
			if (prefab.Prefab.TryGetComponent<OfferingBowl>(ref original7))
			{
				list.AddRange(new OfferingBowlModel(original7).Translate());
			}
			SapCollector original8 = default(SapCollector);
			if (prefab.Prefab.TryGetComponent<SapCollector>(ref original8))
			{
				list.AddRange(new SapCollectorModel(original8).Translate());
			}
			MineRock fromMineRock = default(MineRock);
			if (prefab.Prefab.TryGetComponent<MineRock>(ref fromMineRock))
			{
				list.AddRange(new NameModel(fromMineRock).Translate());
			}
			MineRock5 fromMineRock2 = default(MineRock5);
			if (prefab.Prefab.TryGetComponent<MineRock5>(ref fromMineRock2))
			{
				list.AddRange(new NameModel(fromMineRock2).Translate());
			}
			ItemStand fromItemStand = default(ItemStand);
			if (prefab.Prefab.TryGetComponent<ItemStand>(ref fromItemStand))
			{
				list.AddRange(new NameModel(fromItemStand).Translate());
			}
			Ladder fromLadder = default(Ladder);
			if (prefab.Prefab.TryGetComponent<Ladder>(ref fromLadder))
			{
				list.AddRange(new NameModel(fromLadder).Translate());
			}
			Plant fromPlant = default(Plant);
			if (prefab.Prefab.TryGetComponent<Plant>(ref fromPlant))
			{
				list.AddRange(new NameModel(fromPlant).Translate());
			}
			RuneStone original9 = default(RuneStone);
			if (prefab.Prefab.TryGetComponent<RuneStone>(ref original9))
			{
				list.AddRange(new RuneStoneModel(original9).Translate());
			}
			ShipControlls original10 = default(ShipControlls);
			if (prefab.Prefab.TryGetComponent<ShipControlls>(ref original10))
			{
				list.AddRange(new ShipControlModel(original10).Translate());
			}
			Teleport original11 = default(Teleport);
			if (prefab.Prefab.TryGetComponent<Teleport>(ref original11))
			{
				list.AddRange(new TeleportModel(original11).Translate());
			}
			Switch original12 = default(Switch);
			if (prefab.Prefab.TryGetComponent<Switch>(ref original12))
			{
				list.AddRange(new SwitchModel(original12).Translate());
			}
			ToggleSwitch original13 = default(ToggleSwitch);
			if (prefab.Prefab.TryGetComponent<ToggleSwitch>(ref original13))
			{
				list.AddRange(new SwitchModel(original13).Translate());
			}
			HoverText fromHoverText = default(HoverText);
			if (prefab.Prefab.TryGetComponent<HoverText>(ref fromHoverText))
			{
				list.AddRange(new NameModel(fromHoverText).Translate());
			}
			return list;
		}
	}
}
namespace TranslationsHelper.models
{
	public class BeehiveModel : NameModel
	{
		[UsedImplicitly]
		public readonly string AreaTextToken;

		[UsedImplicitly]
		public readonly string BlockedTextToken;

		[UsedImplicitly]
		public readonly string CheckTextToken;

		[UsedImplicitly]
		public readonly string ExtractTextToken;

		[UsedImplicitly]
		public readonly string FreeSpaceTextToken;

		[UsedImplicitly]
		public readonly string HappyTextToken;

		[UsedImplicitly]
		public readonly string NotConnectedTextToken;

		[UsedImplicitly]
		public readonly string SleepTextToken;

		public BeehiveModel(Beehive original)
			: base(((Object)original).name, original.m_name)
		{
			AreaTextToken = original.m_areaText;
			BlockedTextToken = original.m_blockedText;
			CheckTextToken = original.m_checkText;
			ExtractTextToken = original.m_extractText;
			FreeSpaceTextToken = original.m_freespaceText;
			HappyTextToken = original.m_happyText;
			NotConnectedTextToken = original.m_notConnectedText;
			SleepTextToken = original.m_sleepText;
		}

		public override List<string> Translate()
		{
			List<string> list = base.Translate();
			list.AddRange(new List<string>
			{
				TranslateTokenToPair(TranslationNameToken),
				TranslateTokenToPair(AreaTextToken),
				TranslateTokenToPair(BlockedTextToken),
				TranslateTokenToPair(CheckTextToken),
				TranslateTokenToPair(ExtractTextToken),
				TranslateTokenToPair(FreeSpaceTextToken),
				TranslateTokenToPair(HappyTextToken),
				TranslateTokenToPair(NotConnectedTextToken),
				TranslateTokenToPair(SleepTextToken)
			});
			return list;
		}
	}
	public class CommonModel : NameModel
	{
		[UsedImplicitly]
		public readonly string TranslationDescriptionToken;

		public CommonModel(ItemDrop fromItemDrop)
			: base(((Object)fromItemDrop).name, fromItemDrop.m_itemData.m_shared.m_name)
		{
			TranslationDescriptionToken = fromItemDrop.m_itemData.m_shared.m_description;
		}

		public CommonModel(Piece fromPiece)
			: base(((Object)fromPiece).name, fromPiece.m_name)
		{
			TranslationDescriptionToken = fromPiece.m_description;
		}

		public override List<string> Translate()
		{
			return new List<string>
			{
				TranslateTokenToPair(TranslationNameToken),
				TranslateTokenToPair(TranslationDescriptionToken)
			};
		}
	}
	public class CookingStationModel : NameModel
	{
		[UsedImplicitly]
		public readonly SwitchModel AddFoodSwitch;

		[UsedImplicitly]
		public readonly SwitchModel AddFuelSwitch;

		[UsedImplicitly]
		public readonly string AddItemTooltipToken;

		public CookingStationModel(CookingStation original)
			: base(((Object)original).name, original.m_name)
		{
			AddFoodSwitch = new SwitchModel(original.m_addFoodSwitch);
			AddFuelSwitch = new SwitchModel(original.m_addFuelSwitch);
			AddItemTooltipToken = original.m_addItemTooltip;
		}

		public override List<string> Translate()
		{
			List<string> list = new List<string>();
			list.Add(TranslateTokenToPair(TranslationNameToken));
			list.Add(TranslateTokenToPair(AddItemTooltipToken));
			list.AddRange(AddFoodSwitch.Translate());
			list.AddRange(AddFuelSwitch.Translate());
			return list;
		}
	}
	public class FermenterModel : NameModel
	{
		[UsedImplicitly]
		public readonly SwitchModel AddSwitch;

		[UsedImplicitly]
		public readonly SwitchModel TapSwitch;

		public FermenterModel(Fermenter original)
			: base(((Object)original).name, original.m_name)
		{
			AddSwitch = new SwitchModel(original.m_addSwitch);
			TapSwitch = new SwitchModel(original.m_tapSwitch);
		}

		public override List<string> Translate()
		{
			List<string> list = base.Translate();
			list.AddRange(AddSwitch.Translate());
			list.AddRange(TapSwitch.Translate());
			return list;
		}
	}
	public class IncineratorModel : Translatable
	{
		[UsedImplicitly]
		public readonly string Name;

		[UsedImplicitly]
		public readonly SwitchModel IncinerateSwitch;

		public IncineratorModel(Incinerator original)
		{
			Name = ((Object)original).name;
			IncinerateSwitch = new SwitchModel(original.m_incinerateSwitch);
		}

		public override List<string> Translate()
		{
			return IncinerateSwitch.Translate();
		}
	}
	public class MapTableModel : NameModel
	{
		[UsedImplicitly]
		public readonly SwitchModel ReadSwitch;

		[UsedImplicitly]
		public readonly SwitchModel WriteSwitch;

		public MapTableModel(MapTable original)
			: base(((Object)original).name, original.m_name)
		{
			ReadSwitch = new SwitchModel(original.m_readSwitch);
			WriteSwitch = new SwitchModel(original.m_writeSwitch);
		}

		public override List<string> Translate()
		{
			return base.Translate();
		}
	}
	public class NameModel : Translatable
	{
		[UsedImplicitly]
		public readonly string Name;

		[UsedImplicitly]
		public readonly string TranslationNameToken;

		public NameModel(string internalName, string nameToken)
		{
			Name = internalName;
			TranslationNameToken = nameToken;
		}

		public NameModel(Character fromCharacter)
			: this(((Object)fromCharacter).name, fromCharacter.m_name)
		{
		}

		public NameModel(HoverText fromHoverText)
			: this(((Object)fromHoverText).name, fromHoverText.m_text)
		{
		}

		public NameModel(MineRock fromMineRock)
			: this(((Object)fromMineRock).name, fromMineRock.m_name)
		{
		}

		public NameModel(MineRock5 fromMineRock5)
			: this(((Object)fromMineRock5).name, fromMineRock5.m_name)
		{
		}

		public NameModel(ItemStand fromItemStand)
			: this(((Object)fromItemStand).name, fromItemStand.m_name)
		{
		}

		public NameModel(Ladder fromLadder)
			: this(((Object)fromLadder).name, fromLadder.m_name)
		{
		}

		public NameModel(Plant fromPlant)
			: this(((Object)fromPlant).name, fromPlant.m_name)
		{
		}

		public NameModel(Chair fromChair)
			: this(((Object)fromChair).name, fromChair.m_name)
		{
		}

		public override List<string> Translate()
		{
			return new List<string> { TranslateTokenToPair(TranslationNameToken) };
		}
	}
	public class OfferingBowlModel : NameModel
	{
		[UsedImplicitly]
		public readonly string UseItemTextToken;

		public OfferingBowlModel(OfferingBowl original)
			: base(((Object)original).name, original.m_name)
		{
			UseItemTextToken = original.m_useItemText;
		}

		public override List<string> Translate()
		{
			List<string> list = base.Translate();
			list.Add(TranslateTokenToPair(UseItemTextToken));
			return list;
		}
	}
	public class RuneStoneModel : NameModel
	{
		[UsedImplicitly]
		public readonly string TextToken;

		[UsedImplicitly]
		public readonly string TopicToken;

		[UsedImplicitly]
		public readonly string LabelToken;

		public RuneStoneModel(RuneStone original)
			: base(((Object)original).name, original.m_name)
		{
			TextToken = original.m_text;
			TopicToken = original.m_topic;
			LabelToken = original.m_label;
		}

		public override List<string> Translate()
		{
			List<string> list = base.Translate();
			list.AddRange(new List<string>
			{
				TranslateTokenToPair(TextToken),
				TranslateTokenToPair(TopicToken),
				TranslateTokenToPair(LabelToken)
			});
			return list;
		}
	}
	public class SapCollectorModel : NameModel
	{
		[UsedImplicitly]
		public readonly string DrainingSlowTextToken;

		[UsedImplicitly]
		public readonly string DrainingTextToken;

		[UsedImplicitly]
		public readonly string ExtractTextToken;

		[UsedImplicitly]
		public readonly string FullTextToken;

		[UsedImplicitly]
		public readonly string NotConnectedTextToken;

		public SapCollectorModel(SapCollector original)
			: base(((Object)original).name, original.m_name)
		{
			DrainingSlowTextToken = original.m_drainingSlowText;
			DrainingTextToken = original.m_drainingText;
			ExtractTextToken = original.m_extractText;
			FullTextToken = original.m_fullText;
			NotConnectedTextToken = original.m_notConnectedText;
		}

		public override List<string> Translate()
		{
			List<string> list = base.Translate();
			list.AddRange(new List<string>
			{
				TranslateTokenToPair(DrainingTextToken),
				TranslateTokenToPair(DrainingSlowTextToken),
				TranslateTokenToPair(ExtractTextToken),
				TranslateTokenToPair(FullTextToken),
				TranslateTokenToPair(NotConnectedTextToken)
			});
			return list;
		}
	}
	public class ShipControlModel : Translatable
	{
		[UsedImplicitly]
		public readonly string Name;

		[UsedImplicitly]
		public readonly string HoverText;

		public ShipControlModel(ShipControlls original)
		{
			Name = ((Object)original).name;
			HoverText = original.m_hoverText;
		}

		public override List<string> Translate()
		{
			return new List<string> { TranslateTokenToPair(HoverText) };
		}
	}
	public class SmelterModel : NameModel
	{
		[UsedImplicitly]
		public readonly SwitchModel AddOreSwitch;

		[UsedImplicitly]
		public readonly string AddOreTooltipToken;

		[UsedImplicitly]
		public readonly SwitchModel AddWoodSwitch;

		[UsedImplicitly]
		public readonly SwitchModel EmptyOreSwitch;

		[UsedImplicitly]
		public readonly string EmptyOreTooltipToken;

		public SmelterModel(Smelter original)
			: base(((Object)original).name, original.m_name)
		{
			AddOreSwitch = new SwitchModel(original.m_addOreSwitch);
			AddOreTooltipToken = original.m_addOreTooltip;
			AddWoodSwitch = new SwitchModel(original.m_addWoodSwitch);
			EmptyOreSwitch = new SwitchModel(original.m_emptyOreSwitch);
			EmptyOreTooltipToken = original.m_emptyOreTooltip;
		}

		public override List<string> Translate()
		{
			List<string> list = base.Translate();
			list.AddRange(new List<string>
			{
				TranslateTokenToPair(AddOreTooltipToken),
				TranslateTokenToPair(EmptyOreTooltipToken)
			});
			list.AddRange(AddWoodSwitch.Translate());
			list.AddRange(EmptyOreSwitch.Translate());
			return list;
		}
	}
	public class SwitchModel : NameModel
	{
		[UsedImplicitly]
		public readonly string HoverTextToken;

		public SwitchModel(Switch? original)
			: base(((original != null) ? ((Object)original).name : null) ?? string.Empty, original?.m_name ?? string.Empty)
		{
			HoverTextToken = original?.m_hoverText ?? string.Empty;
		}

		public SwitchModel(ToggleSwitch original)
			: base(((Object)original).name, original.m_name)
		{
			HoverTextToken = original.m_hoverText;
		}

		public override List<string> Translate()
		{
			return new List<string>
			{
				TranslateTokenToPair(TranslationNameToken),
				TranslateTokenToPair(HoverTextToken)
			};
		}
	}
	public class TeleportModel : Translatable
	{
		[UsedImplicitly]
		public readonly string Name;

		[UsedImplicitly]
		public readonly string HoverText;

		[UsedImplicitly]
		public readonly string EnterText;

		public TeleportModel(Teleport original)
		{
			Name = ((Object)original).name;
			HoverText = original.m_hoverText;
			EnterText = original.m_enterText;
		}

		public override List<string> Translate()
		{
			return new List<string>
			{
				TranslateTokenToPair(HoverText),
				TranslateTokenToPair(EnterText)
			};
		}
	}
	public abstract class Translatable
	{
		public abstract List<string> Translate();

		protected string TranslateTokenToPair(string token)
		{
			Regex regex = new Regex("[^a-zA-Z0-9_$]");
			Regex regex2 = new Regex("[^a-zA-Z0-9_]");
			string text = regex.Replace(token, "");
			string text2 = regex2.Replace(text, "");
			if (text == "")
			{
				return "";
			}
			return text2 + ": \"" + Localization.instance.Localize(text) + "\"";
		}
	}
	public class VegvisirModel : NameModel
	{
		[UsedImplicitly]
		public readonly string HoverName;

		[UsedImplicitly]
		public readonly string UseText;

		public VegvisirModel(Vegvisir original)
			: base(((Object)original).name, original.m_name)
		{
			HoverName = original.m_hoverName;
			UseText = original.m_useText;
		}

		public override List<string> Translate()
		{
			List<string> list = base.Translate();
			list.AddRange(new List<string>
			{
				TranslateTokenToPair(HoverName),
				TranslateTokenToPair(UseText)
			});
			return list;
		}
	}
}