// 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.Linq;
using UnityEditor;
using UnityEngine;

namespace WPFMA.Vrca
{
    internal static class WPFMAShaderFetch
    {
        private const string InstallRoot = "Assets/WPFMA-SDK/Shaders";

        internal static int EnsureInstalled(IEnumerable<string> shaderNames, string ripFolder, List<string> warnings)
        {
            if (shaderNames == null)
                return 0;

            var missing = Missing(shaderNames);

            if (!WPFMAArchive.IsUnlocked)
            {
                if (missing.Count > 0)
                {
                    Debug.Log("[WPFMA-SDK] " + missing.Count + " shader(s) are missing, but the archive is locked. " +
                              "Redeem an access code in Settings to have them fetched.");
                }

                return 0;
            }

            if (missing.Count == 0)
            {
                Debug.Log("[WPFMA-SDK] Every shader this rip needs is already installed; the archive was not needed.");
                return 0;
            }

            Debug.Log("[WPFMA-SDK] " + missing.Count + " shader(s) missing; asking the archive for: " +
                      string.Join(", ", missing.Take(8).ToArray()) +
                      (missing.Count > 8 ? " and " + (missing.Count - 8) + " more" : string.Empty));

            string message;
            var catalog = WPFMAArchive.Catalog(out message);
            if (catalog.Count == 0)
            {
                warnings.Add("The shader archive could not be searched (" + (message ?? "no entries") +
                             "), so " + missing.Count + " missing shader(s) were left to the usual matching.");
                return 0;
            }

            int installed = 0;
            var tried = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

            foreach (var name in missing)
            {
                var entry = BestMatch(name, catalog);
                if (entry == null)
                {
                    warnings.Add("'" + name + "' is not installed and nothing in the archive matched it.");
                    continue;
                }

                if (!tried.Add(entry.id))
                    continue;

                Debug.Log("[WPFMA-SDK] '" + name + "' is missing; installing '" + entry.title +
                          "' (" + entry.size_human + ") from the archive.");

                string downloaded = WPFMAArchive.Download(entry, Staging(ripFolder), out message);
                if (downloaded == null)
                {
                    warnings.Add("'" + entry.title + "' could not be downloaded: " + message);
                    continue;
                }

                if (Install(downloaded, entry, warnings))
                    installed++;
            }

            if (installed > 0)
            {
                AssetDatabase.Refresh();

                var stillMissing = Missing(shaderNames);
                Debug.Log("[WPFMA-SDK] Installed " + installed + " shader package(s) from the archive; " +
                          stillMissing.Count + " shader name(s) still unresolved.");
            }

            return installed;
        }

        private static bool InstallUnityPackage(string path, WPFMAArchive.CatalogEntry entry, List<string> warnings)
        {
            int written = 0, skipped = 0;

            try
            {
                var assets = ReadPackage(path);
                if (assets.Count == 0)
                {
                    warnings.Add("'" + entry.title + "' contained no assets this installer could read.");
                    return false;
                }

                foreach (var asset in assets.Values)
                {
                    if (asset.Bytes == null || string.IsNullOrEmpty(asset.PathName))
                        continue;

                    string target = asset.PathName.Replace('\\', '/').Trim();

                    if (!target.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase) ||
                        target.Contains(".."))
                        continue;

                    if (File.Exists(target))
                    {
                        skipped++;
                        continue;
                    }

                    string folder = Path.GetDirectoryName(target);
                    if (!string.IsNullOrEmpty(folder))
                        Directory.CreateDirectory(folder);

                    File.WriteAllBytes(target, asset.Bytes);
                    if (asset.Meta != null)
                        File.WriteAllBytes(target + ".meta", asset.Meta);

                    written++;
                }
            }
            catch (Exception e)
            {
                warnings.Add("'" + entry.title + "' could not be unpacked: " + e.Message);
                return false;
            }

            if (written == 0)
            {
                if (skipped > 0)
                    Debug.Log("[WPFMA-SDK] '" + entry.title + "' is already in the project (" + skipped + " file(s)).");
                return skipped > 0;
            }

            Debug.Log("[WPFMA-SDK] Unpacked '" + entry.title + "': " + written + " file(s)" +
                      (skipped > 0 ? ", " + skipped + " already present" : string.Empty) + ".");
            return true;
        }

        private sealed class PackagedAsset
        {
            public byte[] Bytes;
            public byte[] Meta;
            public string PathName;
        }

        private static Dictionary<string, PackagedAsset> ReadPackage(string path)
        {
            var assets = new Dictionary<string, PackagedAsset>(StringComparer.Ordinal);

            using (var file = File.OpenRead(path))
            using (var gzip = new System.IO.Compression.GZipStream(file, System.IO.Compression.CompressionMode.Decompress))
            {
                string name;
                byte[] content;

                while (ReadTarEntry(gzip, out name, out content))
                {
                    if (content == null || string.IsNullOrEmpty(name))
                        continue;

                    name = name.Replace('\\', '/').TrimStart('.', '/');
                    int slash = name.IndexOf('/');
                    if (slash <= 0)
                        continue;

                    string guid = name.Substring(0, slash);
                    string part = name.Substring(slash + 1).Trim('/');

                    PackagedAsset asset;
                    if (!assets.TryGetValue(guid, out asset))
                        assets[guid] = asset = new PackagedAsset();

                    if (part.Equals("asset", StringComparison.OrdinalIgnoreCase))
                        asset.Bytes = content;
                    else if (part.Equals("asset.meta", StringComparison.OrdinalIgnoreCase))
                        asset.Meta = content;
                    else if (part.Equals("pathname", StringComparison.OrdinalIgnoreCase))
                        asset.PathName = System.Text.Encoding.UTF8.GetString(content).Split('\n')[0].Trim();
                }
            }

            return assets;
        }

        private static bool ReadTarEntry(Stream stream, out string name, out byte[] content)
        {
            name = null;
            content = null;

            var header = new byte[512];
            if (!ReadExactly(stream, header, 512))
                return false;

            if (header.All(b => b == 0))
                return false;

            name = System.Text.Encoding.UTF8.GetString(header, 0, 100).TrimEnd('\0', ' ');
            string sizeField = System.Text.Encoding.ASCII.GetString(header, 124, 12).Trim('\0', ' ');

            long size = 0;
            foreach (var c in sizeField)
            {
                if (c < '0' || c > '7')
                    break;
                size = size * 8 + (c - '0');
            }

            char typeFlag = (char)header[156];
            var data = new byte[size];
            if (size > 0 && !ReadExactly(stream, data, (int)size))
                return false;

            long padding = (512 - (size % 512)) % 512;
            for (long i = 0; i < padding; i++)
            {
                if (stream.ReadByte() < 0)
                    break;
            }

            if (typeFlag == 'L')
            {
                string longName = System.Text.Encoding.UTF8.GetString(data).TrimEnd('\0', ' ');
                string ignoredName;
                byte[] realContent;
                if (!ReadTarEntry(stream, out ignoredName, out realContent))
                    return false;

                name = longName;
                content = realContent;
                return true;
            }

            content = typeFlag == '0' || typeFlag == '\0' ? data : null;
            return true;
        }

        private static bool ReadExactly(Stream stream, byte[] buffer, int count)
        {
            int read = 0;
            while (read < count)
            {
                int got = stream.Read(buffer, read, count - read);
                if (got <= 0)
                    return false;

                read += got;
            }

            return true;
        }

        private static List<string> Missing(IEnumerable<string> shaderNames)
        {
            var missing = new List<string>();
            var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            List<Shader> installed = null;

            foreach (var name in shaderNames)
            {
                if (string.IsNullOrEmpty(name) || IsBuiltIn(name))
                    continue;

                string wanted = WPFMAShaderResolver.RecoverBaseName(name);
                if (string.IsNullOrEmpty(wanted))
                    wanted = name;

                if (!seen.Add(wanted))
                    continue;

                if (Shader.Find(name) != null || Shader.Find(wanted) != null)
                    continue;

                if (installed == null)
                    installed = InstalledShaders();

                string reason;
                if (WPFMAShaderResolver.FindFamilyMatch(name, installed, out reason) != null)
                    continue;

                missing.Add(wanted);
            }

            return missing;
        }

        internal static bool IsBuiltIn(string name)
        {
            if (name.Equals("Standard", StringComparison.OrdinalIgnoreCase) ||
                name.StartsWith("Legacy Shaders/", StringComparison.OrdinalIgnoreCase) ||
                name.StartsWith("Skybox/", StringComparison.OrdinalIgnoreCase) ||
                name.StartsWith("UI/", StringComparison.OrdinalIgnoreCase) ||
                name.StartsWith("Particles/", StringComparison.OrdinalIgnoreCase) ||
                name.StartsWith("Sprites/", StringComparison.OrdinalIgnoreCase) ||
                name.StartsWith("VRChat/", StringComparison.OrdinalIgnoreCase))
                return true;

            if (name.StartsWith("Hidden/", StringComparison.OrdinalIgnoreCase))
            {
                return !name.StartsWith("Hidden/Locked/", StringComparison.OrdinalIgnoreCase) &&
                       !name.StartsWith("Hidden/InternalLocked/", StringComparison.OrdinalIgnoreCase);
            }

            return false;
        }

        internal static List<Shader> InstalledShaders()
        {
            var shaders = new List<Shader>();

            foreach (var info in ShaderUtil.GetAllShaderInfo())
            {
                if (info.hasErrors || info.name.StartsWith("Hidden/", StringComparison.Ordinal))
                    continue;

                var shader = Shader.Find(info.name);
                if (shader != null)
                    shaders.Add(shader);
            }

            return shaders;
        }

        private static WPFMAArchive.CatalogEntry BestMatch(string shaderName, List<WPFMAArchive.CatalogEntry> catalog)
        {
            var words = Words(shaderName);
            if (words.Count == 0)
                return null;

            string vendor = VendorOf(shaderName);
            var segments = SegmentKeys(shaderName, vendor);
            var strongWords = new HashSet<string>(words, StringComparer.OrdinalIgnoreCase);
            strongWords.RemoveWhere(IsVersionWord);
            if (vendor != null)
                strongWords.Remove(vendor);

            WPFMAArchive.CatalogEntry best = null;
            int bestScore = 0;
            int bestStrong = 0;
            int vendorCandidates = 0;

            foreach (var entry in catalog)
            {
                if (entry == null)
                    continue;

                var haystack = Words(string.Join(" ", new[]
                {
                    entry.title, entry.collection, entry.file, entry.author, entry.version,
                    entry.tags != null ? string.Join(" ", entry.tags) : null
                }.Where(part => !string.IsNullOrEmpty(part)).ToArray()));

                bool vendorMatched = vendor != null && haystack.Any(word => SameVendor(vendor, word));
                if (vendor != null && !vendorMatched)
                    continue;

                if (vendorMatched)
                {
                    vendorCandidates++;
                }

                string compact = Compact(string.Join(" ", new[] { entry.title, entry.file, entry.collection }
                    .Where(part => !string.IsNullOrEmpty(part)).ToArray()));

                int strong = segments.Count(segment => compact.Contains(segment));
                strong += strongWords.Count(word => haystack.Contains(word) && !segments.Any(compact.Contains));

                int versions = words.Count(word => IsVersionWord(word) && haystack.Contains(word));

                int score = (vendorMatched ? 6 : 0) + strong * 2 +
                            ((vendorMatched || strong > 0) ? versions : 0);

                if (score <= bestScore)
                    continue;

                bestScore = score;
                bestStrong = strong;
                best = entry;
            }

            if (best == null)
                return null;

            if (vendor != null)
            {
                if (bestStrong >= 1 || vendorCandidates == 1)
                    return best;

                Debug.Log("[WPFMA-SDK] '" + shaderName + "': " + vendorCandidates + " entries from that vendor and " +
                          "nothing else in the name matched, so none was chosen. Closest was '" + best.title + "'.");
                return null;
            }

            return bestStrong >= 2 ? best : null;
        }

        private static List<string> SegmentKeys(string shaderName, string vendor)
        {
            var keys = new List<string>();
            if (string.IsNullOrEmpty(shaderName))
                return keys;

            var parts = shaderName.Split('/');
            for (int i = 0; i < parts.Length; i++)
            {
                string part = parts[i].Trim().TrimStart('.');
                if (i == 0 && vendor != null)
                    continue;

                string key = Compact(part);
                if (key.Length < 4)
                    continue;

                if (key.EndsWith("s", StringComparison.Ordinal))
                    key = key.Substring(0, key.Length - 1);

                if (!keys.Contains(key))
                    keys.Add(key);
            }

            return keys;
        }

        private static string Compact(string text)
        {
            if (string.IsNullOrEmpty(text))
                return string.Empty;

            var builder = new System.Text.StringBuilder(text.Length);
            foreach (var character in text)
            {
                if (char.IsLetterOrDigit(character))
                    builder.Append(char.ToLowerInvariant(character));
            }

            return builder.ToString();
        }

        private static string VendorOf(string shaderName)
        {
            if (string.IsNullOrEmpty(shaderName))
                return null;

            int slash = shaderName.IndexOf('/');
            if (slash <= 0)
                return null;

            string vendor = shaderName.Substring(0, slash).Trim().TrimStart('.');

            int space = vendor.IndexOf(' ');
            if (space > 2)
                vendor = vendor.Substring(0, space);

            return vendor.Length >= 3 ? vendor : null;
        }

        private static bool SameVendor(string vendor, string word)
        {
            if (string.Equals(vendor, word, StringComparison.OrdinalIgnoreCase))
                return true;

            int length = Math.Min(5, Math.Min(vendor.Length, word.Length));
            if (length < 4)
                return false;

            return string.Equals(vendor.Substring(0, length), word.Substring(0, length),
                StringComparison.OrdinalIgnoreCase);
        }

        private static bool IsVersionWord(string word)
        {
            if (string.IsNullOrEmpty(word))
                return false;

            string trimmed = word.TrimStart('v', 'V');
            if (trimmed.Length == 0)
                return false;

            foreach (var character in trimmed)
            {
                if (!char.IsDigit(character))
                    return false;
            }

            return true;
        }

        private static HashSet<string> Words(string text)
        {
            var words = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            if (string.IsNullOrEmpty(text))
                return words;

            foreach (var raw in text.Split(new[] { '/', '\\', ' ', '_', '-', '.', '(', ')', '[', ']', ',' },
                         StringSplitOptions.RemoveEmptyEntries))
            {
                string word = raw.Trim();
                if (word.Length < 2 || word.Equals("shader", StringComparison.OrdinalIgnoreCase))
                    continue;

                words.Add(word);
            }

            return words;
        }

        private static string Staging(string ripFolder)
        {
            string folder = string.IsNullOrEmpty(ripFolder) ? InstallRoot + "/Downloads" : ripFolder + "/Shaders";
            Directory.CreateDirectory(folder);
            return folder;
        }

        private static bool Install(string downloaded, WPFMAArchive.CatalogEntry entry, List<string> warnings)
        {
            return Install(downloaded, entry, warnings, 0);
        }

        private static bool Install(string downloaded, WPFMAArchive.CatalogEntry entry, List<string> warnings, int depth)
        {
            string extension = Path.GetExtension(downloaded).ToLowerInvariant();

            try
            {
                switch (extension)
                {
                    case ".gz":
                        return depth == 0 && Install(Gunzip(downloaded, warnings), entry, warnings, 1);

                    case ".unitypackage":
                        return InstallUnityPackage(downloaded, entry, warnings);

                    case ".zip":
                        string target = InstallRoot + "/" + SafeFolder(entry.collection ?? entry.title ?? "Archive");
                        Directory.CreateDirectory(target);
                        System.IO.Compression.ZipFile.ExtractToDirectory(downloaded, target);
                        return true;

                    case ".shader":
                    case ".cginc":
                    case ".hlsl":
                    case ".shadergraph":
                        string folder = InstallRoot + "/" + SafeFolder(entry.collection ?? "Shaders");
                        Directory.CreateDirectory(folder);
                        File.Copy(downloaded, Path.Combine(folder, Path.GetFileName(downloaded)), true);
                        return true;

                    case ".7z":
                        warnings.Add("'" + entry.title + "' is a .7z, which Unity cannot open on its own. " +
                                     "The file is in the rip's Shaders folder; extract it by hand, or " +
                                     "re-upload it as a .zip or .unitypackage.");
                        return false;

                    default:
                        warnings.Add("'" + entry.title + "' arrived as " + extension +
                                     ", which this installer does not handle; the file is with the rip.");
                        return false;
                }
            }
            catch (Exception e)
            {
                warnings.Add("'" + entry.title + "' could not be installed: " + e.Message);
                return false;
            }
        }

        private static string Gunzip(string path, List<string> warnings)
        {
            string inner = Path.Combine(Path.GetDirectoryName(path) ?? string.Empty,
                Path.GetFileNameWithoutExtension(path));

            try
            {
                using (var source = File.OpenRead(path))
                using (var gzip = new System.IO.Compression.GZipStream(source, System.IO.Compression.CompressionMode.Decompress))
                using (var target = File.Create(inner))
                    gzip.CopyTo(target);

                return inner;
            }
            catch (Exception)
            {
                try
                {
                    File.Copy(path, inner, true);
                    return inner;
                }
                catch (Exception e)
                {
                    warnings.Add("'" + Path.GetFileName(path) + "' could not be unpacked: " + e.Message);
                    return path;
                }
            }
        }

        private static string SafeFolder(string name)
        {
            return WPFMAPaths.SafeFileName(name);
        }
    }
}
#endif
