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

#if WPFMA_VRC_AVATARS
using UnityEditor.Animations;
using VRC.SDK3.Avatars.Components;
using VRC.SDK3.Avatars.ScriptableObjects;
#endif

namespace WPFMA
{
    internal static class WPFMAParameterBudgetSection
    {
        private const string PrefKey = "WPFMA.Tools.ParameterBudgetExpanded";

        internal static void Draw(GUIStyle sectionStyle)
        {
            if (!WPFMAToolSection.AvatarProject)
                return;

            WPFMAToolSection.Draw(sectionStyle, "Parameter budget", Detail(), PrefKey, Body);
        }

#if !WPFMA_VRC_AVATARS
        private static string Detail()
        {
            return "needs the avatar SDK";
        }

        private static void Body()
        {
            EditorGUILayout.HelpBox("This needs the VRChat avatar SDK, which is not in this project yet.", MessageType.Info);
        }
#else
        private sealed class Usage
        {
            public readonly HashSet<string> Animator = new HashSet<string>();
            public readonly HashSet<string> Menu = new HashSet<string>();
            public readonly HashSet<string> Components = new HashSet<string>();
            /// <summary>Named by Modular Avatar or VRCFury, which can add or use them when the avatar uploads.</summary>
            public readonly HashSet<string> AddOns = new HashSet<string>();
        }

        private static readonly string[] PhysBoneSuffixes = { "_IsGrabbed", "_IsPosed", "_Angle", "_Stretch", "_Squish" };

        private static readonly HashSet<string> BuiltIn = new HashSet<string>
        {
            "IsLocal", "PreviewMode", "Viseme", "Voice", "GestureLeft", "GestureRight", "GestureLeftWeight",
            "GestureRightWeight", "AngularY", "VelocityX", "VelocityY", "VelocityZ", "VelocityMagnitude",
            "Upright", "Grounded", "Seated", "AFK", "TrackingType", "VRMode", "MuteSelf", "InStation",
            "Earmuffs", "IsOnFriendsList", "AvatarVersion", "IsAnimatorEnabled", "ScaleModified", "ScaleFactor",
            "ScaleFactorInverse", "EyeHeightAsMeters", "EyeHeightAsPercent"
        };

        private static VRCAvatarDescriptor cachedFor;
        private static Usage usage;
        private static bool onlyProblems { get { return WPFMAToolDefaults.ParametersOnlyProblems; } set { WPFMAToolDefaults.ParametersOnlyProblems = value; } }
        private static Vector2 scroll;
        private static string status;

        private static VRCAvatarDescriptor Resolve()
        {
            var active = Selection.activeGameObject;
            return active != null && !EditorUtility.IsPersistent(active) ? active.GetComponentInParent<VRCAvatarDescriptor>() : null;
        }

        private static string Detail()
        {
            var avatar = Resolve();
            var asset = avatar != null ? avatar.expressionParameters : null;
            if (asset == null)
                return avatar == null ? "nothing selected" : "no parameters asset";

            return asset.CalcTotalCost() + " / " + VRCExpressionParameters.MAX_PARAMETER_COST + " bits";
        }

        private static void Body()
        {
            EditorGUILayout.LabelField(new GUIContent("Synced parameter bits, and unused ones.", "Shows how much of VRChat's 256-bit synced budget each parameter uses, and finds parameters " + "nothing uses or menu entries pointing at nothing."), WPFMAToolSection.Hint(WPFMAToolSection.MetaText));
            EditorGUILayout.Space(4f);

            var avatar = Resolve();
            if (avatar == null)
            {
                EditorGUILayout.LabelField("Select the avatar in the Hierarchy.", WPFMAToolSection.Hint(WPFMAToolSection.FaintText));
                return;
            }

            var asset = avatar.expressionParameters;
            if (asset == null)
            {
                EditorGUILayout.LabelField(new GUIContent("No parameters asset - Avatar setup makes one.", "This avatar has no Expression Parameters asset. Avatar setup can make one."), WPFMAToolSection.Hint(WPFMAToolSection.WarnAmber));
                return;
            }

            if (cachedFor != avatar || usage == null)
            {
                cachedFor = avatar;
                usage = Scan(avatar);
            }

            DrawBar(asset);

            using (new EditorGUILayout.HorizontalScope())
            {
                onlyProblems = EditorGUILayout.ToggleLeft("Only show problems", onlyProblems);
                if (GUILayout.Button("Rescan", GUILayout.Width(80f)))
                    usage = Scan(avatar);
            }

            var parameters = (asset.parameters ?? new VRCExpressionParameters.Parameter[0])
                .Where(p => p != null && !string.IsNullOrEmpty(p.name))
                .ToList();

            var unused = parameters.Where(p => !Used(p.name)).ToList();
            var orphans = usage.Menu.Where(n => !string.IsNullOrEmpty(n) && !BuiltIn.Contains(n) && !usage.AddOns.Contains(n) &&
                                               parameters.All(p => p.name != n)).ToList();

            if (unused.Count > 0)
            {
                EditorGUILayout.LabelField(
                    unused.Count + " parameter(s) are not used by any controller, menu, PhysBone or contact" +
                    (unused.Any(p => p.networkSynced) ? ", wasting " + unused.Where(p => p.networkSynced).Sum(p => VRCExpressionParameters.TypeCost(p.valueType)) + " synced bits." : "."),
                    WPFMAToolSection.Hint(WPFMAToolSection.WarnAmber));
            }

            if (orphans.Count > 0)
            {
                EditorGUILayout.LabelField(
                    "Menu controls use parameters that are not in the asset: " + string.Join(", ", orphans.ToArray()) +
                    ". Those controls do nothing unless a tool adds them at build time.",
                    WPFMAToolSection.Hint(WPFMAToolSection.WarnAmber));
            }

            EditorGUILayout.Space(4f);
            using (new EditorGUILayout.HorizontalScope())
            {
                EditorGUILayout.LabelField("Name", WPFMAToolSection.Hint(WPFMAToolSection.FaintText));
                EditorGUILayout.LabelField("Type", WPFMAToolSection.Hint(WPFMAToolSection.FaintText), GUILayout.Width(44f));
                EditorGUILayout.LabelField("Bits", WPFMAToolSection.Hint(WPFMAToolSection.FaintText), GUILayout.Width(30f));
                EditorGUILayout.LabelField("Synced", WPFMAToolSection.Hint(WPFMAToolSection.FaintText), GUILayout.Width(46f));
                EditorGUILayout.LabelField("Saved", WPFMAToolSection.Hint(WPFMAToolSection.FaintText), GUILayout.Width(42f));
                EditorGUILayout.LabelField("Used by", WPFMAToolSection.Hint(WPFMAToolSection.FaintText), GUILayout.Width(120f));
                GUILayout.Space(24f);
            }

            scroll = EditorGUILayout.BeginScrollView(scroll, GUILayout.MaxHeight(320f));
            foreach (var parameter in parameters.OrderByDescending(p => p.networkSynced ? VRCExpressionParameters.TypeCost(p.valueType) : 0)
                         .ThenBy(p => p.name))
            {
                bool used = Used(parameter.name);
                if (onlyProblems && used)
                    continue;

                DrawRow(asset, parameter, used);
            }
            EditorGUILayout.EndScrollView();

            EditorGUILayout.Space(4f);
            using (new EditorGUI.DisabledScope(unused.Count == 0))
            {
                if (GUILayout.Button("Remove " + unused.Count + " unused", GUILayout.Height(24f)))
                {
                    var names = unused.Select(p => p.name).ToList();
                    EditorApplication.delayCall += () => RemoveUnused(asset, names);
                }
            }

            EditorGUILayout.LabelField(new GUIContent("Add-ons can add more at upload.", "VRCFury and Modular Avatar can add parameters when you upload, so the final count can be higher than this."), WPFMAToolSection.Hint(WPFMAToolSection.FaintText));

            if (!string.IsNullOrEmpty(status))
                EditorGUILayout.LabelField(status, WPFMAToolSection.Hint(WPFMAToolSection.OkGreen));
        }

        private static void DrawBar(VRCExpressionParameters asset)
        {
            int cost = asset.CalcTotalCost();
            int max = VRCExpressionParameters.MAX_PARAMETER_COST;
            float fraction = Mathf.Clamp01(cost / (float)max);

            var color = cost > max ? WPFMAToolSection.ErrorRed
                : cost > max * 0.85f ? WPFMAToolSection.WarnAmber
                : WPFMAToolSection.OkGreen;

            var rect = GUILayoutUtility.GetRect(0f, 20f, GUILayout.ExpandWidth(true));
            EditorGUI.DrawRect(rect, WPFMAToolSection.ToolbarBackground);
            EditorGUI.DrawRect(new Rect(rect.x, rect.y, rect.width * fraction, rect.height), color);
            GUI.Label(rect, cost + " / " + max + " synced bits" + (cost > max ? "  -  over budget, it will not upload" : string.Empty),
                new GUIStyle(EditorStyles.boldLabel) { alignment = TextAnchor.MiddleCenter, normal = { textColor = Color.white } });
        }

        private static void DrawRow(VRCExpressionParameters asset, VRCExpressionParameters.Parameter parameter, bool used)
        {
            using (new EditorGUILayout.HorizontalScope())
            {
                EditorGUILayout.LabelField(new GUIContent(parameter.name, parameter.name),
                    WPFMAToolSection.Hint(used ? WPFMAToolSection.MetaText : WPFMAToolSection.WarnAmber));
                EditorGUILayout.LabelField(parameter.valueType.ToString(), WPFMAToolSection.Hint(WPFMAToolSection.FaintText), GUILayout.Width(44f));
                EditorGUILayout.LabelField(parameter.networkSynced ? VRCExpressionParameters.TypeCost(parameter.valueType).ToString() : "0",
                    WPFMAToolSection.Hint(WPFMAToolSection.FaintText), GUILayout.Width(30f));

                bool synced = EditorGUILayout.Toggle(parameter.networkSynced, GUILayout.Width(46f));
                bool saved = EditorGUILayout.Toggle(parameter.saved, GUILayout.Width(42f));
                if (synced != parameter.networkSynced || saved != parameter.saved)
                {
                    Undo.RecordObject(asset, "Edit parameter");
                    parameter.networkSynced = synced;
                    parameter.saved = saved;
                    EditorUtility.SetDirty(asset);
                }

                EditorGUILayout.LabelField(UsedBy(parameter.name), WPFMAToolSection.Hint(used ? WPFMAToolSection.FaintText : WPFMAToolSection.WarnAmber),
                    GUILayout.Width(120f));

                if (GUILayout.Button("x", EditorStyles.miniButton, GUILayout.Width(20f)))
                {
                    string name = parameter.name;
                    EditorApplication.delayCall += () => RemoveUnused(asset, new List<string> { name });
                }
            }
        }

        private static bool Used(string name)
        {
            return Used(usage, name);
        }

        private static bool Used(Usage found, string name)
        {
            return found.Animator.Contains(name) || found.Menu.Contains(name) || found.Components.Contains(name) || found.AddOns.Contains(name);
        }

        private static string UsedBy(string name)
        {
            var parts = new List<string>();
            if (usage.Animator.Contains(name))
                parts.Add("animator");
            if (usage.Menu.Contains(name))
                parts.Add("menu");
            if (usage.Components.Contains(name))
                parts.Add("bones/contacts");
            if (usage.AddOns.Contains(name))
                parts.Add("add-ons");
            return parts.Count == 0 ? "nothing" : string.Join(", ", parts.ToArray());
        }

        private static void RemoveUnused(VRCExpressionParameters asset, List<string> names)
        {
            if (!EditorUtility.DisplayDialog("Remove parameters",
                    "Remove " + names.Count + " parameter(s) from '" + asset.name + "'?\n\n" + string.Join("\n", names.Take(15).ToArray()) +
                    (names.Count > 15 ? "\n..." : string.Empty), "Remove", "Cancel"))
                return;

            status = WPFMAChangeLog.Run("Parameter budget", "Remove " + names.Count + " parameter(s)", new[] { AssetDatabase.GetAssetPath(asset) }, false, () =>
            {
                Undo.RecordObject(asset, "Remove parameters");
                asset.parameters = asset.parameters.Where(p => p == null || !names.Contains(p.name)).ToArray();
                EditorUtility.SetDirty(asset);
                AssetDatabase.SaveAssets();
                return "Removed " + names.Count + " parameter(s): " + string.Join(", ", names.Take(8).ToArray());
            });
        }

        internal static List<string> UnusedParameters(VRCAvatarDescriptor avatar)
        {
            List<string> unused, orphans;
            Problems(avatar, out unused, out orphans);
            return unused;
        }

        internal static List<string> MenuOrphans(VRCAvatarDescriptor avatar)
        {
            List<string> unused, orphans;
            Problems(avatar, out unused, out orphans);
            return orphans;
        }

        /// <summary>Parameters nothing uses, and menu controls pointing at parameters that don't exist, from one scan.</summary>
        internal static void Problems(VRCAvatarDescriptor avatar, out List<string> unused, out List<string> orphans)
        {
            unused = new List<string>();
            orphans = new List<string>();
            if (avatar == null)
                return;

            var asset = avatar.expressionParameters;
            var found = Scan(avatar);
            var names = asset != null && asset.parameters != null
                ? new HashSet<string>(asset.parameters.Where(p => p != null).Select(p => p.name))
                : new HashSet<string>();

            if (asset != null && asset.parameters != null)
            {
                unused = asset.parameters
                    .Where(p => p != null && !string.IsNullOrEmpty(p.name) && !Used(found, p.name))
                    .Select(p => p.name)
                    .ToList();
            }

            orphans = found.Menu.Where(n => !string.IsNullOrEmpty(n) && !BuiltIn.Contains(n) && !found.AddOns.Contains(n) && !names.Contains(n)).ToList();
        }

        // ---- Ints that only ever hold 0 or 1 ------------------------------------------------------------------------

        /// <summary>
        /// Synced Int parameters that are only ever 0 or 1: the menu only toggles them to 1, the animators only check
        /// for 0 or 1, and drivers only set 0 or 1. As Bools they cost 1 bit instead of 8 and work the same (VRChat
        /// converts a Bool to the animator's Int by itself). Anything an add-on uses is left alone.
        /// </summary>
        internal static List<string> IntsThatCouldBeBools(VRCAvatarDescriptor avatar)
        {
            var result = new List<string>();
            var asset = avatar != null ? avatar.expressionParameters : null;
            if (asset == null || asset.parameters == null)
                return result;

            var ints = new HashSet<string>(asset.parameters
                .Where(p => p != null && p.networkSynced && p.valueType == VRCExpressionParameters.ValueType.Int && !string.IsNullOrEmpty(p.name) &&
                            (p.defaultValue == 0f || p.defaultValue == 1f))
                .Select(p => p.name));
            if (ints.Count == 0)
                return result;

            var use = WPFMAAvatarAnimations.Use(avatar.gameObject);
            var found = Scan(avatar);
            ints.ExceptWith(use.Parameters);
            ints.ExceptWith(found.Components);

            var bad = new HashSet<string>();
            var seen = new HashSet<string>();
            CheckMenu(avatar.expressionsMenu, ints, bad, seen, new HashSet<VRCExpressionsMenu>());

            var controllers = WPFMAAvatarAnimations.Sources(avatar.gameObject, true).Select(s => s.Controller)
                .Concat(use.Controllers).OfType<AnimatorController>().Distinct();
            foreach (var controller in controllers)
            {
                foreach (var declared in controller.parameters)
                    if (ints.Contains(declared.name) && declared.type != AnimatorControllerParameterType.Int && declared.type != AnimatorControllerParameterType.Bool)
                        bad.Add(declared.name);

                foreach (var layer in controller.layers)
                    if (layer.stateMachine != null)
                        CheckMachine(layer.stateMachine, ints, bad, seen);
            }

            foreach (var source in WPFMAAvatarAnimations.Sources(avatar.gameObject, true).Where(s => s.Motion is BlendTree))
                CheckTree((BlendTree)source.Motion, ints, bad);

            result.AddRange(ints.Where(n => seen.Contains(n) && !bad.Contains(n)).OrderBy(n => n));
            return result;
        }

        internal static string MakeBools(VRCAvatarDescriptor avatar, List<string> names)
        {
            var asset = avatar.expressionParameters;
            Undo.RecordObject(asset, "Make parameters Bools");
            int changed = 0;
            foreach (var parameter in asset.parameters)
            {
                if (parameter == null || !names.Contains(parameter.name) || parameter.valueType != VRCExpressionParameters.ValueType.Int)
                    continue;
                parameter.valueType = VRCExpressionParameters.ValueType.Bool;
                parameter.defaultValue = parameter.defaultValue >= 1f ? 1f : 0f;
                changed++;
            }
            EditorUtility.SetDirty(asset);
            AssetDatabase.SaveAssets();
            return "Made " + changed + " parameter(s) Bools, saving " + changed * 7 + " synced bits: " + string.Join(", ", names.Take(8).ToArray());
        }

        private static bool ZeroOrOne(float value)
        {
            return value == 0f || value == 1f;
        }

        private static void CheckMenu(VRCExpressionsMenu menu, HashSet<string> ints, HashSet<string> bad, HashSet<string> seen, HashSet<VRCExpressionsMenu> walked)
        {
            if (menu == null || !walked.Add(menu) || menu.controls == null)
                return;

            foreach (var control in menu.controls)
            {
                if (control == null)
                    continue;

                string name = control.parameter != null ? control.parameter.name : null;
                if (!string.IsNullOrEmpty(name) && ints.Contains(name))
                {
                    seen.Add(name);
                    bool simple = control.type == VRCExpressionsMenu.Control.ControlType.Toggle ||
                                  control.type == VRCExpressionsMenu.Control.ControlType.Button ||
                                  control.type == VRCExpressionsMenu.Control.ControlType.SubMenu;
                    if (!simple || !ZeroOrOne(control.value))
                        bad.Add(name);
                }

                if (control.subParameters != null)
                    foreach (var sub in control.subParameters)
                        if (sub != null && !string.IsNullOrEmpty(sub.name) && ints.Contains(sub.name))
                            bad.Add(sub.name);

                if (control.type == VRCExpressionsMenu.Control.ControlType.SubMenu)
                    CheckMenu(control.subMenu, ints, bad, seen, walked);
            }
        }

        private static void CheckMachine(AnimatorStateMachine machine, HashSet<string> ints, HashSet<string> bad, HashSet<string> seen)
        {
            CheckTransitions(machine.anyStateTransitions, ints, bad, seen);
            CheckTransitions(machine.entryTransitions, ints, bad, seen);
            CheckBehaviours(machine.behaviours, ints, bad, seen);

            foreach (var child in machine.states)
            {
                var state = child.state;
                if (state == null)
                    continue;

                CheckTransitions(state.transitions, ints, bad, seen);
                CheckBehaviours(state.behaviours, ints, bad, seen);
                foreach (var name in new[] { state.speedParameter, state.cycleOffsetParameter, state.mirrorParameter, state.timeParameter })
                    if (!string.IsNullOrEmpty(name) && ints.Contains(name))
                        bad.Add(name);
                CheckTree(state.motion as BlendTree, ints, bad);
            }

            foreach (var sub in machine.stateMachines)
            {
                if (sub.stateMachine == null)
                    continue;
                CheckTransitions(machine.GetStateMachineTransitions(sub.stateMachine), ints, bad, seen);
                CheckMachine(sub.stateMachine, ints, bad, seen);
            }
        }

        private static void CheckTransitions(IEnumerable<AnimatorTransitionBase> transitions, HashSet<string> ints, HashSet<string> bad, HashSet<string> seen)
        {
            foreach (var transition in transitions)
            {
                if (transition == null)
                    continue;
                foreach (var condition in transition.conditions)
                {
                    if (!ints.Contains(condition.parameter))
                        continue;
                    seen.Add(condition.parameter);

                    bool fine = ((condition.mode == AnimatorConditionMode.Equals || condition.mode == AnimatorConditionMode.NotEqual) && ZeroOrOne(condition.threshold)) ||
                                (condition.mode == AnimatorConditionMode.Greater && condition.threshold == 0f) ||
                                (condition.mode == AnimatorConditionMode.Less && condition.threshold == 1f) ||
                                condition.mode == AnimatorConditionMode.If || condition.mode == AnimatorConditionMode.IfNot;
                    if (!fine)
                        bad.Add(condition.parameter);
                }
            }
        }

        /// <summary>Avatar Parameter Drivers may only set them to 0 or 1 (copying from them is fine).</summary>
        private static void CheckBehaviours(StateMachineBehaviour[] behaviours, HashSet<string> ints, HashSet<string> bad, HashSet<string> seen)
        {
            foreach (var behaviour in behaviours)
            {
                if (behaviour == null || behaviour.GetType().Name != "VRCAvatarParameterDriver")
                    continue;

                var list = new SerializedObject(behaviour).FindProperty("parameters");
                if (list == null || !list.isArray)
                    continue;

                for (int i = 0; i < list.arraySize; i++)
                {
                    var entry = list.GetArrayElementAtIndex(i);
                    var name = entry.FindPropertyRelative("name");
                    if (name == null || !ints.Contains(name.stringValue))
                        continue;

                    seen.Add(name.stringValue);
                    var type = entry.FindPropertyRelative("type");
                    var value = entry.FindPropertyRelative("value");
                    bool set = type != null && type.enumValueIndex == 0;
                    if (!set || value == null || !ZeroOrOne(value.floatValue))
                        bad.Add(name.stringValue);
                }
            }
        }

        private static void CheckTree(BlendTree tree, HashSet<string> ints, HashSet<string> bad)
        {
            if (tree == null)
                return;
            foreach (var name in new[] { tree.blendParameter, tree.blendParameterY })
                if (!string.IsNullOrEmpty(name) && ints.Contains(name))
                    bad.Add(name);
            foreach (var child in tree.children)
            {
                if (!string.IsNullOrEmpty(child.directBlendParameter) && ints.Contains(child.directBlendParameter))
                    bad.Add(child.directBlendParameter);
                if (child.motion != tree)
                    CheckTree(child.motion as BlendTree, ints, bad);
            }
        }

        private static Usage Scan(VRCAvatarDescriptor avatar)
        {
            return WPFMAAvatarAnimations.Memo("parameters", avatar, () => ScanNow(avatar));
        }

        private static Usage ScanNow(VRCAvatarDescriptor avatar)
        {
            var result = new Usage();

            // The avatar's layers, Modular Avatar merges and the controllers VRCFury adds.
            var addOns = WPFMAAvatarAnimations.Use(avatar.gameObject);
            result.Animator.UnionWith(WPFMAAvatarAnimations.AnimatorParameters(avatar.gameObject, addOns));
            result.AddOns.UnionWith(addOns.Parameters);

            WalkMenu(avatar.expressionsMenu, result.Menu, new HashSet<VRCExpressionsMenu>());

            foreach (var component in avatar.GetComponentsInChildren<Component>(true))
            {
                if (component == null || component.GetType().Namespace == null || !component.GetType().Namespace.StartsWith("VRC"))
                    continue;

                var property = new SerializedObject(component).FindProperty("parameter");
                if (property == null || property.propertyType != SerializedPropertyType.String || string.IsNullOrEmpty(property.stringValue))
                    continue;

                result.Components.Add(property.stringValue);
                foreach (var suffix in PhysBoneSuffixes)
                    result.Components.Add(property.stringValue + suffix);
            }

            return result;
        }

        private static void WalkMenu(VRCExpressionsMenu menu, HashSet<string> names, HashSet<VRCExpressionsMenu> seen)
        {
            if (menu == null || !seen.Add(menu) || menu.controls == null)
                return;

            foreach (var control in menu.controls)
            {
                if (control == null)
                    continue;

                if (control.parameter != null && !string.IsNullOrEmpty(control.parameter.name))
                    names.Add(control.parameter.name);

                if (control.subParameters != null)
                {
                    foreach (var sub in control.subParameters)
                    {
                        if (sub != null && !string.IsNullOrEmpty(sub.name))
                            names.Add(sub.name);
                    }
                }

                if (control.type == VRCExpressionsMenu.Control.ControlType.SubMenu)
                    WalkMenu(control.subMenu, names, seen);
            }
        }
#endif
    }
}
#endif
