// 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;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using UnityEditor;
using UnityEngine;
using UnityEngine.Networking;

namespace WPFMA
{
    internal sealed class WPFMAVpmPackage
    {
        public string Name;
        public string Version;
        public string DownloadUrl;
        public string CachePath;

        public bool IsCached => !string.IsNullOrEmpty(CachePath) && File.Exists(CachePath);
    }

    internal sealed class WPFMAVpmRepository
    {
        private const string CacheRoot = "Assets/WPFMA-SDK/Cached";
        private const string CacheManifestPath = CacheRoot + "/cache-manifest.json";
        private UnityWebRequest request;
        private Action<List<WPFMAVpmPackage>, string> fetchCallback;
        private Action<string, string> downloadCallback;

        public static List<WPFMAVpmPackage> LoadCachedPackages()
        {
            var result = new List<WPFMAVpmPackage>();
            try
            {
                if (!File.Exists(CacheManifestPath))
                    return result;

                var root = MiniJson.Deserialize(File.ReadAllText(CacheManifestPath)) as Dictionary<string, object>;
                var entries = root != null ? root["packages"] as List<object> : null;
                if (entries == null)
                    return result;

                foreach (var entryObject in entries)
                {
                    var entry = entryObject as Dictionary<string, object>;
                    if (entry == null)
                        continue;

                    var name = GetString(entry, "name");
                    var version = GetString(entry, "version");
                    var url = GetString(entry, "downloadUrl") ?? GetString(entry, "url");
                    var cachePath = GetString(entry, "cachePath");
                    if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(version))
                        continue;

                    if (string.IsNullOrEmpty(cachePath))
                        cachePath = Path.Combine(CacheRoot, Sanitize(name), Sanitize(name) + "-" + Sanitize(version) + ".zip");

                    var package = new WPFMAVpmPackage
                    {
                        Name = name,
                        Version = version,
                        DownloadUrl = url,
                        CachePath = cachePath
                    };

                    if (package.IsCached)
                        result.Add(package);
                }
            }
            catch
            {
                return result;
            }

            return result.OrderBy(package => package.Name, StringComparer.OrdinalIgnoreCase).ToList();
        }

        public static void SaveCachedPackage(WPFMAVpmPackage package)
        {
            if (package == null)
                return;

            Directory.CreateDirectory(CacheRoot);
            var packages = LoadCachedPackages();
            if (string.IsNullOrEmpty(package.CachePath))
                package.CachePath = Path.Combine(CacheRoot, Sanitize(package.Name), Sanitize(package.Name) + "-" + Sanitize(package.Version) + ".zip");

            var existingIndex = packages.FindIndex(item =>
                string.Equals(item.Name, package.Name, StringComparison.OrdinalIgnoreCase) &&
                string.Equals(item.Version, package.Version, StringComparison.OrdinalIgnoreCase));

            if (existingIndex >= 0)
                packages[existingIndex] = package;
            else
                packages.Add(package);

            WriteCacheManifest(packages);
        }

        public void Fetch(string repositoryUrl, Action<List<WPFMAVpmPackage>, string> callback)
        {
            Cancel();
            fetchCallback = callback;
            request = UnityWebRequest.Get(repositoryUrl.Trim());
            request.timeout = 30;
            request.SendWebRequest().completed += OnFetchCompleted;
        }

        public void Download(WPFMAVpmPackage package, Action<string, string> callback)
        {
            Cancel();
            if (package == null || string.IsNullOrEmpty(package.DownloadUrl))
            {
                callback(null, "The package has no downloadable archive URL.");
                return;
            }

            downloadCallback = callback;
            request = UnityWebRequest.Get(package.DownloadUrl);
            request.timeout = 120;
            request.downloadHandler = new DownloadHandlerBuffer();
            request.SendWebRequest().completed += operation =>
            {
                var activeRequest = request;
                request = null;
                if (activeRequest.result != UnityWebRequest.Result.Success)
                {
                    downloadCallback?.Invoke(null, activeRequest.error);
                    downloadCallback = null;
                    return;
                }

                try
                {
                    string packageFolder = Path.Combine(CacheRoot, Sanitize(package.Name));
                    Directory.CreateDirectory(packageFolder);
                    string cachePath = Path.Combine(packageFolder, Sanitize(package.Name) + "-" + Sanitize(package.Version) + ".zip");
                    File.WriteAllBytes(cachePath, activeRequest.downloadHandler.data);
                    package.CachePath = cachePath;
                    SaveCachedPackage(package);
                    AssetDatabase.Refresh();
                    downloadCallback?.Invoke(cachePath, null);
                }
                catch (Exception exception)
                {
                    downloadCallback?.Invoke(null, exception.Message);
                }
                finally
                {
                    downloadCallback = null;
                    activeRequest.Dispose();
                }
            };
        }

        public static void Install(WPFMAVpmPackage package)
        {
            Install(package, new HashSet<string>(StringComparer.OrdinalIgnoreCase));
        }

        private static void Install(WPFMAVpmPackage package, HashSet<string> visited)
        {
            if (package == null)
                throw new InvalidOperationException("The package is null.");
            if (!package.IsCached)
                throw new InvalidOperationException("Cache this package before installing it.");

            if (!visited.Add(package.Name))
                return;

            string packagesRoot = Path.GetFullPath("Packages");
            string packagePath = Path.Combine(packagesRoot, Sanitize(package.Name));
            string stagingPath = Path.Combine(packagesRoot, ".lc-sdk-vpm-" + Sanitize(package.Name));
            if (Directory.Exists(stagingPath))
                Directory.Delete(stagingPath, true);

            using (var archive = ZipFile.OpenRead(package.CachePath))
            {
                if (archive.GetEntry("package.json") == null)
                    throw new InvalidDataException("The archive does not contain package.json at its root.");
            }

            ZipFile.ExtractToDirectory(package.CachePath, stagingPath);
            var extractedPackageJson = Path.Combine(stagingPath, "package.json");
            if (!File.Exists(extractedPackageJson))
                throw new InvalidDataException("The archive did not extract a package.json file.");

            var installedDeps = ParseDependencyNames(extractedPackageJson);
            InstallLegacyPackageFamily(stagingPath, extractedPackageJson);

            if (Directory.Exists(packagePath))
            {
                try
                {
                    Directory.Delete(packagePath, true);
                }
                catch (IOException exception)
                {
                    TryDelete(stagingPath);
                    throw new IOException("'" + package.Name + "' is already installed and Unity is holding its " +
                                          "files open, so it cannot be replaced. Close Unity, delete " +
                                          packagePath + ", then reopen and install again.\n\n" + exception.Message,
                        exception);
                }
                catch (UnauthorizedAccessException exception)
                {
                    TryDelete(stagingPath);
                    throw new UnauthorizedAccessException("'" + package.Name + "' could not be replaced because a " +
                                                          "file in " + packagePath + " is read-only or in use.\n\n" +
                                                          exception.Message, exception);
                }
            }

            Directory.Move(stagingPath, packagePath);
            PatchVrcfuryBadInstallDetector(packagePath);

            EnsureManifestDependency(package.Name, ResolveManifestVersionHint(package.Name));
            foreach (var dependency in installedDeps)
            {
                if (string.Equals(dependency, package.Name, StringComparison.OrdinalIgnoreCase))
                    continue;

                var dependencyPath = Path.Combine(packagesRoot, Sanitize(dependency));
                if (Directory.Exists(dependencyPath))
                {
                    EnsureManifestDependency(dependency, ResolveManifestVersionHint(dependency));
                    continue;
                }

                var dependencyPackage = FindCachedDependency(dependency);
                if (dependencyPackage != null)
                {
                    Install(dependencyPackage, visited);
                    continue;
                }

                var locallyCachedPackages = LoadCachedPackages();
                var localDependencyPackage = locallyCachedPackages.FirstOrDefault(candidate =>
                    string.Equals(candidate.Name, dependency, StringComparison.OrdinalIgnoreCase));

                if (localDependencyPackage != null)
                {
                    Install(localDependencyPackage, visited);
                    continue;
                }

                EnsureManifestDependency(dependency, ResolveManifestVersionHint(dependency));
            }

            AssetDatabase.Refresh();
        }

        private static void TryDelete(string path)
        {
            try
            {
                if (Directory.Exists(path))
                    Directory.Delete(path, true);
            }
            catch (Exception)
            {
            }
        }

        public void Cancel()
        {
            if (request == null)
                return;

            request.Abort();
            request.Dispose();
            request = null;
        }

        private void OnFetchCompleted(AsyncOperation operation)
        {
            var activeRequest = request;
            request = null;
            if (activeRequest.result != UnityWebRequest.Result.Success)
            {
                fetchCallback?.Invoke(null, activeRequest.error);
                fetchCallback = null;
                activeRequest.Dispose();
                return;
            }

            try
            {
                fetchCallback?.Invoke(ParsePackages(activeRequest.downloadHandler.text), null);
            }
            catch (Exception exception)
            {
                fetchCallback?.Invoke(null, exception.Message);
            }
            finally
            {
                fetchCallback = null;
                activeRequest.Dispose();
            }
        }

        private static List<WPFMAVpmPackage> ParsePackages(string json)
        {
            try
            {
                var root = MiniJson.Deserialize(json) as Dictionary<string, object>;
                if (root == null)
                    throw new InvalidDataException("The repository response is not valid JSON.");

                var packageGroups = root["packages"] as Dictionary<string, object>;
                if (packageGroups == null)
                    throw new InvalidDataException("The repository response has no packages object.");

                var result = new List<WPFMAVpmPackage>();
                foreach (var packageEntry in packageGroups)
                {
                    var packageData = packageEntry.Value as Dictionary<string, object>;
                    if (packageData == null)
                        continue;

                    var versions = packageData["versions"] as Dictionary<string, object>;
                    if (versions == null)
                        continue;

                    Dictionary<string, object> newest = null;
                    string newestVersion = null;
                    foreach (var version in versions)
                    {
                        var versionMetadata = version.Value as Dictionary<string, object>;
                        if (versionMetadata == null)
                            continue;

                        var candidateUrl = GetString(versionMetadata, "url") ?? GetString(versionMetadata, "downloadUrl");
                        if (string.IsNullOrEmpty(candidateUrl))
                            continue;

                        var candidateVersion = GetString(versionMetadata, "version") ?? version.Key;
                        if (newest == null || CompareVersions(candidateVersion, newestVersion) > 0)
                        {
                            newest = versionMetadata;
                            newestVersion = candidateVersion;
                        }
                    }

                    if (newest == null)
                        continue;

                    var url = GetString(newest, "url") ?? GetString(newest, "downloadUrl");
                    if (string.IsNullOrEmpty(url))
                        continue;

                    result.Add(new WPFMAVpmPackage
                    {
                        Name = GetString(newest, "name") ?? packageEntry.Key,
                        Version = GetString(newest, "version") ?? newestVersion,
                        DownloadUrl = url
                    });
                }

                result.Sort((left, right) => string.Compare(left.Name, right.Name, StringComparison.OrdinalIgnoreCase));
                return result;
            }
            catch
            {
                return ParsePackagesLoose(json);
            }
        }

        private static List<WPFMAVpmPackage> ParsePackagesLoose(string json)
        {
            var result = new List<WPFMAVpmPackage>();
            if (string.IsNullOrWhiteSpace(json))
                return result;

            string packagesObject = ExtractObject(json, "packages");
            if (string.IsNullOrEmpty(packagesObject))
                return result;

            var packageMatches = Regex.Matches(packagesObject, "\"((?:\\\\.|[^\\\"])*)\"\\s*:\\s*\\{");
            foreach (Match packageMatch in packageMatches)
            {
                var packageName = UnescapeJsonString(packageMatch.Groups[1].Value);
                if (string.IsNullOrEmpty(packageName))
                    continue;

                int packageObjectStart = packagesObject.IndexOf('{', packageMatch.Index);
                if (packageObjectStart < 0)
                    continue;

                int packageObjectEnd = FindMatchingBrace(packagesObject, packageObjectStart);
                if (packageObjectEnd < packageObjectStart)
                    continue;

                string packageObject = packagesObject.Substring(packageObjectStart + 1, packageObjectEnd - packageObjectStart - 1);
                string versionsObject = ExtractObject(packageObject, "versions");
                if (string.IsNullOrEmpty(versionsObject))
                    continue;

                string newestUrl = null;
                string newestVersion = null;
                var versionMatches = Regex.Matches(versionsObject, "\"((?:\\\\.|[^\\\"])*)\"\\s*:\\s*\\{");
                foreach (Match versionMatch in versionMatches)
                {
                    var versionKey = UnescapeJsonString(versionMatch.Groups[1].Value);
                    int versionObjectStart = versionsObject.IndexOf('{', versionMatch.Index);
                    if (versionObjectStart < 0)
                        continue;

                    int versionObjectEnd = FindMatchingBrace(versionsObject, versionObjectStart);
                    if (versionObjectEnd < versionObjectStart)
                        continue;

                    string versionObject = versionsObject.Substring(versionObjectStart + 1, versionObjectEnd - versionObjectStart - 1);
                    string url = MatchJsonStringValue(versionObject, "url") ?? MatchJsonStringValue(versionObject, "downloadUrl");
                    if (string.IsNullOrEmpty(url))
                        continue;

                    string versionValue = MatchJsonStringValue(versionObject, "version") ?? versionKey;
                    if (string.IsNullOrEmpty(versionValue))
                        continue;

                    if (newestUrl == null || CompareVersions(versionValue, newestVersion) > 0)
                    {
                        newestUrl = url;
                        newestVersion = versionValue;
                    }
                }

                if (string.IsNullOrEmpty(newestUrl))
                    continue;

                result.Add(new WPFMAVpmPackage
                {
                    Name = packageName,
                    Version = newestVersion,
                    DownloadUrl = newestUrl
                });
            }

            result.Sort((left, right) => string.Compare(left.Name, right.Name, StringComparison.OrdinalIgnoreCase));
            return result;
        }

        private static string ExtractObject(string json, string key)
        {
            if (string.IsNullOrWhiteSpace(json))
                return null;

            string pattern = "\"" + Regex.Escape(key) + "\"\\s*:\\s*\\{";
            Match match = Regex.Match(json, pattern);
            if (!match.Success)
                return null;

            int start = json.IndexOf('{', match.Index);
            if (start < 0)
                return null;

            int end = FindMatchingBrace(json, start);
            if (end < start)
                return null;

            return json.Substring(start + 1, end - start - 1);
        }

        private static int FindMatchingBrace(string json, int startIndex)
        {
            int depth = 0;
            bool inString = false;
            for (int i = startIndex; i < json.Length; i++)
            {
                char current = json[i];
                if (current == '"')
                {
                    if (inString && i > 0 && json[i - 1] == '\\')
                        continue;
                    inString = !inString;
                    continue;
                }

                if (inString)
                    continue;

                if (current == '{')
                    depth++;
                else if (current == '}')
                {
                    depth--;
                    if (depth == 0)
                        return i;
                }
            }

            return -1;
        }

        private static string MatchJsonStringValue(string json, string key)
        {
            string pattern = "\"" + Regex.Escape(key) + "\"\\s*:\\s*\"((?:\\\\.|[^\\\"])*)\"";
            Match match = Regex.Match(json, pattern);
            return match.Success ? UnescapeJsonString(match.Groups[1].Value) : null;
        }

        private static string UnescapeJsonString(string value)
        {
            if (string.IsNullOrEmpty(value))
                return value;

            value = value.Replace("\\\"", "\"");
            value = value.Replace("\\\\", "\\");
            value = value.Replace("\\n", "\n");
            value = value.Replace("\\r", "\r");
            value = value.Replace("\\t", "\t");
            return value;
        }

        private static int CompareVersions(string left, string right)
        {
            if (string.IsNullOrEmpty(right)) return 1;
            if (string.Equals(left, right, StringComparison.OrdinalIgnoreCase)) return 0;

            var leftParts = ParseVersionParts(left);
            var rightParts = ParseVersionParts(right);
            if (leftParts.Count > 0 && rightParts.Count > 0)
            {
                int limit = Math.Max(leftParts.Count, rightParts.Count);
                for (int i = 0; i < limit; i++)
                {
                    int leftValue = i < leftParts.Count ? leftParts[i] : 0;
                    int rightValue = i < rightParts.Count ? rightParts[i] : 0;
                    if (leftValue != rightValue)
                        return leftValue.CompareTo(rightValue);
                }
                return 0;
            }

            return string.Compare(left, right, StringComparison.OrdinalIgnoreCase);
        }

        private static List<int> ParseVersionParts(string version)
        {
            if (string.IsNullOrEmpty(version))
                return new List<int>();

            var result = new List<int>();
            foreach (var token in version.Split(new[] { '.', '-', '+', '_' }, StringSplitOptions.RemoveEmptyEntries))
            {
                if (int.TryParse(token, out var numericPart))
                    result.Add(numericPart);
            }

            return result;
        }

        private static string GetString(Dictionary<string, object> values, string key)
        {
            if (values == null || !values.ContainsKey(key))
                return null;

            var value = values[key];
            return value == null ? null : value.ToString();
        }

        private static List<string> ParseDependencyNames(string packageJsonPath)
        {
            if (!File.Exists(packageJsonPath))
                return new List<string>();

            try
            {
                var root = MiniJson.Deserialize(File.ReadAllText(packageJsonPath)) as Dictionary<string, object>;
                var dependencies = new List<string>();
                if (root == null)
                    return dependencies;

                AddDependencyNames(root, "dependencies", dependencies);
                AddDependencyNames(root, "vpmDependencies", dependencies);
                AddLegacyDependencyNames(root, "legacyFolders", dependencies);
                AddLegacyDependencyNames(root, "legacyFiles", dependencies);
                return dependencies.Distinct(StringComparer.OrdinalIgnoreCase).ToList();
            }
            catch
            {
                return new List<string>();
            }
        }

        private static void AddDependencyNames(Dictionary<string, object> root, string key, List<string> dependencies)
        {
            if (!root.ContainsKey(key))
                return;

            var values = root[key] as Dictionary<string, object>;
            if (values == null)
                return;

            foreach (var pair in values)
            {
                if (!string.IsNullOrEmpty(pair.Key))
                    dependencies.Add(pair.Key);
            }
        }

        private static void AddLegacyDependencyNames(Dictionary<string, object> root, string key, List<string> dependencies)
        {
            if (!root.ContainsKey(key))
                return;

            var values = root[key] as Dictionary<string, object>;
            if (values == null)
                return;

            foreach (var pair in values)
            {
                var legacyName = NormalizeLegacyPackageName(pair.Key);
                if (!string.IsNullOrEmpty(legacyName))
                    dependencies.Add(legacyName);
            }
        }

        private static string NormalizeLegacyPackageName(string legacyEntry)
        {
            if (string.IsNullOrWhiteSpace(legacyEntry))
                return null;

            var normalized = legacyEntry.Replace('\\', '/').Trim();
            if (string.IsNullOrEmpty(normalized))
                return null;

            var lastSegment = normalized;
            var slashIndex = normalized.LastIndexOf('/');
            if (slashIndex >= 0)
                lastSegment = normalized.Substring(slashIndex + 1);

            if (string.IsNullOrEmpty(lastSegment))
                return null;

            if (lastSegment.EndsWith(".tgz", StringComparison.OrdinalIgnoreCase))
                lastSegment = lastSegment.Substring(0, lastSegment.Length - 4);
            else if (lastSegment.EndsWith(".zip", StringComparison.OrdinalIgnoreCase))
                lastSegment = lastSegment.Substring(0, lastSegment.Length - 4);
            else if (lastSegment.EndsWith(".tar.gz", StringComparison.OrdinalIgnoreCase))
                lastSegment = lastSegment.Substring(0, lastSegment.Length - 7);

            if (string.IsNullOrEmpty(lastSegment) || lastSegment.Contains(" ") || !lastSegment.Contains("."))
                return null;

            return lastSegment;
        }

        private static WPFMAVpmPackage FindCachedDependency(string dependencyName)
        {
            if (string.IsNullOrEmpty(dependencyName))
                return null;

            var cachedPackages = LoadCachedPackages();
            foreach (var package in cachedPackages)
            {
                if (string.Equals(package.Name, dependencyName, StringComparison.OrdinalIgnoreCase))
                    return package;
            }

            return null;
        }

        private static string ResolveManifestVersionHint(string dependencyName)
        {
            var dependencyPath = Path.Combine("Packages", Sanitize(dependencyName), "package.json");
            if (!File.Exists(dependencyPath))
                return null;

            try
            {
                var root = MiniJson.Deserialize(File.ReadAllText(dependencyPath)) as Dictionary<string, object>;
                if (root == null || !root.ContainsKey("version"))
                    return null;

                return root["version"]?.ToString();
            }
            catch
            {
                return null;
            }
        }

        private static void WriteCacheManifest(List<WPFMAVpmPackage> packages)
        {
            Directory.CreateDirectory(CacheRoot);
            var builder = new StringBuilder();
            builder.AppendLine("{");
            builder.AppendLine("  \"packages\": [");

            for (int i = 0; i < packages.Count; i++)
            {
                var package = packages[i];
                builder.AppendLine("    {");
                builder.AppendLine("      \"name\": \"" + EscapeJson(package.Name ?? string.Empty) + "\",");
                builder.AppendLine("      \"version\": \"" + EscapeJson(package.Version ?? string.Empty) + "\",");
                builder.AppendLine("      \"downloadUrl\": \"" + EscapeJson(package.DownloadUrl ?? string.Empty) + "\",");
                builder.AppendLine("      \"cachePath\": \"" + EscapeJson(package.CachePath ?? string.Empty) + "\"");
                builder.Append("    }");
                if (i < packages.Count - 1)
                    builder.Append(',');
                builder.AppendLine();
            }

            builder.AppendLine("  ]");
            builder.AppendLine("}");
            File.WriteAllText(CacheManifestPath, builder.ToString());
        }

        private static string EscapeJson(string value)
        {
            if (string.IsNullOrEmpty(value))
                return string.Empty;

            return value
                .Replace("\\", "\\\\")
                .Replace("\"", "\\\"")
                .Replace("\r", "\\r")
                .Replace("\n", "\\n");
        }

        private static string Sanitize(string value)
        {
            return WPFMAPaths.SafeFileName(value);
        }

        private static void InstallLegacyPackageFamily(string stagingPath, string packageJsonPath)
        {
            if (!File.Exists(packageJsonPath))
                return;

            try
            {
                var root = MiniJson.Deserialize(File.ReadAllText(packageJsonPath)) as Dictionary<string, object>;
                if (root == null)
                    return;

                foreach (var entry in GetLegacyPaths(root, "legacyFolders"))
                    CopyLegacyFamilyEntry(stagingPath, entry);

                foreach (var entry in GetLegacyPaths(root, "legacyFiles"))
                    CopyLegacyFamilyEntry(stagingPath, entry);
            }
            catch
            {
            }
        }

        private static IEnumerable<string> GetLegacyPaths(Dictionary<string, object> root, string key)
        {
            if (!root.ContainsKey(key))
                yield break;

            var values = root[key] as Dictionary<string, object>;
            if (values == null)
                yield break;

            foreach (var pair in values)
            {
                var target = pair.Key;
                if (!string.IsNullOrWhiteSpace(target))
                    yield return target.Replace('\\', '/');
            }
        }

        private static void CopyLegacyFamilyEntry(string stagingPath, string relativeTarget)
        {
            if (string.IsNullOrWhiteSpace(relativeTarget))
                return;

            var normalizedTarget = relativeTarget.Trim();
            if (normalizedTarget.StartsWith("/", StringComparison.Ordinal))
                normalizedTarget = normalizedTarget.Substring(1);

            var targetPath = Path.GetFullPath(Path.Combine(Path.GetFullPath("."), normalizedTarget));
            if (string.IsNullOrEmpty(Path.GetFileName(targetPath)))
                return;

            var sourceName = normalizedTarget.Substring(normalizedTarget.LastIndexOf('/') + 1);
            string sourcePath = null;
            var candidates = Directory.GetFiles(stagingPath, "*", SearchOption.AllDirectories)
                .Concat(Directory.GetDirectories(stagingPath, "*", SearchOption.AllDirectories))
                .Where(path => string.Equals(Path.GetFileName(path), sourceName, StringComparison.OrdinalIgnoreCase))
                .ToList();

            foreach (var candidate in candidates)
            {
                var candidateNormalized = candidate.Replace('\\', '/');
                var targetNormalized = normalizedTarget.Replace('\\', '/');
                if (candidateNormalized.EndsWith("/" + sourceName, StringComparison.OrdinalIgnoreCase) ||
                    candidateNormalized.EndsWith("/" + targetNormalized.Substring(targetNormalized.LastIndexOf('/') + 1), StringComparison.OrdinalIgnoreCase))
                {
                    sourcePath = candidate;
                    break;
                }
            }

            if (string.IsNullOrEmpty(sourcePath))
                return;

            var targetDirectory = Path.GetDirectoryName(targetPath);
            if (!string.IsNullOrEmpty(targetDirectory))
                Directory.CreateDirectory(targetDirectory);

            if (Directory.Exists(targetPath))
                Directory.Delete(targetPath, true);
            if (File.Exists(targetPath))
                File.Delete(targetPath);

            if (Directory.Exists(sourcePath))
                Directory.Move(sourcePath, targetPath);
            else if (File.Exists(sourcePath))
                File.Copy(sourcePath, targetPath, true);
        }

        private static void PatchVrcfuryBadInstallDetector(string packagePath)
        {
            if (string.IsNullOrEmpty(packagePath))
                return;

            var detectorPath = Path.Combine(packagePath, "Editor-Avatars", "BadInstallDetector.cs");
            if (!File.Exists(detectorPath))
                return;

            var patchedContent = @"using System.IO;
using System.Linq;
using UnityEditor;
using VF.Utils;

namespace VF {
    internal static class BadInstallDetector {
        [VFInit]
        private static void Init() {
            // WPFMA disables the upstream local-install popup for managed installs.
        }
    }
}";

            File.WriteAllText(detectorPath, patchedContent);
        }

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

            string manifest = File.ReadAllText(manifestPath);
            manifest = RemoveStaleManifestDependency(manifest, packageName);

            if (manifest.Contains("\"" + packageName + "\":")) return;

            string resolvedVersion = version;
            if (string.IsNullOrEmpty(resolvedVersion))
                resolvedVersion = ResolveManifestVersionHint(packageName);

            if (string.IsNullOrEmpty(resolvedVersion))
                return;

            const string marker = "  \"dependencies\": {\n";
            manifest = manifest.Replace(marker, marker + "    \"" + packageName + "\": \"" + resolvedVersion + "\",\n");
            File.WriteAllText(manifestPath, manifest);
        }

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

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

    internal static class MiniJson
    {
        public static object Deserialize(string json)
        {
            if (string.IsNullOrWhiteSpace(json))
                throw new InvalidDataException("Empty JSON response.");

            int index = 0;
            object result = ParseValue(json, ref index);
            SkipWhitespace(json, ref index);
            if (index != json.Length)
                throw new InvalidDataException("Unexpected trailing JSON content.");
            return result;
        }

        private static object ParseValue(string json, ref int index)
        {
            SkipWhitespace(json, ref index);
            if (index >= json.Length)
                throw new InvalidDataException("Empty JSON response.");

            char current = json[index];
            switch (current)
            {
                case '{': return ParseObject(json, ref index);
                case '[': return ParseArray(json, ref index);
                case '"': return ParseString(json, ref index);
                case 't':
                    if (json.Length - index >= 4 && json.Substring(index, 4) == "true")
                    {
                        index += 4;
                        return true;
                    }
                    break;
                case 'f':
                    if (json.Length - index >= 5 && json.Substring(index, 5) == "false")
                    {
                        index += 5;
                        return false;
                    }
                    break;
                case 'n':
                    if (json.Length - index >= 4 && json.Substring(index, 4) == "null")
                    {
                        index += 4;
                        return null;
                    }
                    break;
            }

            return ParseNumber(json, ref index);
        }

        private static Dictionary<string, object> ParseObject(string json, ref int index)
        {
            var result = new Dictionary<string, object>();
            index++;
            SkipWhitespace(json, ref index);

            if (index < json.Length && json[index] == '}')
            {
                index++;
                return result;
            }

            while (index < json.Length)
            {
                if (json[index] != '"')
                    throw new InvalidDataException("Invalid JSON object key.");

                string key = ParseString(json, ref index);
                SkipWhitespace(json, ref index);
                if (index >= json.Length || json[index] != ':')
                    throw new InvalidDataException("Invalid JSON object entry.");

                index++;
                result[key] = ParseValue(json, ref index);
                SkipWhitespace(json, ref index);

                if (index >= json.Length)
                    throw new InvalidDataException("Unclosed JSON object.");

                if (json[index] == ',')
                {
                    index++;
                    SkipWhitespace(json, ref index);
                    if (index < json.Length && json[index] == '}')
                        index++;
                    continue;
                }

                if (json[index] == '}')
                {
                    index++;
                    return result;
                }

                throw new InvalidDataException("Invalid JSON object separator.");
            }

            throw new InvalidDataException("Unclosed JSON object.");
        }

        private static List<object> ParseArray(string json, ref int index)
        {
            var result = new List<object>();
            index++;
            SkipWhitespace(json, ref index);

            if (index < json.Length && json[index] == ']')
            {
                index++;
                return result;
            }

            while (index < json.Length)
            {
                result.Add(ParseValue(json, ref index));
                SkipWhitespace(json, ref index);

                if (index >= json.Length)
                    throw new InvalidDataException("Unclosed JSON array.");

                if (json[index] == ',')
                {
                    index++;
                    SkipWhitespace(json, ref index);
                    continue;
                }

                if (json[index] == ']')
                {
                    index++;
                    return result;
                }

                throw new InvalidDataException("Invalid JSON array separator.");
            }

            throw new InvalidDataException("Unclosed JSON array.");
        }

        private static string ParseString(string json, ref int index)
        {
            if (index >= json.Length || json[index] != '"')
                throw new InvalidDataException("Invalid JSON string.");

            index++;
            var result = new StringBuilder();
            while (index < json.Length)
            {
                char current = json[index++];
                if (current == '"')
                    return result.ToString();

                if (current == '\\')
                {
                    if (index >= json.Length)
                        throw new InvalidDataException("Unclosed JSON escape sequence.");

                    char escape = json[index++];
                    switch (escape)
                    {
                        case '"': result.Append('"'); break;
                        case '\\': result.Append('\\'); break;
                        case '/': result.Append('/'); break;
                        case 'b': result.Append('\b'); break;
                        case 'f': result.Append('\f'); break;
                        case 'n': result.Append('\n'); break;
                        case 'r': result.Append('\r'); break;
                        case 't': result.Append('\t'); break;
                        case 'u':
                            if (index + 4 > json.Length)
                                throw new InvalidDataException("Invalid unicode escape sequence.");

                            string hex = json.Substring(index, 4);
                            if (!int.TryParse(hex, System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture, out int codePoint))
                                throw new InvalidDataException("Invalid unicode escape sequence.");

                            result.Append(char.ConvertFromUtf32(codePoint));
                            index += 4;
                            break;
                        default:
                            result.Append(escape);
                            break;
                    }
                    continue;
                }

                result.Append(current);
            }

            throw new InvalidDataException("Unclosed JSON string.");
        }

        private static double ParseNumber(string json, ref int index)
        {
            int start = index;

            if (index < json.Length && json[index] == '-')
                index++;

            while (index < json.Length && char.IsDigit(json[index]))
                index++;

            if (index < json.Length && json[index] == '.')
            {
                index++;
                while (index < json.Length && char.IsDigit(json[index]))
                    index++;
            }

            if (index < json.Length && (json[index] == 'e' || json[index] == 'E'))
            {
                index++;
                if (index < json.Length && (json[index] == '+' || json[index] == '-'))
                    index++;

                while (index < json.Length && char.IsDigit(json[index]))
                    index++;
            }

            string value = json.Substring(start, index - start);
            if (string.IsNullOrEmpty(value) || value == "-" || value == ".")
                throw new InvalidDataException("Invalid JSON number: " + value);

            if (!double.TryParse(value, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out double result))
                throw new InvalidDataException("Invalid JSON number: " + value);

            return result;
        }

        private static void SkipWhitespace(string json, ref int index)
        {
            while (index < json.Length && char.IsWhiteSpace(json[index]))
                index++;
        }
    }
}
#endif
