using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Logging;
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.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("MapInstaller")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+41dac237b6879bddb8198a3e00d04e82f3f72c6c")]
[assembly: AssemblyProduct("MapInstaller")]
[assembly: AssemblyTitle("MapInstaller")]
[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 MapInstaller
{
	internal class Installer
	{
		private static char _S = Path.DirectorySeparatorChar;

		private static string GAME_PATH = Path.GetDirectoryName(Application.dataPath);

		private static string BEPINEX_PATH = Path.Combine(GAME_PATH, $"BepInEx{_S}plugins");

		private static string MAPS_PATH = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), $"AppData{_S}LocalLow{_S}Colossal Order{_S}Cities Skylines II{_S}Maps");

		private static string THUNDERSTORE_PATH = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), $"AppData{_S}Roaming{_S}Thunderstore Mod Manager{_S}DataFolder{_S}CitiesSkylines2{_S}profiles");

		private static string RMODMAN_PATH = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), $"AppData{_S}Roaming{_S}r2modmanPlus-local{_S}CitiesSkylines2{_S}profiles");

		private static List<Action> _currentActions = new List<Action>();

		private static ManualLogSource _logger;

		private static bool _hasErrors = false;

		internal Installer(ManualLogSource logger)
		{
			_logger = logger;
		}

		private void ScanDirectory()
		{
			try
			{
				if (Directory.Exists(BEPINEX_PATH))
				{
					_logger.LogInfo((object)"Scanning BepInEx folder...");
					ProcessSource(BEPINEX_PATH);
				}
				string activeThunderstoreProfile = GetActiveThunderstoreProfile();
				if (!string.IsNullOrEmpty(activeThunderstoreProfile))
				{
					_logger.LogInfo((object)("Scanning Thunderstore folder '" + activeThunderstoreProfile + "'..."));
					ProcessSource(activeThunderstoreProfile);
				}
				string activeRModManProfile = GetActiveRModManProfile();
				if (!string.IsNullOrEmpty(activeRModManProfile))
				{
					_logger.LogInfo((object)("Scanning rModMan folder '" + activeRModManProfile + "'..."));
					ProcessSource(activeRModManProfile);
				}
				if (_currentActions.Count == 0)
				{
					OnComplete();
					_logger.LogInfo((object)"No changes detected!");
				}
			}
			catch (Exception ex)
			{
				HandleException(ex);
			}
		}

		private string GetActiveProfile(string path)
		{
			if (!Directory.Exists(path))
			{
				return null;
			}
			DateTime dateTime = DateTime.MinValue;
			string result = string.Empty;
			string[] directories = Directory.GetDirectories(path);
			foreach (string path2 in directories)
			{
				string text = Path.Combine(path2, $"BepInEx{_S}plugins");
				if (Directory.Exists(text))
				{
					DateTime mostRecentModifiedDate = GetMostRecentModifiedDate(text);
					if (mostRecentModifiedDate > dateTime)
					{
						dateTime = mostRecentModifiedDate;
						result = text;
					}
				}
			}
			return result;
		}

		private string GetActiveThunderstoreProfile()
		{
			return GetActiveProfile(THUNDERSTORE_PATH);
		}

		private string GetActiveRModManProfile()
		{
			if (Directory.Exists(RMODMAN_PATH))
			{
				return GetActiveProfile(RMODMAN_PATH);
			}
			string environmentVariable = Environment.GetEnvironmentVariable("DOORSTOP_INVOKE_DLL_PATH");
			string directoryName = Path.GetDirectoryName(environmentVariable);
			string fullPath = Path.GetFullPath(Path.Combine(directoryName, "..", "..", ".."));
			return GetActiveProfile(fullPath);
		}

		public DateTime GetMostRecentModifiedDate(string directory)
		{
			return (from file in Directory.GetFiles(directory, "*", SearchOption.AllDirectories)
				select new FileInfo(file).LastWriteTime into date
				orderby date descending
				select date).FirstOrDefault();
		}

		private void ProcessSource(string sourceDirectory)
		{
			string[] directories = Directory.GetDirectories(sourceDirectory);
			foreach (string directory in directories)
			{
				ProcessDirectory(sourceDirectory, directory);
			}
			string[] files = Directory.GetFiles(sourceDirectory, "*.zip", SearchOption.AllDirectories);
			foreach (string zipFilePath in files)
			{
				ProcessZipFile(sourceDirectory, zipFilePath);
			}
		}

		private void EnsureMapsFolder()
		{
			try
			{
				Directory.CreateDirectory(MAPS_PATH);
			}
			catch (Exception ex)
			{
				HandleException(ex);
			}
		}

		private void ProcessDirectory(string sourceDirectory, string directory)
		{
			if (CheckDirectoryForMaps(directory, out var outputFolder) && FolderHasChanges(outputFolder, MAPS_PATH))
			{
				string relativePath = Path.GetRelativePath(sourceDirectory, outputFolder);
				_logger.LogInfo((object)("Detected changes at '" + relativePath + "', queuing for copy..."));
				_currentActions.Add(GenerateDirectoryCopyTask(sourceDirectory, outputFolder));
			}
		}

		private bool CheckDirectoryForMaps(string directory, out string outputFolder)
		{
			outputFolder = null;
			string text = Path.Combine(directory, "Maps");
			if (Directory.Exists(text))
			{
				outputFolder = text;
				return true;
			}
			string[] files = Directory.GetFiles(directory, "*.cok.cid");
			if (files.Length == 0)
			{
				return false;
			}
			string[] array = files;
			foreach (string path in array)
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(path);
				string path2 = Path.Combine(Path.GetDirectoryName(path), fileNameWithoutExtension);
				if (File.Exists(path2))
				{
					outputFolder = directory;
					return true;
				}
			}
			return false;
		}

		private void ProcessZipFile(string sourceDirectory, string zipFilePath)
		{
			string relativePath = Path.GetRelativePath(sourceDirectory, zipFilePath);
			if (ZipFileHasChanges(zipFilePath, MAPS_PATH))
			{
				_logger.LogInfo((object)("Detected changes in map ZIP '" + relativePath + "', queuing for copy..."));
				_currentActions.Add(GenerateZipCopyTask(sourceDirectory, zipFilePath));
			}
		}

		private void CopyFile(string file, string targetFolder)
		{
			try
			{
				string fileName = Path.GetFileName(file);
				string destFileName = Path.Combine(targetFolder, fileName);
				File.Copy(file, destFileName, overwrite: true);
			}
			catch (Exception ex)
			{
				HandleException(ex);
			}
		}

		private bool FolderHasChanges(string sourceFolder, string targetFolder)
		{
			string[] files = Directory.GetFiles(sourceFolder, "*.cok.cid");
			string[] files2 = Directory.GetFiles(sourceFolder, "*.cok");
			if (files.Length == 0 || files2.Length == 0)
			{
				return false;
			}
			List<string> list = files.ToList();
			list.AddRange(files2);
			foreach (string item in list)
			{
				string fileName = Path.GetFileName(item);
				string text = Path.Combine(targetFolder, fileName);
				if (!File.Exists(text))
				{
					return true;
				}
				if (GetFileHash(item) != GetFileHash(text))
				{
					return true;
				}
			}
			return false;
		}

		private bool ZipFileHasChanges(string zipFilePath, string targetFolder)
		{
			using (ZipArchive zipArchive = ZipFile.OpenRead(zipFilePath))
			{
				foreach (ZipArchiveEntry entry in zipArchive.Entries)
				{
					if (!entry.FullName.EndsWith("/") && entry.FullName.ToLowerInvariant().Contains("maps/") && entry.FullName.ToLowerInvariant().EndsWith(".cok") && !entry.FullName.ToLowerInvariant().EndsWith(".cok.cid"))
					{
						string text = SanitiseZipEntryPath(Path.GetFileName(entry.FullName), MAPS_PATH);
						if (!File.Exists(text))
						{
							return true;
						}
						if (GetZipEntryHash(entry) != GetFileHash(text))
						{
							return true;
						}
					}
				}
			}
			return false;
		}

		private string GetHash(Stream stream)
		{
			using MD5 mD = MD5.Create();
			byte[] array = mD.ComputeHash(stream);
			return BitConverter.ToString(array).Replace("-", "").ToLowerInvariant();
		}

		private string GetFileHash(string file)
		{
			using FileStream stream = File.OpenRead(file);
			return GetHash(stream);
		}

		private string GetZipEntryHash(ZipArchiveEntry entry)
		{
			using Stream stream = entry.Open();
			return GetHash(stream);
		}

		private string SanitiseZipEntryPath(string entryFullName, string targetDirectory)
		{
			string fullPath = Path.GetFullPath(Path.Combine(targetDirectory, entryFullName));
			if (!fullPath.StartsWith(targetDirectory, StringComparison.OrdinalIgnoreCase))
			{
				throw new SecurityException("Attempted to extract a file outside of the target directory.");
			}
			return fullPath;
		}

		private Action GenerateDirectoryCopyTask(string sourceFolder, string copyFolder)
		{
			return delegate
			{
				try
				{
					string relativePath = Path.GetRelativePath(sourceFolder, copyFolder);
					string[] files = Directory.GetFiles(copyFolder, "*.cok.cid");
					string[] files2 = Directory.GetFiles(copyFolder, "*.cok");
					if (files.Length != 0 || files2.Length != 0)
					{
						List<string> list = files.ToList();
						list.AddRange(files2);
						_logger.LogInfo((object)$"Copying '{list.Count}' from '{relativePath}'.");
						int num = 0;
						int num2 = 0;
						foreach (string item in list)
						{
							if (num % 10 == 0)
							{
								_logger.LogInfo((object)$"Copying file {num2 + 1}/{list.Count}...");
							}
							CopyFile(item, MAPS_PATH);
							num2++;
							num = (int)((decimal)num2 / (decimal)list.Count * 100m);
						}
						_logger.LogInfo((object)("Finished copying '" + relativePath + "'."));
					}
				}
				catch (Exception ex)
				{
					HandleException(ex);
				}
			};
		}

		private Action GenerateZipCopyTask(string sourceDirectory, string zipFilePath)
		{
			return delegate
			{
				try
				{
					string relativePath = Path.GetRelativePath(sourceDirectory, zipFilePath);
					_logger.LogInfo((object)("Processing zip file '" + relativePath + "'."));
					using (ZipArchive zipArchive = ZipFile.OpenRead(zipFilePath))
					{
						List<ZipArchiveEntry> list = zipArchive.Entries.Where((ZipArchiveEntry entry) => entry.FullName.ToLower().Contains("maps/") && (entry.FullName.ToLowerInvariant().EndsWith(".cok") || entry.FullName.ToLowerInvariant().EndsWith(".cok.cid"))).ToList();
						int count = list.Count;
						if (count == 0)
						{
							return;
						}
						_logger.LogInfo((object)$"Extracting '{count}' files from '{relativePath}'.");
						int num = 0;
						foreach (ZipArchiveEntry item in list)
						{
							string text = SanitiseZipEntryPath(Path.GetFileName(item.FullName), MAPS_PATH);
							Directory.CreateDirectory(Path.GetDirectoryName(text));
							item.ExtractToFile(text, overwrite: true);
							num++;
							int num2 = (int)((decimal)num / (decimal)count * 100m);
							if (num2 % 10 == 0)
							{
								_logger.LogInfo((object)$"Extracting file {num + 1}/{count}...");
							}
						}
					}
					_logger.LogInfo((object)("Finished processing zip file '" + relativePath + "'."));
				}
				catch (Exception ex)
				{
					HandleException(ex);
				}
			};
		}

		private void RunActions()
		{
			if (_currentActions.Count == 0)
			{
				OnComplete();
				return;
			}
			Task.Run(delegate
			{
				foreach (Action currentAction in _currentActions)
				{
					currentAction();
				}
				OnComplete();
			});
		}

		private void Clear()
		{
			_currentActions.Clear();
		}

		private void HandleException(Exception ex)
		{
			if (ex is IOException || ex is UnauthorizedAccessException || ex is SecurityException || ex is InvalidDataException || ex is FileNotFoundException)
			{
				_logger.LogError((object)ex);
				_hasErrors = true;
				return;
			}
			throw ex;
		}

		private void CheckForErrors()
		{
			if (_hasErrors)
			{
				_logger.LogInfo((object)"Map installer encountered errors trying to copy maps, for support please visit the Cities2Modding discord referencing the error.");
				_logger.LogInfo((object)"See BepInEx log file at: 'BepInEx\\plugins' folder.");
			}
		}

		private void OnComplete()
		{
			CheckForErrors();
			Clear();
		}

		public void Run()
		{
			EnsureMapsFolder();
			ScanDirectory();
			RunActions();
		}
	}
	[BepInPlugin("MapInstaller", "MapInstaller", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		private void Awake()
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"=================================================================");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"MapInstaller by Cities2Modding community.");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"=================================================================");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Reddit link: https://www.reddit.com/r/cities2modding/");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Discord link: https://discord.gg/KGRNBbm5Fh");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Our mods are officially distributed via Thunderstore.io and https://github.com/Cities2Modding");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Example mod repository and modding info: https://github.com/optimus-code/Cities2Modding");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Thanks to Captain_Of_Coit, 89pleasure, Rebecca, optimus-code and the Cites2Modding community!");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"=================================================================");
			new Installer(((BaseUnityPlugin)this).Logger).Run();
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "MapInstaller";

		public const string PLUGIN_NAME = "MapInstaller";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}