// 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;
using System.Text.RegularExpressions;

namespace WPFMA.Vrca
{
    /// <summary>
    /// Which avatar systems an uploaded avatar was built with. VRCFury, Modular Avatar and the optimizers run at
    /// upload, bake their work into plain animators, meshes and parameters, then remove themselves, so they're
    /// found by the names they leave behind (layer and parameter names, controller and mesh names).
    /// </summary>
    internal static class WPFMABundleSystems
    {
        private const int MeshClassId = 43;
        private const int AnimatorControllerClassId = 91;

        /// <summary>Names gathered from a bundle while it's being read for shaders.</summary>
        internal sealed class Traces
        {
            public readonly List<string> Controllers = new List<string>();
            public readonly HashSet<string> Strings = new HashSet<string>(StringComparer.Ordinal);
            public readonly List<string> Meshes = new List<string>();
            public readonly List<string> Shaders = new List<string>();
        }

        internal sealed class Found
        {
            public string Name;
            public string Evidence;
        }

        internal static void Collect(WPFMASerializedFile cab, Traces traces)
        {
            foreach (var info in cab.Objects)
            {
                if (info.Type == null)
                    continue;
                try
                {
                    if (info.Type.ClassId == MeshClassId)
                    {
                        string name = cab.ReadString(info, "m_Name");
                        if (!string.IsNullOrEmpty(name))
                            traces.Meshes.Add(name);
                    }
                    else if (info.Type.ClassId == AnimatorControllerClassId)
                    {
                        var value = cab.ReadObject(info) as Dictionary<string, object>;
                        if (value == null)
                            continue;
                        object name;
                        if (value.TryGetValue("m_Name", out name) && name is string)
                            traces.Controllers.Add((string)name);
                        object table;
                        // Every layer, parameter and state name the controller uses.
                        if (value.TryGetValue("m_TOS", out table) && table is List<object>)
                            foreach (var entry in ((List<object>)table).OfType<Dictionary<string, object>>())
                            {
                                object text;
                                if (entry.TryGetValue("second", out text) && text is string && ((string)text).Length > 0)
                                    traces.Strings.Add((string)text);
                            }
                    }
                }
                catch (Exception)
                {
                }
            }
        }

        private static readonly Regex VrcFuryLayer = new Regex(@"^\[VF\d+\]", RegexOptions.Compiled);
        private static readonly Regex VrcFuryParameter = new Regex(@"^VF\d+_", RegexOptions.Compiled);

        internal static List<Found> Detect(Traces traces)
        {
            var found = new List<Found>();
            if (traces == null)
                return found;

            var strings = traces.Strings;

            // VRCFury: controllers named "VRCFury FX", layers "[VF129] Defaults", parameters "VF73_...".
            var furyControllers = traces.Controllers.Where(c => c.IndexOf("VRCFury", StringComparison.OrdinalIgnoreCase) >= 0).ToList();
            var furyLayers = strings.Where(s => VrcFuryLayer.IsMatch(s)).ToList();
            int furyParameters = strings.Count(s => VrcFuryParameter.IsMatch(s));
            if (furyControllers.Count > 0 || furyLayers.Count > 0 || furyParameters > 0)
                found.Add(new Found
                {
                    Name = "VRCFury",
                    Evidence = Join(
                        furyControllers.Count > 0 ? "controllers named \"" + furyControllers[0] + "\"" : null,
                        furyLayers.Count > 0 ? Count(furyLayers.Count, "layer") + " like " + furyLayers.OrderBy(s => s.Length).First() : null,
                        furyParameters > 0 ? Count(furyParameters, "VF parameter") : null)
                });

            // Modular Avatar: layers "Modular Avatar: ..." / "MA Responsive: ...", parameters "__MA...".
            var maLayers = strings.Where(s => s.StartsWith("Modular Avatar", StringComparison.Ordinal) || s.StartsWith("MA Responsive", StringComparison.Ordinal)).ToList();
            int maParameters = strings.Count(s => s.StartsWith("__MA", StringComparison.Ordinal) || s.StartsWith("__ModularAvatar", StringComparison.Ordinal));
            if (maLayers.Count > 0 || maParameters > 0)
                found.Add(new Found
                {
                    Name = "Modular Avatar",
                    Evidence = Join(
                        maLayers.Count > 0 ? Count(maLayers.Count, "layer") + " like \"" + maLayers.OrderBy(s => s.Length).First() + "\"" : null,
                        maParameters > 0 ? Count(maParameters, "__MA parameter") : null)
                });

            Prefixed(found, strings, "Go/", 5, "GoGo Loco", "locomotion");
            Prefixed(found, strings, "v2/", 5, "Face tracking (VRCFaceTracking)", "face");
            Prefixed(found, strings, "OSCm/", 3, "OSCmooth", "smoothing");

            // d4rkpl4y3r's Avatar Optimizer: copies its controllers as "...(OptimizedCopy)" and uses its own shaders.
            var d4rkControllers = traces.Controllers.Where(c => c.IndexOf("(OptimizedCopy)", StringComparison.Ordinal) >= 0).ToList();
            var d4rkShaders = traces.Shaders.Where(s => s.IndexOf("d4rkpl4y3r", StringComparison.OrdinalIgnoreCase) >= 0).ToList();
            if (d4rkControllers.Count > 0 || d4rkShaders.Count > 0)
                found.Add(new Found
                {
                    Name = "d4rkpl4y3r Avatar Optimizer",
                    Evidence = Join(
                        d4rkControllers.Count > 0 ? Count(d4rkControllers.Count, "controller") + " ending \"(OptimizedCopy)\"" : null,
                        d4rkShaders.Count > 0 ? Count(d4rkShaders.Count, "optimizer shader") : null)
                });

            // Avatar Optimizer (AAO, anatawa12): merged meshes named "AAOGeneratedMesh...".
            int aaoMeshes = traces.Meshes.Count(m => m.StartsWith("AAOGeneratedMesh", StringComparison.Ordinal));
            if (aaoMeshes > 0)
                found.Add(new Found { Name = "Avatar Optimizer (AAO)", Evidence = Count(aaoMeshes, "mesh") + " named \"AAOGeneratedMesh...\"" });

            return found;
        }

        private static void Prefixed(List<Found> found, HashSet<string> strings, string prefix, int least, string name, string what)
        {
            int count = strings.Count(s => s.StartsWith(prefix, StringComparison.Ordinal));
            if (count >= least)
                found.Add(new Found { Name = name, Evidence = Count(count, what + " parameter") + " starting \"" + prefix + "\"" });
        }

        private static string Count(int count, string thing)
        {
            if (count == 1)
                return "1 " + thing;
            return count + " " + thing + (thing.EndsWith("sh", StringComparison.Ordinal) ? "es" : "s");
        }

        private static string Join(params string[] parts)
        {
            return string.Join(", ", parts.Where(p => !string.IsNullOrEmpty(p)));
        }

        /// <summary>What to tell the user about systems that are already baked in.</summary>
        internal const string BakedNote =
            "These were already baked in when the avatar was uploaded, so you don't need them installed to use or re-upload it.";

        internal const string StackWarning =
            "Adding VRCFury or Modular Avatar parts to the ripped avatar later can stack a second copy on top of what's already baked in.";
    }
}
#endif
