// WPFMA-SDK needs Unity 2022.3 (VRChat's version); on older Unity this file is skipped and WPFMAUnityVersionNotice explains why.
#if UNITY_2022_3_OR_NEWER
using System.IO;
using System.Linq;
using UnityEditor;
using UnityEngine;

namespace WPFMA
{
    [InitializeOnLoad]
    internal static class WPFMAPackageInstaller
    {
        private const string QHierarchyPackage = "Assets/WPFMA-SDK/Import/QHierarchy v4.4.unitypackage";
        private const string PackageSourcesPath = "Assets/WPFMA-SDK/PackageSources";
        private const string VpmCacheFolderName = "VPM";
        private const string InstallVersion = "WPFMA.QHierarchy.4.4.Installed";
        private const string PackageSourcesInstalledKey = "WPFMA.BundledPackageSourcesInstalled";

        static WPFMAPackageInstaller()
        {
            EditorApplication.delayCall += InstallBundledPackages;
        }

        private static void InstallBundledPackages()
        {
            if (SessionState.GetBool(PackageSourcesInstalledKey, false))
                return;
            SessionState.SetBool(PackageSourcesInstalledKey, true);

            InstallBundledPackageSources();

            if (!SessionState.GetBool(InstallVersion, false) && File.Exists(QHierarchyPackage) &&
                !Directory.Exists("Assets/QHierarchy"))
            {
                SessionState.SetBool(InstallVersion, true);
                AssetDatabase.ImportPackage(QHierarchyPackage, false);
                Debug.Log("WPFMA-SDK imported QHierarchy 4.4.");
            }
        }

        private static void InstallBundledPackageSources()
        {
            if (!Directory.Exists(PackageSourcesPath))
                return;

            RemoveInvalidVpmDependency();
            foreach (var source in Directory.GetDirectories(PackageSourcesPath))
            {
                var packageName = Path.GetFileName(source);
                if (string.Equals(packageName, VpmCacheFolderName, System.StringComparison.OrdinalIgnoreCase))
                    continue;

                var destination = Path.Combine("Packages", packageName);
                CopyDirectory(source, destination);
                EnsureManifestDependency(packageName);
            }

            AssetDatabase.Refresh();
        }

        private static void RemoveInvalidVpmDependency()
        {
            const string invalidDependency = "    \"VPM\": \"file:VPM\",";
            var manifestPath = "Packages/manifest.json";
            if (!File.Exists(manifestPath))
                return;

            var manifest = File.ReadAllText(manifestPath);
            var cleanedManifest = manifest
                .Replace(invalidDependency + "\r\n", string.Empty)
                .Replace(invalidDependency + "\n", string.Empty)
                .Replace(invalidDependency, string.Empty);
            if (cleanedManifest != manifest)
                File.WriteAllText(manifestPath, cleanedManifest);
        }

        private static void CopyDirectory(string source, string destination)
        {
            Directory.CreateDirectory(destination);
            foreach (var file in Directory.GetFiles(source))
                File.Copy(file, Path.Combine(destination, Path.GetFileName(file)), true);

            foreach (var directory in Directory.GetDirectories(source))
                CopyDirectory(directory, Path.Combine(destination, Path.GetFileName(directory)));
        }

        private static void EnsureManifestDependency(string packageName)
        {
            var manifestPath = "Packages/manifest.json";
            if (!File.Exists(manifestPath))
                return;

            var manifest = File.ReadAllText(manifestPath);
            manifest = RemoveStaleManifestDependency(manifest, packageName);
            if (manifest.Contains("\"" + packageName + "\":"))
                return;

            var version = ReadInstalledPackageVersion(packageName);
            if (string.IsNullOrEmpty(version))
                return;

            var dependency = "    \"" + packageName + "\": \"" + version + "\",\n";
            var dependenciesMarker = "  \"dependencies\": {\n";
            manifest = manifest.Replace(dependenciesMarker, dependenciesMarker + dependency);
            File.WriteAllText(manifestPath, manifest);
        }

        private static string RemoveStaleManifestDependency(string manifest, string packageName)
        {
            if (string.IsNullOrEmpty(manifest))
                return manifest;

            var pattern = "\\s*\"" + System.Text.RegularExpressions.Regex.Escape(packageName) + "\"\\s*:\\s*\"(?:file:)?" + System.Text.RegularExpressions.Regex.Escape(packageName) + "\"\\s*,?\\r?\\n?";
            return System.Text.RegularExpressions.Regex.Replace(manifest, pattern, "", System.Text.RegularExpressions.RegexOptions.IgnoreCase);
        }

        private static string ReadInstalledPackageVersion(string packageName)
        {
            var packageJsonPath = Path.Combine("Packages", packageName, "package.json");
            if (!File.Exists(packageJsonPath))
                return null;

            var text = File.ReadAllText(packageJsonPath);
            var match = System.Text.RegularExpressions.Regex.Match(text, "\"version\"\\s*:\\s*\"([^\"]+)\"");
            return match.Success ? match.Groups[1].Value : null;
        }
    }
}
#endif
