// 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
#if WPFMA_VRC_AVATARS
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnityEditor;
using UnityEditor.Animations;
using UnityEngine;
using VRC.SDK3.Avatars.Components;
using VRC.SDK3.Avatars.ScriptableObjects;

namespace WPFMA
{
    internal static class WPFMAToggleCreator
    {
        internal enum WriteDefaults
        {
            MatchAvatar,
            On,
            Off
        }

        internal sealed class Request
        {
            public VRCAvatarDescriptor Avatar;
            public List<GameObject> Targets = new List<GameObject>();

            public string Name = "New Toggle";

            public string ParameterName = string.Empty;

            public bool DefaultOn = true;
            public bool Saved = true;
            public bool Synced = true;
            public bool AddToMenu = true;
            public Texture2D Icon;
            public WriteDefaults WriteDefaults = WriteDefaults.MatchAvatar;
            public string Folder;

            public VRCExpressionsMenu Menu;

            public bool UseExistingClips;
            public AnimationClip ExistingOn;
            public AnimationClip ExistingOff;

            /// <summary>Goes into the one shared toggles layer instead of a layer of its own (every layer costs the avatar).</summary>
            public bool Combined = true;
        }

        internal sealed class Result
        {
            public bool Success;
            public string Message;
            public readonly List<string> Notes = new List<string>();
            public AnimationClip OnClip;
            public AnimationClip OffClip;
            /// <summary>Files it made, so the Change log can remove them when it's reverted.</summary>
            public readonly List<string> Created = new List<string>();
        }

        internal sealed class MenuEntry
        {
            public VRCExpressionsMenu Menu;
            public string Path;
            public int Depth;

            public bool Full
            {
                get { return Menu != null && Menu.controls.Count >= VRCExpressionsMenu.MAX_CONTROLS; }
            }

            public string Label
            {
                get
                {
                    return new string(' ', Depth * 2) + Path +
                           (Menu != null ? "  (" + Menu.controls.Count + " of " + VRCExpressionsMenu.MAX_CONTROLS + ")" : string.Empty);
                }
            }
        }

        internal static List<MenuEntry> EnumerateMenus(VRCAvatarDescriptor avatar)
        {
            var entries = new List<MenuEntry>();
            if (avatar == null || avatar.expressionsMenu == null)
                return entries;

            Walk(avatar.expressionsMenu, avatar.expressionsMenu.name, 0, entries, new HashSet<VRCExpressionsMenu>());
            return entries;
        }

        private static void Walk(VRCExpressionsMenu menu, string path, int depth,
            List<MenuEntry> entries, HashSet<VRCExpressionsMenu> seen)
        {
            if (menu == null || !seen.Add(menu))
                return;

            entries.Add(new MenuEntry { Menu = menu, Path = path, Depth = depth });

            foreach (var control in menu.controls)
            {
                if (control == null || control.type != VRCExpressionsMenu.Control.ControlType.SubMenu)
                    continue;

                if (control.subMenu != null)
                    Walk(control.subMenu, control.name, depth + 1, entries, seen);
            }
        }

        internal static VRCExpressionsMenu CreateSubmenu(VRCExpressionsMenu parent, string name, out string problem)
        {
            problem = null;

            if (parent == null)
            {
                problem = "Pick the menu to add it to first.";
                return null;
            }

            if (parent.controls.Count >= VRCExpressionsMenu.MAX_CONTROLS)
            {
                problem = "'" + parent.name + "' is already full, so a submenu cannot be added to it.";
                return null;
            }

            if (string.IsNullOrWhiteSpace(name))
                name = "New Menu";

            string parentPath = AssetDatabase.GetAssetPath(parent);
            string folder = string.IsNullOrEmpty(parentPath)
                ? "Assets"
                : Path.GetDirectoryName(parentPath).Replace('\\', '/');

            var submenu = ScriptableObject.CreateInstance<VRCExpressionsMenu>();
            submenu.name = name;
            submenu.controls = new List<VRCExpressionsMenu.Control>();

            string assetPath = AssetDatabase.GenerateUniqueAssetPath(folder + "/" + WPFMAPaths.SafeFileName(name) + ".asset");
            AssetDatabase.CreateAsset(submenu, assetPath);

            Undo.RegisterCompleteObjectUndo(parent, "Create submenu");
            parent.controls.Add(new VRCExpressionsMenu.Control
            {
                name = name,
                type = VRCExpressionsMenu.Control.ControlType.SubMenu,
                subMenu = submenu,
                parameter = new VRCExpressionsMenu.Control.Parameter { name = string.Empty }
            });

            EditorUtility.SetDirty(parent);
            AssetDatabase.SaveAssets();
            return submenu;
        }

        internal static VRCExpressionsMenu ResolveMenu(Request request)
        {
            if (request == null)
                return null;

            if (request.Menu != null)
                return request.Menu;

            return request.Avatar != null ? request.Avatar.expressionsMenu : null;
        }

        internal static List<string> Validate(Request request)
        {
            var problems = new List<string>();
            if (request == null)
            {
                problems.Add("Nothing to build.");
                return problems;
            }

            if (request.Avatar == null)
                problems.Add("Pick an avatar with a VRCAvatarDescriptor.");

            if (string.IsNullOrWhiteSpace(request.Name))
                problems.Add("Give the toggle a name.");

            var targets = request.Targets.Where(t => t != null).ToList();
            if (request.UseExistingClips)
            {
                if (request.ExistingOn == null)
                    problems.Add("Pick the ON animation, or turn off 'Use existing animations'.");
            }
            else if (targets.Count == 0)
            {
                problems.Add("Pick at least one object to toggle.");
            }

            if (request.Avatar != null)
            {
                foreach (var target in request.UseExistingClips ? new List<GameObject>() : targets)
                {
                    if (!target.transform.IsChildOf(request.Avatar.transform))
                        problems.Add("'" + target.name + "' is not inside the avatar.");
                    else if (target.transform == request.Avatar.transform)
                        problems.Add("The avatar root cannot toggle itself.");
                }

                var fx = FindFxController(request.Avatar);
                if (fx == null)
                    problems.Add("The avatar has no FX controller on its FX playable layer.");
                else if (!(fx is AnimatorController))
                    problems.Add("The FX playable layer is not an AnimatorController, so a layer cannot be added to it.");
                else if (string.IsNullOrEmpty(AssetDatabase.GetAssetPath(fx)))
                    problems.Add("The FX controller is not saved as an asset.");

                if (request.Avatar.expressionParameters == null && (request.Synced || request.AddToMenu))
                    problems.Add("The avatar has no Expression Parameters asset to add the parameter to. Avatar setup can make one.");

                var menu = ResolveMenu(request);
                if (request.AddToMenu && menu == null)
                    problems.Add("The avatar has no Expressions Menu asset to add the control to.");

                if (request.AddToMenu && menu != null && menu.controls.Count >= VRCExpressionsMenu.MAX_CONTROLS)
                {
                    problems.Add("'" + menu.name + "' already holds " + VRCExpressionsMenu.MAX_CONTROLS +
                                 " controls, which is the limit. Pick another menu, add a submenu, or turn off 'Add to menu'.");
                }
            }

            return problems;
        }

        internal static Result Create(Request request)
        {
            var result = new Result();

            var problems = Validate(request);
            if (problems.Count > 0)
            {
                result.Message = problems[0];
                return result;
            }

            var controller = (AnimatorController)FindFxController(request.Avatar);

            string wanted = SafeParameterName(string.IsNullOrWhiteSpace(request.ParameterName)
                ? request.Name
                : request.ParameterName);

            string parameter = UniqueParameterName(controller, request.Avatar, wanted);
            if (parameter != wanted)
                result.Notes.Add("A parameter named '" + wanted + "' already existed, so this one is '" + parameter + "'.");

            string folder = ResolveFolder(request, controller);
            var targets = request.Targets.Where(t => t != null).ToList();

            if (request.UseExistingClips)
            {
                result.OnClip = request.ExistingOn;
                result.OffClip = request.ExistingOff;

                if (result.OffClip == null)
                {
                    result.Notes.Add("No OFF animation given, so the Off state is empty. That only behaves " +
                                     "correctly with write defaults on.");
                }
            }
            else
            {
                try
                {
                    AssetDatabase.StartAssetEditing();

                    result.OnClip = BuildClip(request.Avatar, targets, folder, request.Name + " ON", true);
                    result.OffClip = BuildClip(request.Avatar, targets, folder, request.Name + " OFF", false);
                    result.Created.Add(AssetDatabase.GetAssetPath(result.OnClip));
                    result.Created.Add(AssetDatabase.GetAssetPath(result.OffClip));
                }
                finally
                {
                    AssetDatabase.StopAssetEditing();
                }

                AssetDatabase.SaveAssets();
            }

            // The shared layer is safe next to write-defaults-off layers too: its on and off clips set the same things.
            bool combined = request.Combined && request.WriteDefaults != WriteDefaults.Off;
            if (combined)
            {
                AddToCombined(controller, parameter, request.Name, request.DefaultOn, result.OnClip, result.OffClip);
                result.Notes.Add("Added to the shared '" + CombinedLayerName + "' layer, so the FX controller didn't get another layer.");
            }
            else
            {
                bool writeDefaults = ResolveWriteDefaults(request, controller, result);
                AddLayer(controller, parameter, request, result.OnClip, result.OffClip, writeDefaults);
                if (request.Combined)
                    result.Notes.Add("Write defaults is set to Off, so it got a layer of its own (the shared layer needs write defaults on).");
            }

            // A local-only toggle still needs its parameter listed (unsynced, so it costs nothing), or the menu button does nothing.
            if (request.Synced || request.AddToMenu)
                AddParameter(request, parameter, result);

            if (request.AddToMenu)
                AddMenuControl(request, parameter, result);

            AssetDatabase.SaveAssets();

            result.Success = true;
            result.Message = request.UseExistingClips
                ? "Built '" + request.Name + "' from existing animations."
                : "Built '" + request.Name + "' on " + targets.Count + (targets.Count == 1 ? " object." : " objects.");
            return result;
        }

        private static AnimationClip BuildClip(VRCAvatarDescriptor avatar, List<GameObject> targets,
            string folder, string name, bool active)
        {
            var clip = new AnimationClip { name = WPFMAPaths.SafeFileName(name) };
            var curve = AnimationCurve.Constant(0f, 1f / 60f, active ? 1f : 0f);

            foreach (var target in targets)
            {
                string path = AnimationUtility.CalculateTransformPath(target.transform, avatar.transform);
                var binding = EditorCurveBinding.FloatCurve(path, typeof(GameObject), "m_IsActive");
                AnimationUtility.SetEditorCurve(clip, binding, curve);
            }

            string assetPath = AssetDatabase.GenerateUniqueAssetPath(folder + "/" + WPFMAPaths.SafeFileName(name) + ".anim");
            AssetDatabase.CreateAsset(clip, assetPath);
            return clip;
        }

        private static void AddLayer(AnimatorController controller, string parameter, Request request,
            AnimationClip onClip, AnimationClip offClip, bool writeDefaults)
        {
            Undo.RegisterCompleteObjectUndo(controller, "Create toggle");

            if (!controller.parameters.Any(p => p.name == parameter))
                controller.AddParameter(parameter, AnimatorControllerParameterType.Bool);

            var layer = new AnimatorControllerLayer
            {
                name = UniqueLayerName(controller, request.Name),
                defaultWeight = 1f,
                stateMachine = new AnimatorStateMachine
                {
                    name = UniqueLayerName(controller, request.Name),
                    hideFlags = HideFlags.HideInHierarchy
                }
            };

            string controllerPath = AssetDatabase.GetAssetPath(controller);
            if (!string.IsNullOrEmpty(controllerPath))
                AssetDatabase.AddObjectToAsset(layer.stateMachine, controllerPath);

            var machine = layer.stateMachine;
            var offState = machine.AddState("Off");
            var onState = machine.AddState("On");

            offState.motion = offClip;
            onState.motion = onClip;
            offState.writeDefaultValues = writeDefaults;
            onState.writeDefaultValues = writeDefaults;

            machine.defaultState = request.DefaultOn ? onState : offState;

            var toOn = offState.AddTransition(onState);
            toOn.hasExitTime = false;
            toOn.duration = 0f;
            toOn.AddCondition(AnimatorConditionMode.If, 0f, parameter);

            var toOff = onState.AddTransition(offState);
            toOff.hasExitTime = false;
            toOff.duration = 0f;
            toOff.AddCondition(AnimatorConditionMode.IfNot, 0f, parameter);

            controller.AddLayer(layer);
            EditorUtility.SetDirty(controller);
        }

        // ---- The shared toggles layer ---------------------------------------------------------------------------
        // Every toggle used to get a layer of its own, and every layer costs the avatar each frame. The shared layer
        // is one state playing a Direct blend tree with a small on/off tree per toggle - the usual way to make
        // toggles cheap. Its parameters are Floats in the animator (blend trees need them); the menu's Bools still
        // drive them, because VRChat converts between the two.

        internal const string CombinedLayerName = "WPFMA Toggles";
        internal const string OneParameter = "WPFMA/One";

        internal sealed class SimpleToggle
        {
            public AnimatorControllerLayer Layer;
            public string Parameter;
            public bool DefaultOn;
            public AnimationClip On;
            public AnimationClip Off;
        }

        private static void AddToCombined(AnimatorController controller, string parameter, string name, bool defaultOn,
            AnimationClip onClip, AnimationClip offClip)
        {
            Undo.RegisterCompleteObjectUndo(controller, "Create toggle");
            var tree = CombinedTree(controller);
            SetFloatParameter(controller, parameter, defaultOn ? 1f : 0f);
            AddToggleTree(controller, tree, name, parameter, onClip, offClip);
            EditorUtility.SetDirty(controller);
        }

        /// <summary>The shared layer's Direct blend tree, made (with its layer) the first time.</summary>
        private static BlendTree CombinedTree(AnimatorController controller)
        {
            foreach (var layer in controller.layers)
            {
                if (layer.stateMachine == null || !layer.name.StartsWith(CombinedLayerName, StringComparison.Ordinal))
                    continue;
                foreach (var child in layer.stateMachine.states)
                {
                    var existing = child.state != null ? child.state.motion as BlendTree : null;
                    if (existing != null && existing.blendType == BlendTreeType.Direct)
                        return existing;
                }
            }

            SetFloatParameter(controller, OneParameter, 1f);
            string path = AssetDatabase.GetAssetPath(controller);

            var machine = new AnimatorStateMachine { name = CombinedLayerName, hideFlags = HideFlags.HideInHierarchy };
            AssetDatabase.AddObjectToAsset(machine, path);
            var tree = new BlendTree { name = CombinedLayerName, blendType = BlendTreeType.Direct, hideFlags = HideFlags.HideInHierarchy };
            AssetDatabase.AddObjectToAsset(tree, path);

            var state = machine.AddState("Toggles");
            state.motion = tree;
            state.writeDefaultValues = true;
            machine.defaultState = state;

            controller.AddLayer(new AnimatorControllerLayer
            {
                name = UniqueLayerName(controller, CombinedLayerName),
                defaultWeight = 1f,
                stateMachine = machine
            });
            return tree;
        }

        private static void AddToggleTree(AnimatorController controller, BlendTree combined, string name, string parameter,
            AnimationClip onClip, AnimationClip offClip)
        {
            var toggle = new BlendTree
            {
                name = name,
                blendType = BlendTreeType.Simple1D,
                blendParameter = parameter,
                useAutomaticThresholds = false,
                hideFlags = HideFlags.HideInHierarchy
            };
            AssetDatabase.AddObjectToAsset(toggle, AssetDatabase.GetAssetPath(controller));
            toggle.children = new[]
            {
                new ChildMotion { motion = offClip, threshold = 0f, timeScale = 1f },
                new ChildMotion { motion = onClip, threshold = 1f, timeScale = 1f }
            };

            var children = combined.children.ToList();
            children.Add(new ChildMotion { motion = toggle, directBlendParameter = OneParameter, timeScale = 1f });
            combined.children = children.ToArray();
            EditorUtility.SetDirty(toggle);
            EditorUtility.SetDirty(combined);
        }

        /// <summary>Adds the parameter as a Float, or turns an existing one into a Float (keeping its default).</summary>
        private static void SetFloatParameter(AnimatorController controller, string name, float value)
        {
            var parameters = controller.parameters;
            int index = Array.FindIndex(parameters, p => p.name == name);
            if (index < 0)
            {
                controller.AddParameter(new AnimatorControllerParameter { name = name, type = AnimatorControllerParameterType.Float, defaultFloat = value });
                return;
            }

            if (parameters[index].type == AnimatorControllerParameterType.Float)
                return;
            parameters[index].type = AnimatorControllerParameterType.Float;
            parameters[index].defaultFloat = value;
            controller.parameters = parameters;
        }

        /// <summary>
        /// Toggle layers that can move into the shared layer and behave exactly the same: two states that only play an
        /// on and an off clip (setting the same things), switched instantly by one Bool that nothing else in the
        /// controller checks. Anything fancier (fades, masks, drivers, more states) is left alone.
        /// </summary>
        internal static List<SimpleToggle> Combinable(AnimatorController controller)
        {
            var found = new List<SimpleToggle>();
            if (controller == null)
                return found;

            var layers = controller.layers;
            for (int i = 1; i < layers.Length; i++)
            {
                var toggle = AsSimpleToggle(controller, layers[i]);
                if (toggle != null)
                    found.Add(toggle);
            }

            // A parameter another layer also checks has to stay a Bool, so those toggles stay as they are.
            return found.Where(t => !UsedElsewhere(layers, t)).ToList();
        }

        private static SimpleToggle AsSimpleToggle(AnimatorController controller, AnimatorControllerLayer layer)
        {
            var machine = layer.stateMachine;
            if (machine == null || layer.name.StartsWith(CombinedLayerName, StringComparison.Ordinal) || layer.avatarMask != null ||
                layer.blendingMode != AnimatorLayerBlendingMode.Override || layer.syncedLayerIndex >= 0 || layer.defaultWeight < 0.999f ||
                machine.states.Length != 2 || machine.stateMachines.Length != 0 || machine.behaviours.Length != 0 ||
                machine.entryTransitions.Length != 0)
                return null;

            var a = machine.states[0].state;
            var b = machine.states[1].state;
            if (a == null || b == null || a.behaviours.Length != 0 || b.behaviours.Length != 0 ||
                !(a.motion is AnimationClip) || !(b.motion is AnimationClip) || a.timeParameterActive || b.timeParameterActive)
                return null;

            string parameter = null;
            AnimatorState on = null, off = null;
            var transitions = a.transitions.Concat(b.transitions).Concat(machine.anyStateTransitions).ToList();
            if (transitions.Count == 0)
                return null;

            foreach (var transition in transitions)
            {
                if (transition.isExit || transition.mute || transition.solo || transition.hasExitTime || transition.duration > 0f ||
                    transition.conditions.Length != 1 || (transition.destinationState != a && transition.destinationState != b))
                    return null;

                var condition = transition.conditions[0];
                if (parameter == null)
                    parameter = condition.parameter;
                if (condition.parameter != parameter)
                    return null;

                if (condition.mode == AnimatorConditionMode.If)
                {
                    if (on != null && on != transition.destinationState)
                        return null;
                    on = transition.destinationState;
                }
                else if (condition.mode == AnimatorConditionMode.IfNot)
                {
                    if (off != null && off != transition.destinationState)
                        return null;
                    off = transition.destinationState;
                }
                else
                    return null;
            }

            if (on == null || off == null || on == off)
                return null;

            var declared = controller.parameters.FirstOrDefault(p => p.name == parameter);
            if (declared == null || declared.type != AnimatorControllerParameterType.Bool)
                return null;

            var onClip = (AnimationClip)on.motion;
            var offClip = (AnimationClip)off.motion;
            if (!SameBindings(onClip, offClip))
                return null;

            return new SimpleToggle { Layer = layer, Parameter = parameter, DefaultOn = declared.defaultBool, On = onClip, Off = offClip };
        }

        private static bool SameBindings(AnimationClip a, AnimationClip b)
        {
            Func<AnimationClip, HashSet<string>> keys = clip => new HashSet<string>(
                AnimationUtility.GetCurveBindings(clip).Concat(AnimationUtility.GetObjectReferenceCurveBindings(clip))
                    .Select(x => x.path + "|" + x.type.FullName + "|" + x.propertyName));
            var ka = keys(a);
            return ka.Count > 0 && ka.SetEquals(keys(b));
        }

        private static bool UsedElsewhere(AnimatorControllerLayer[] layers, SimpleToggle toggle)
        {
            foreach (var layer in layers)
            {
                if (layer == toggle.Layer || layer.stateMachine == null || layer.stateMachine == toggle.Layer.stateMachine)
                    continue;
                if (MachineUses(layer.stateMachine, toggle.Parameter))
                    return true;
            }
            return false;
        }

        private static bool MachineUses(AnimatorStateMachine machine, string parameter)
        {
            Func<IEnumerable<AnimatorTransitionBase>, bool> checks = list => list.Any(t => t != null && t.conditions.Any(c => c.parameter == parameter));
            if (checks(machine.anyStateTransitions) || checks(machine.entryTransitions))
                return true;

            foreach (var child in machine.states)
            {
                var state = child.state;
                if (state == null)
                    continue;
                if (checks(state.transitions) || state.speedParameter == parameter || state.cycleOffsetParameter == parameter ||
                    state.mirrorParameter == parameter || state.timeParameter == parameter || TreeUses(state.motion as BlendTree, parameter))
                    return true;
            }

            foreach (var sub in machine.stateMachines)
            {
                if (sub.stateMachine != null && (checks(machine.GetStateMachineTransitions(sub.stateMachine)) || MachineUses(sub.stateMachine, parameter)))
                    return true;
            }
            return false;
        }

        private static bool TreeUses(BlendTree tree, string parameter)
        {
            if (tree == null)
                return false;
            if (tree.blendParameter == parameter || tree.blendParameterY == parameter)
                return true;
            return tree.children.Any(c => c.directBlendParameter == parameter || (c.motion != tree && TreeUses(c.motion as BlendTree, parameter)));
        }

        /// <summary>Moves every simple toggle layer on the avatar's FX into the shared layer.</summary>
        internal static string CombineExisting(VRCAvatarDescriptor avatar)
        {
            var controller = FindFxController(avatar) as AnimatorController;
            if (controller == null || string.IsNullOrEmpty(AssetDatabase.GetAssetPath(controller)))
                return "The avatar has no FX controller saved as an asset.";

            var toggles = Combinable(controller);
            if (toggles.Count == 0)
                return "No toggle layers that can be combined without changing how they work.";

            int before = controller.layers.Length;
            Undo.RegisterCompleteObjectUndo(controller, "Combine toggles");
            var tree = CombinedTree(controller);

            foreach (var toggle in toggles)
            {
                SetFloatParameter(controller, toggle.Parameter, toggle.DefaultOn ? 1f : 0f);
                AddToggleTree(controller, tree, toggle.Layer.name, toggle.Parameter, toggle.On, toggle.Off);
            }

            foreach (var toggle in toggles)
            {
                int index = Array.FindIndex(controller.layers, l => l.stateMachine == toggle.Layer.stateMachine);
                if (index >= 0)
                    controller.RemoveLayer(index);
            }

            EditorUtility.SetDirty(controller);
            AssetDatabase.SaveAssets();
            return "Combined " + toggles.Count + " toggle layer(s) into '" + CombinedLayerName + "'. The FX controller went from " +
                   before + " to " + controller.layers.Length + " layers.";
        }

        private static bool ResolveWriteDefaults(Request request, AnimatorController controller, Result result)
        {
            if (request.WriteDefaults == WriteDefaults.On)
                return true;
            if (request.WriteDefaults == WriteDefaults.Off)
                return false;

            int on = 0, off = 0;
            foreach (var layer in controller.layers)
            {
                if (layer.stateMachine == null)
                    continue;

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

                    if (child.state.writeDefaultValues)
                        on++;
                    else
                        off++;
                }
            }

            if (on > 0 && off > 0)
                result.Notes.Add("This controller mixes write defaults (" + on + " on, " + off + " off), which causes " +
                                 "properties to stick. Matching the majority for now - worth making it consistent.");

            bool matched = on >= off && on > 0;
            if (on + off > 0)
                result.Notes.Add("Write defaults set to " + (matched ? "on" : "off") + " to match the controller.");

            return matched;
        }

        internal static RuntimeAnimatorController FindFxController(VRCAvatarDescriptor avatar)
        {
            if (avatar == null || avatar.baseAnimationLayers == null)
                return null;

            foreach (var layer in avatar.baseAnimationLayers)
            {
                if (layer.type == VRCAvatarDescriptor.AnimLayerType.FX && !layer.isDefault)
                    return layer.animatorController;
            }

            return null;
        }

        private static void AddParameter(Request request, string parameter, Result result)
        {
            var asset = request.Avatar.expressionParameters;
            if (asset == null)
                return;

            Undo.RegisterCompleteObjectUndo(asset, "Create toggle");

            var parameters = asset.parameters != null
                ? asset.parameters.ToList()
                : new List<VRCExpressionParameters.Parameter>();

            parameters.Add(new VRCExpressionParameters.Parameter
            {
                name = parameter,
                valueType = VRCExpressionParameters.ValueType.Bool,
                defaultValue = request.DefaultOn ? 1f : 0f,
                saved = request.Saved,
                networkSynced = request.Synced
            });

            asset.parameters = parameters.ToArray();
            EditorUtility.SetDirty(asset);

            int cost = asset.CalcTotalCost();
            if (cost > VRCExpressionParameters.MAX_PARAMETER_COST)
            {
                result.Notes.Add("Parameter budget is now " + cost + " of " + VRCExpressionParameters.MAX_PARAMETER_COST +
                                 ", which is over. The avatar will not upload until something is removed or unsynced.");
            }
        }

        private static void AddMenuControl(Request request, string parameter, Result result)
        {
            var menu = ResolveMenu(request);
            if (menu == null)
                return;

            Undo.RegisterCompleteObjectUndo(menu, "Create toggle");

            menu.controls.Add(new VRCExpressionsMenu.Control
            {
                name = request.Name,
                icon = request.Icon,
                type = VRCExpressionsMenu.Control.ControlType.Toggle,
                parameter = new VRCExpressionsMenu.Control.Parameter { name = parameter },
                value = 1f
            });

            EditorUtility.SetDirty(menu);
            result.Notes.Add("Added to " + menu.name + " (" + menu.controls.Count + " of " +
                             VRCExpressionsMenu.MAX_CONTROLS + " controls).");
        }

        private static string SafeParameterName(string name)
        {
            if (string.IsNullOrWhiteSpace(name))
                return "Toggle";

            var cleaned = new string(name.Trim().Select(c => char.IsLetterOrDigit(c) || c == '_' ? c : '_').ToArray());
            return char.IsDigit(cleaned[0]) ? "_" + cleaned : cleaned;
        }

        private static string UniqueParameterName(AnimatorController controller, VRCAvatarDescriptor avatar, string wanted)
        {
            bool Taken(string candidate)
            {
                if (controller != null && controller.parameters.Any(p => p.name == candidate))
                    return true;

                var asset = avatar.expressionParameters;
                return asset != null && asset.parameters != null && asset.parameters.Any(p => p != null && p.name == candidate);
            }

            if (!Taken(wanted))
                return wanted;

            for (int n = 2; n < 1000; n++)
            {
                string candidate = wanted + n;
                if (!Taken(candidate))
                    return candidate;
            }

            return wanted + Guid.NewGuid().ToString("N").Substring(0, 6);
        }

        private static string UniqueLayerName(AnimatorController controller, string wanted)
        {
            if (controller.layers.All(l => l.name != wanted))
                return wanted;

            for (int n = 2; n < 1000; n++)
            {
                string candidate = wanted + " " + n;
                if (controller.layers.All(l => l.name != candidate))
                    return candidate;
            }

            return wanted + " " + Guid.NewGuid().ToString("N").Substring(0, 6);
        }

        private static string ResolveFolder(Request request, AnimatorController controller)
        {
            if (!string.IsNullOrEmpty(request.Folder) && AssetDatabase.IsValidFolder(request.Folder))
                return request.Folder;

            string controllerPath = AssetDatabase.GetAssetPath(controller);
            string folder = string.IsNullOrEmpty(controllerPath)
                ? "Assets/WPFMA-SDK/Toggles"
                : Path.GetDirectoryName(controllerPath).Replace('\\', '/') + "/Toggles";

            WPFMAAvatarFolders.Ensure(folder);
            return folder;
        }
    }
}
#endif
#endif
