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

namespace WPFMA.Vrca
{
    internal static class WPFMARequiredPackages
    {
        private const int MonoScriptClassId = 115;

        internal sealed class Requirement
        {
            public string Assembly;
            public string Package;
            public string Display;
            public string Note;
            public bool Installed;
            public int Scripts;

            public string Describe()
            {
                string name = string.IsNullOrEmpty(Display) ? Assembly : Display;
                string where = string.IsNullOrEmpty(Package) ? string.Empty : " (" + Package + ")";
                string tail = string.IsNullOrEmpty(Note) ? string.Empty : " - " + Note;

                return name + where + ", used by " + Scripts + (Scripts == 1 ? " script" : " scripts") + tail;
            }
        }

        private static readonly string[] Ignored =
        {
            "Assembly-CSharp", "Assembly-CSharp-firstpass", "Assembly-CSharp-Editor",
            "UnityEngine", "UnityEditor", "mscorlib", "System", "netstandard"
        };

        private static readonly Dictionary<string, string[]> Known =
            new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase)
            {
                { "VRCFury", new[] { "com.vrcfury.vrcfury", "VRCFury", null } },
                { "VRCFury.Editor", new[] { "com.vrcfury.vrcfury", "VRCFury", null } },
                { "VRCSDK3A", new[] { "com.vrchat.avatars", "VRChat Avatars SDK", null } },
                { "VRC.SDK3A", new[] { "com.vrchat.avatars", "VRChat Avatars SDK", null } },
                { "VRCSDKBase", new[] { "com.vrchat.base", "VRChat Base SDK", null } },
                { "VRC.SDKBase", new[] { "com.vrchat.base", "VRChat Base SDK", null } },
                { "VRCSDK2", new[] { null, "VRChat SDK2",
                    "retired by VRChat and no longer available, so these components cannot be restored" } },
                { "lilToon", new[] { "jp.lilxyzw.liltoon", "lilToon", null } },
                { "lilToon.Editor", new[] { "jp.lilxyzw.liltoon", "lilToon", null } },
                { "d4rkAvatarOptimizer", new[] { null, "d4rkAvatarOptimizer", "install it from its own release page" } },
                { "Thry.Editor", new[] { null, "Thry Editor (Poiyomi)", "ships with Poiyomi shaders" } },
                { "DynamicBone", new[] { null, "Dynamic Bone", "a paid Asset Store package" } },
                { "RootMotion", new[] { null, "Final IK", "a paid Asset Store package" } },
                { "FinalIK", new[] { null, "Final IK", "a paid Asset Store package" } }
            };

        internal static List<Requirement> Detect(WPFMASerializedFile cab)
        {
            var found = new List<Requirement>();
            if (cab == null || cab.Objects == null)
                return found;

            var counts = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

            foreach (var info in cab.Objects.Where(o => o.Type != null && o.Type.ClassId == MonoScriptClassId))
            {
                string assembly;
                try
                {
                    var values = cab.ReadObject(info) as Dictionary<string, object>;
                    if (values == null)
                        continue;

                    object raw;
                    if (!values.TryGetValue("m_AssemblyName", out raw))
                        continue;

                    assembly = Normalize(raw as string);
                }
                catch (Exception)
                {
                    continue;
                }

                if (string.IsNullOrEmpty(assembly) || IsIgnored(assembly))
                    continue;

                int count;
                counts.TryGetValue(assembly, out count);
                counts[assembly] = count + 1;
            }

            var loaded = LoadedAssemblies();

            foreach (var pair in counts.OrderByDescending(p => p.Value))
            {
                string[] known;
                Known.TryGetValue(pair.Key, out known);

                found.Add(new Requirement
                {
                    Assembly = pair.Key,
                    Package = known != null ? known[0] : null,
                    Display = known != null ? known[1] : null,
                    Note = known != null ? known[2] : null,
                    Installed = loaded.Contains(pair.Key),
                    Scripts = pair.Value
                });
            }

            return found;
        }

        internal static List<Requirement> Missing(WPFMASerializedFile cab)
        {
            return Detect(cab).Where(r => !r.Installed).ToList();
        }

        private static HashSet<string> LoadedAssemblies()
        {
            var names = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
            {
                try
                {
                    names.Add(assembly.GetName().Name);
                }
                catch (Exception)
                {
                }
            }

            return names;
        }

        private static string Normalize(string assembly)
        {
            if (string.IsNullOrEmpty(assembly))
                return null;

            assembly = assembly.Trim();
            if (assembly.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
                assembly = assembly.Substring(0, assembly.Length - 4);

            return assembly;
        }

        private static bool IsIgnored(string assembly)
        {
            foreach (var ignored in Ignored)
            {
                if (assembly.Equals(ignored, StringComparison.OrdinalIgnoreCase) ||
                    assembly.StartsWith(ignored + ".", StringComparison.OrdinalIgnoreCase))
                    return true;
            }

            return false;
        }
    }
}
#endif
