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

namespace WPFMA.Vrca
{
    public static class WPFMAAnimatorGraph
    {
        private const uint InvalidId = 0xFFFFFFFF;
        private const long SelectorDestinationBase = 30000;

        public sealed class Stats
        {
            public int Layers;
            public int States;
            public int Transitions;
            public int Conditions;
            public int BlendTrees;

            public override string ToString()
            {
                return Layers + " layer(s), " + States + " state(s), " + Transitions +
                       " transition(s), " + Conditions + " condition(s), " + BlendTrees + " blend tree(s)";
            }
        }

        public static Stats Populate(AnimatorController rebuilt, string controllerName, WPFMASerializedFile cab,
            Func<int, Motion> clipAtIndex, List<string> warnings, long controllerPathId = 0,
            Func<uint, string> transformPathOf = null)
        {
            Dictionary<string, object> root = FindController(cab, controllerName, controllerPathId);
            if (root == null)
            {
                warnings.Add("Controller '" + controllerName + "' was not found in the serialized bundle data.");
                return null;
            }

            var tos = ReadTos(root);
            var controller = Dict(root["m_Controller"]);
            var layerArray = ListOf(controller["m_LayerArray"]);
            var stateMachineArray = ListOf(controller["m_StateMachineArray"]);

            var stats = new Stats();
            var machineOwners = new Dictionary<int, int>();
            var maskCache = new Dictionary<string, AvatarMask>();
            int unresolvedMaskBones = 0;

            for (int layerIndex = 0; layerIndex < layerArray.Count; layerIndex++)
            {
                var layerData = Data(layerArray[layerIndex]);
                int machineIndex = (int)AsLong(layerData["m_StateMachineIndex"]);
                string layerName = Name(tos, AsUInt(layerData["m_Binding"]), "Layer " + layerIndex);

                rebuilt.AddLayer(layerName);
                var layers = rebuilt.layers;
                var layer = layers[layers.Length - 1];

                layer.defaultWeight = layerIndex == 0 ? 1f : AsFloat(layerData, "m_DefaultWeight", 1f);
                layer.iKPass = AsBool(layerData, "m_IKPass");
                layer.avatarMask = BuildLayerMask(rebuilt, layerData, layerName, tos, transformPathOf, maskCache,
                    ref unresolvedMaskBones);
                foreach (var key in layerData.Keys)
                {
                    if (key.EndsWith("m_LayerBlendingMode", StringComparison.Ordinal))
                        layer.blendingMode = (AnimatorLayerBlendingMode)AsLong(layerData[key]);
                }

                int owner;
                if (machineOwners.TryGetValue(machineIndex, out owner))
                {
                    layer.syncedLayerIndex = owner;
                    layers[layers.Length - 1] = layer;
                    rebuilt.layers = layers;
                    stats.Layers++;
                    continue;
                }

                machineOwners[machineIndex] = layerIndex;
                layers[layers.Length - 1] = layer;
                rebuilt.layers = layers;

                if (machineIndex < 0 || machineIndex >= stateMachineArray.Count)
                {
                    warnings.Add("Layer '" + layerName + "' points at a missing state machine; left empty.");
                    stats.Layers++;
                    continue;
                }

                BuildStateMachine(rebuilt, layer.stateMachine, Data(stateMachineArray[machineIndex]),
                    tos, clipAtIndex, stats, warnings);
                stats.Layers++;
            }

            if (unresolvedMaskBones > 0)
                warnings.Add("'" + controllerName + "': " + unresolvedMaskBones +
                    " bone(s) in layer masks could not be matched to the avatar and were left out of those masks.");

            return stats;
        }

        private static readonly KeyValuePair<AvatarMaskBodyPart, int[]>[] BodyPartBits =
        {
            Part(AvatarMaskBodyPart.Root, new[] { 0 }),
            Part(AvatarMaskBodyPart.Body, Range(1, 9), Range(62, 64)),
            Part(AvatarMaskBodyPart.Head, Range(10, 21), Range(65, 66)),
            Part(AvatarMaskBodyPart.LeftLeg, Range(22, 29), Range(67, 70)),
            Part(AvatarMaskBodyPart.RightLeg, Range(30, 37), Range(71, 74)),
            Part(AvatarMaskBodyPart.LeftArm, Range(38, 46), Range(75, 78)),
            Part(AvatarMaskBodyPart.RightArm, Range(47, 55), Range(79, 82)),
            Part(AvatarMaskBodyPart.LeftFootIK, new[] { 56 }),
            Part(AvatarMaskBodyPart.RightFootIK, new[] { 57 }),
            Part(AvatarMaskBodyPart.LeftHandIK, new[] { 58 }),
            Part(AvatarMaskBodyPart.RightHandIK, new[] { 59 }),
            Part(AvatarMaskBodyPart.LeftFingers, new[] { 60 }),
            Part(AvatarMaskBodyPart.RightFingers, new[] { 61 })
        };

        private const int HumanMaskBits = 83;

        private static KeyValuePair<AvatarMaskBodyPart, int[]> Part(AvatarMaskBodyPart part, params int[][] groups)
        {
            var bits = new List<int>();
            foreach (var group in groups)
                bits.AddRange(group);
            return new KeyValuePair<AvatarMaskBodyPart, int[]>(part, bits.ToArray());
        }

        private static int[] Range(int first, int last)
        {
            var bits = new int[last - first + 1];
            for (int i = 0; i < bits.Length; i++)
                bits[i] = first + i;
            return bits;
        }

        private static AvatarMask BuildLayerMask(AnimatorController rebuilt, Dictionary<string, object> layerData,
            string layerName, Dictionary<uint, string> tos, Func<uint, string> transformPathOf,
            Dictionary<string, AvatarMask> cache, ref int unresolvedBones)
        {
            var body = Dict(layerData.ContainsKey("m_BodyMask") ? layerData["m_BodyMask"] : null);
            uint[] words =
            {
                body != null && body.ContainsKey("word0") ? AsUInt(body["word0"]) : uint.MaxValue,
                body != null && body.ContainsKey("word1") ? AsUInt(body["word1"]) : uint.MaxValue,
                body != null && body.ContainsKey("word2") ? AsUInt(body["word2"]) : uint.MaxValue
            };

            var skeleton = Data(layerData.ContainsKey("m_SkeletonMask") ? layerData["m_SkeletonMask"] : null);
            var bones = skeleton != null && skeleton.ContainsKey("m_Data") ? ListOf(skeleton["m_Data"]) : new List<object>();

            bool everyHumanBit = true;
            for (int bit = 0; bit < HumanMaskBits && everyHumanBit; bit++)
                everyHumanBit = IsBitSet(words, bit);

            if (everyHumanBit && bones.Count == 0)
                return null;

            var entries = new List<KeyValuePair<string, bool>>();
            foreach (var entry in bones)
            {
                var bone = Dict(entry);
                if (bone == null)
                    continue;

                uint hash = AsUInt(bone["m_PathHash"]);
                string path = hash == 0 ? string.Empty : transformPathOf != null ? transformPathOf(hash) : null;
                if (path == null)
                    tos.TryGetValue(hash, out path);
                if (path == null)
                {
                    unresolvedBones++;
                    continue;
                }

                entries.Add(new KeyValuePair<string, bool>(path, AsFloat(bone, "m_Weight", 1f) > 0.5f));
            }

            var parts = new bool[BodyPartBits.Length];
            var key = new System.Text.StringBuilder();
            for (int i = 0; i < BodyPartBits.Length; i++)
            {
                foreach (var bit in BodyPartBits[i].Value)
                    parts[i] |= IsBitSet(words, bit);
                key.Append(parts[i] ? '1' : '0');
            }
            foreach (var entry in entries)
                key.Append('|').Append(entry.Key).Append(entry.Value ? ":1" : ":0");

            AvatarMask mask;
            if (cache.TryGetValue(key.ToString(), out mask))
                return mask;

            mask = new AvatarMask { name = "Mask " + (cache.Count + 1) + " (" + layerName + ")" };
            for (int i = 0; i < BodyPartBits.Length; i++)
                mask.SetHumanoidBodyPartActive(BodyPartBits[i].Key, parts[i]);

            mask.transformCount = entries.Count;
            for (int i = 0; i < entries.Count; i++)
            {
                mask.SetTransformPath(i, entries[i].Key);
                mask.SetTransformActive(i, entries[i].Value);
            }

            if (AssetDatabase.Contains(rebuilt))
                AssetDatabase.AddObjectToAsset(mask, rebuilt);

            cache[key.ToString()] = mask;
            return mask;
        }

        private static bool IsBitSet(uint[] words, int bit)
        {
            int word = bit / 32;
            return word < words.Length && (words[word] & (1u << (bit % 32))) != 0;
        }

        private static void BuildStateMachine(AnimatorController rebuilt, AnimatorStateMachine machine,
            Dictionary<string, object> machineData, Dictionary<uint, string> tos,
            Func<int, Motion> clipAtIndex, Stats stats, List<string> warnings)
        {
            var stateConstants = ListOf(machineData["m_StateConstantArray"]);
            var states = new AnimatorState[stateConstants.Count];

            for (int i = 0; i < stateConstants.Count; i++)
            {
                var stateData = Data(stateConstants[i]);
                string stateName = Name(tos, AsUInt(stateData["m_NameID"]), null);
                if (stateName == null)
                {
                    string fullPath = Name(tos, AsUInt(stateData["m_FullPathID"]), "State " + i);
                    int dot = fullPath.LastIndexOf('.');
                    stateName = dot >= 0 ? fullPath.Substring(dot + 1) : fullPath;
                }

                var position = new Vector3(320f, 60f + 70f * i, 0f);
                var state = machine.AddState(stateName, position);

                state.speed = AsFloat(stateData, "m_Speed", 1f);
                state.cycleOffset = AsFloat(stateData, "m_CycleOffset", 0f);
                state.writeDefaultValues = AsBool(stateData, "m_WriteDefaultValues");
                state.mirror = AsBool(stateData, "m_Mirror");
                state.iKOnFeet = AsBool(stateData, "m_IKOnFeet");

                BindParameter(stateData, "m_SpeedParamID", tos, name => { state.speedParameterActive = true; state.speedParameter = name; });
                BindParameter(stateData, "m_MirrorParamID", tos, name => { state.mirrorParameterActive = true; state.mirrorParameter = name; });
                BindParameter(stateData, "m_CycleOffsetParamID", tos, name => { state.cycleOffsetParameterActive = true; state.cycleOffsetParameter = name; });
                BindParameter(stateData, "m_TimeParamID", tos, name => { state.timeParameterActive = true; state.timeParameter = name; });

                state.motion = BuildStateMotion(rebuilt, stateData, stateName, tos, clipAtIndex, stats, warnings);
                states[i] = state;
                stats.States++;
            }

            long defaultState = AsLong(machineData["m_DefaultState"]);
            if (defaultState >= 0 && defaultState < states.Length)
                machine.defaultState = states[(int)defaultState];

            for (int i = 0; i < stateConstants.Count; i++)
            {
                var stateData = Data(stateConstants[i]);
                foreach (var entry in ListOf(stateData["m_TransitionConstantArray"]))
                {
                    var transitionData = Data(entry);
                    var transition = CreateTransition(states[i], null, transitionData, states, warnings);
                    if (transition == null)
                        continue;

                    ApplyTransitionSettings(transition, transitionData, tos, false);
                    AddConditions(transition, transitionData, tos, stats, warnings);
                    stats.Transitions++;
                }
            }

            foreach (var entry in ListOf(machineData["m_AnyStateTransitionConstantArray"]))
            {
                var transitionData = Data(entry);
                long destination = AsLong(transitionData["m_DestinationState"]);
                if (destination < 0 || destination >= states.Length)
                    continue;

                var transition = machine.AddAnyStateTransition(states[(int)destination]);
                ApplyTransitionSettings(transition, transitionData, tos, true);
                AddConditions(transition, transitionData, tos, stats, warnings);
                stats.Transitions++;
            }

            foreach (var entry in ListOf(machineData["m_SelectorStateConstantArray"]))
            {
                var selector = Data(entry);
                if (!AsBool(selector, "m_IsEntry"))
                    continue;

                foreach (var t in ListOf(selector["m_TransitionConstantArray"]))
                {
                    var selectorTransition = Data(t);
                    var conditions = ListOf(selectorTransition["m_ConditionConstantArray"]);
                    if (conditions.Count == 0)
                        continue;

                    long destination = AsLong(selectorTransition["m_Destination"]);
                    if (destination < 0 || destination >= states.Length)
                        continue;

                    var entryTransition = machine.AddEntryTransition(states[(int)destination]);
                    foreach (var c in conditions)
                    {
                        var condition = Data(c);
                        int mode = (int)AsLong(condition["m_ConditionMode"]);
                        if (mode < 1 || mode > 7 || mode == 5)
                            continue;
                        entryTransition.AddCondition((AnimatorConditionMode)mode,
                            AsFloat(condition, "m_EventThreshold", 0f),
                            Name(tos, AsUInt(condition["m_EventID"]), "#" + AsUInt(condition["m_EventID"])));
                        stats.Conditions++;
                    }
                    stats.Transitions++;
                }
            }
        }

        private static AnimatorStateTransition CreateTransition(AnimatorState source,
            AnimatorStateMachine unusedMachine, Dictionary<string, object> transitionData,
            AnimatorState[] states, List<string> warnings)
        {
            long destination = AsLong(transitionData["m_DestinationState"]);

            if (destination >= SelectorDestinationBase)
            {
                return source.AddExitTransition();
            }

            if (destination < 0 || destination >= states.Length)
            {
                warnings.Add("A transition from '" + source.name + "' points outside the state array; skipped.");
                return null;
            }

            return source.AddTransition(states[(int)destination]);
        }

        private static void ApplyTransitionSettings(AnimatorStateTransition transition,
            Dictionary<string, object> transitionData, Dictionary<uint, string> tos, bool isAnyState)
        {
            transition.hasExitTime = AsBool(transitionData, "m_HasExitTime");
            transition.exitTime = AsFloat(transitionData, "m_ExitTime", 0f);
            transition.duration = AsFloat(transitionData, "m_TransitionDuration", 0f);
            transition.offset = AsFloat(transitionData, "m_TransitionOffset", 0f);
            transition.hasFixedDuration = AsBool(transitionData, "m_HasFixedDuration");
            transition.orderedInterruption = AsBool(transitionData, "m_OrderedInterruption");
            transition.interruptionSource = (TransitionInterruptionSource)AsLong(transitionData["m_InterruptionSource"]);
            if (isAnyState)
                transition.canTransitionToSelf = AsBool(transitionData, "m_CanTransitionToSelf");

            string name = Name(tos, AsUInt(transitionData["m_UserID"]), null);
            if (!string.IsNullOrEmpty(name))
                transition.name = name;
        }

        private static void AddConditions(AnimatorStateTransition transition,
            Dictionary<string, object> transitionData, Dictionary<uint, string> tos,
            Stats stats, List<string> warnings)
        {
            foreach (var entry in ListOf(transitionData["m_ConditionConstantArray"]))
            {
                var condition = Data(entry);
                int mode = (int)AsLong(condition["m_ConditionMode"]);

                if (mode == 5)
                {
                    transition.hasExitTime = true;
                    float exitTime = AsFloat(condition, "m_ExitTime", 0f);
                    if (exitTime > 0f)
                        transition.exitTime = exitTime;
                    continue;
                }

                if (mode < 1 || mode > 7)
                    continue;

                uint eventId = AsUInt(condition["m_EventID"]);
                string parameter = Name(tos, eventId, null);
                if (parameter == null)
                {
                    warnings.Add("A condition references parameter hash " + eventId + " with no name in the bundle; skipped.");
                    continue;
                }

                transition.AddCondition((AnimatorConditionMode)mode, AsFloat(condition, "m_EventThreshold", 0f), parameter);
                stats.Conditions++;
            }
        }

        private static Motion BuildStateMotion(AnimatorController rebuilt, Dictionary<string, object> stateData,
            string stateName, Dictionary<uint, string> tos, Func<int, Motion> clipAtIndex,
            Stats stats, List<string> warnings)
        {
            var indexArray = ListOf(stateData["m_BlendTreeConstantIndexArray"]);
            var constants = ListOf(stateData["m_BlendTreeConstantArray"]);
            if (indexArray.Count == 0 || constants.Count == 0)
                return null;

            int constantIndex = (int)AsLong(indexArray[0]);
            if (constantIndex < 0 || constantIndex >= constants.Count)
                return null;

            var nodes = ListOf(Data(constants[constantIndex])["m_NodeArray"]);
            if (nodes.Count == 0)
                return null;

            return BuildMotion(rebuilt, nodes, 0, stateName, tos, clipAtIndex, stats, warnings);
        }

        private static Motion BuildMotion(AnimatorController rebuilt, List<object> nodes, int nodeIndex,
            string label, Dictionary<uint, string> tos, Func<int, Motion> clipAtIndex,
            Stats stats, List<string> warnings)
        {
            var node = Data(nodes[nodeIndex]);
            var childIndices = ListOf(node["m_ChildIndices"]);

            if (childIndices.Count == 0)
            {
                uint clipId = AsUInt(node["m_ClipID"]);
                return clipId == InvalidId ? null : clipAtIndex((int)clipId);
            }

            var tree = new BlendTree
            {
                name = label,
                blendType = (BlendTreeType)AsLong(node["m_BlendType"]),
                hideFlags = HideFlags.HideInHierarchy,

                useAutomaticThresholds = false
            };

            uint blendEvent = AsUInt(node["m_BlendEventID"]);
            if (blendEvent != InvalidId)
                tree.blendParameter = Name(tos, blendEvent, tree.blendParameter);

            uint blendEventY = AsUInt(node["m_BlendEventYID"]);
            if (blendEventY != InvalidId)
                tree.blendParameterY = Name(tos, blendEventY, tree.blendParameterY);

            AssetDatabase.AddObjectToAsset(tree, rebuilt);
            stats.BlendTrees++;

            var thresholds = ListOf(Data(node["m_Blend1dData"])["m_ChildThresholdArray"]);
            var positions = ListOf(Data(node["m_Blend2dData"])["m_ChildPositionArray"]);
            var directParameters = ListOf(Data(node["m_BlendDirectData"])["m_ChildBlendEventIDArray"]);

            var children = new ChildMotion[childIndices.Count];
            for (int k = 0; k < childIndices.Count; k++)
            {
                int childIndex = (int)AsLong(childIndices[k]);
                var childNode = childIndex >= 0 && childIndex < nodes.Count
                    ? Data(nodes[childIndex])
                    : new Dictionary<string, object>();

                var child = new ChildMotion
                {
                    motion = BuildMotion(rebuilt, nodes, childIndex,
                        label + " " + k, tos, clipAtIndex, stats, warnings),

                    mirror = AsBool(childNode, "m_Mirror"),
                    cycleOffset = AsFloat(childNode, "m_CycleOffset", 0f),

                    timeScale = Reciprocal(AsFloat(childNode, "m_Duration", 1f))
                };

                if (k < thresholds.Count)
                    child.threshold = AsFloatValue(thresholds[k]);

                if (k < positions.Count)
                {
                    var p = Dict(positions[k]);
                    if (p != null)
                        child.position = new Vector2(AsFloat(p, "x", 0f), AsFloat(p, "y", 0f));
                }

                if (k < directParameters.Count)
                {
                    uint id = AsUInt(directParameters[k]);
                    if (id != InvalidId)
                        child.directBlendParameter = Name(tos, id, "#" + id);
                }

                children[k] = child;
            }

            tree.children = children;
            return tree;
        }

        public static long[] ReadClipOrder(WPFMASerializedFile cab, string controllerName, long controllerPathId = 0)
        {
            var root = cab != null ? FindController(cab, controllerName, controllerPathId) : null;
            if (root == null)
                return null;

            object listValue;
            var entries = root.TryGetValue("m_AnimationClips", out listValue) ? listValue as List<object> : null;
            if (entries == null)
                return null;

            var order = new long[entries.Count];
            for (int i = 0; i < entries.Count; i++)
            {
                var pointer = Dict(entries[i]);
                object pathValue;
                if (pointer != null && pointer.TryGetValue("m_PathID", out pathValue))
                    order[i] = AsLong(pathValue);
            }

            return order;
        }

        public static int RepairChildSettings(AnimatorController target, WPFMASerializedFile cab,
            long controllerPathId, List<string> notes)
        {
            var root = FindController(cab, target.name, controllerPathId);
            if (root == null)
                return Decline(notes, target.name, "it is not in the bundle under that name");

            var tos = ReadTos(root);
            var controller = Dict(root["m_Controller"]);
            if (controller == null)
                return Decline(notes, target.name, "its serialized data could not be read");

            var layerArray = ListOf(controller["m_LayerArray"]);
            var machines = ListOf(controller["m_StateMachineArray"]);
            var layers = target.layers;
            if (layerArray.Count != layers.Length)
                return Decline(notes, target.name, "it has " + layers.Length + " layer(s) and the bundle has " +
                    layerArray.Count);

            var pending = new List<PendingChild>();
            var machineSeen = new HashSet<int>();

            for (int i = 0; i < layerArray.Count; i++)
            {
                int machineIndex = (int)AsLong(Data(layerArray[i])["m_StateMachineIndex"]);

                if (!machineSeen.Add(machineIndex))
                    continue;
                if (machineIndex < 0 || machineIndex >= machines.Count)
                    continue;

                var stateConstants = ListOf(Data(machines[machineIndex])["m_StateConstantArray"]);
                var states = layers[i].stateMachine != null
                    ? layers[i].stateMachine.states
                    : new ChildAnimatorState[0];
                if (states.Length != stateConstants.Count)
                    return Decline(notes, target.name, "layer '" + layers[i].name + "' has " + states.Length +
                        " state(s) and the bundle has " + stateConstants.Count);

                for (int s = 0; s < states.Length; s++)
                {
                    var stateData = Data(stateConstants[s]);
                    if (states[s].state == null)
                        continue;

                    string expected = Name(tos, AsUInt(stateData["m_NameID"]), null);
                    if (expected != null && !SameState(states[s].state.name, expected))
                        return Decline(notes, target.name, "state " + s + " of layer '" + layers[i].name +
                            "' is called '" + states[s].state.name + "' and the bundle calls it '" + expected + "'");

                    var indexArray = ListOf(stateData["m_BlendTreeConstantIndexArray"]);
                    var constants = ListOf(stateData["m_BlendTreeConstantArray"]);
                    if (indexArray.Count == 0 || constants.Count == 0)
                        continue;

                    int constantIndex = (int)AsLong(indexArray[0]);
                    if (constantIndex < 0 || constantIndex >= constants.Count)
                        continue;

                    var nodes = ListOf(Data(constants[constantIndex])["m_NodeArray"]);
                    if (nodes.Count == 0)
                        continue;

                    if (!CollectChildren(states[s].state.motion as BlendTree, nodes, 0, pending))
                        return Decline(notes, target.name, "the blend trees of state '" + states[s].state.name +
                            "' no longer match the bundle's");
                }
            }

            int changed = 0;
            foreach (var group in pending.GroupBy(c => c.Tree))
            {
                var children = group.Key.children;
                bool touched = false;

                foreach (var item in group)
                {
                    var child = children[item.Index];
                    if (child.mirror == item.Mirror &&
                        Math.Abs(child.cycleOffset - item.CycleOffset) <= 0.0001f &&
                        Math.Abs(child.timeScale - item.TimeScale) <= 0.0001f)
                        continue;

                    child.mirror = item.Mirror;
                    child.cycleOffset = item.CycleOffset;
                    child.timeScale = item.TimeScale;
                    children[item.Index] = child;
                    touched = true;
                    changed++;
                }

                if (touched)
                    group.Key.children = children;
            }

            return changed;
        }

        private struct PendingChild
        {
            public BlendTree Tree;
            public int Index;
            public bool Mirror;
            public float CycleOffset;
            public float TimeScale;
        }

        private static bool SameState(string exported, string expected)
        {
            if (exported == expected)
                return true;
            if (exported == null || expected == null ||
                !exported.StartsWith(expected + " ", StringComparison.Ordinal))
                return false;

            for (int i = expected.Length + 1; i < exported.Length; i++)
            {
                if (!char.IsDigit(exported[i]))
                    return false;
            }

            return exported.Length > expected.Length + 1;
        }

        private static int Decline(List<string> notes, string controllerName, string reason)
        {
            notes.Add("'" + controllerName + "' was left untouched: " + reason + ".");
            return -1;
        }

        private static bool CollectChildren(BlendTree tree, List<object> nodes, int nodeIndex, List<PendingChild> pending)
        {
            if (tree == null)
                return true;
            if (nodeIndex < 0 || nodeIndex >= nodes.Count)
                return false;

            var node = Data(nodes[nodeIndex]);
            var childIndices = ListOf(node["m_ChildIndices"]);
            var children = tree.children;
            if (children == null || children.Length != childIndices.Count)
                return false;

            foreach (var child in children)
            {
                if (child.motion == null)
                    return false;
            }

            for (int k = 0; k < children.Length; k++)
            {
                int childIndex = (int)AsLong(childIndices[k]);
                var childNode = childIndex >= 0 && childIndex < nodes.Count
                    ? Data(nodes[childIndex])
                    : new Dictionary<string, object>();

                pending.Add(new PendingChild
                {
                    Tree = tree,
                    Index = k,
                    Mirror = AsBool(childNode, "m_Mirror"),
                    CycleOffset = AsFloat(childNode, "m_CycleOffset", 0f),
                    TimeScale = Reciprocal(AsFloat(childNode, "m_Duration", 1f))
                });

                if (!CollectChildren(children[k].motion as BlendTree, nodes, childIndex, pending))
                    return false;
            }

            return true;
        }

        public static List<AnimatorControllerParameter> ReadParameters(WPFMASerializedFile cab,
            string controllerName, long controllerPathId = 0)
        {
            var found = new List<AnimatorControllerParameter>();
            var root = cab != null ? FindController(cab, controllerName, controllerPathId) : null;
            if (root == null)
                return found;

            var tos = ReadTos(root);
            var controller = Dict(root["m_Controller"]);
            if (controller == null)
                return found;

            object valuesRaw, defaultsRaw = null;
            if (!controller.TryGetValue("m_Values", out valuesRaw))
                return found;
            controller.TryGetValue("m_DefaultValues", out defaultsRaw);

            var entries = ListOf(Data(valuesRaw)["m_ValueArray"]);
            var defaults = Data(defaultsRaw);
            var floats = ListOf(defaults.ContainsKey("m_FloatValues") ? defaults["m_FloatValues"] : null);
            var ints = ListOf(defaults.ContainsKey("m_IntValues") ? defaults["m_IntValues"] : null);
            var bools = ListOf(defaults.ContainsKey("m_BoolValues") ? defaults["m_BoolValues"] : null);

            var taken = new HashSet<string>(StringComparer.Ordinal);
            foreach (var entry in entries)
            {
                var value = Data(entry);
                object idRaw;
                if (!value.TryGetValue("m_ID", out idRaw))
                    continue;

                string name = Name(tos, AsUInt(idRaw), null);
                if (string.IsNullOrEmpty(name) || !taken.Add(name))
                    continue;

                int type = (int)AsLong(value.ContainsKey("m_Type") ? value["m_Type"] : 1);
                int index = (int)AsLong(value.ContainsKey("m_Index") ? value["m_Index"] : 0);

                var parameter = new AnimatorControllerParameter { name = name };
                switch (type)
                {
                    case 3:
                        parameter.type = AnimatorControllerParameterType.Int;
                        parameter.defaultInt = index >= 0 && index < ints.Count ? (int)AsLong(ints[index]) : 0;
                        break;
                    case 4:
                        parameter.type = AnimatorControllerParameterType.Bool;
                        parameter.defaultBool = index >= 0 && index < bools.Count && AsBoolValue(bools[index]);
                        break;
                    case 9:
                        parameter.type = AnimatorControllerParameterType.Trigger;
                        parameter.defaultBool = index >= 0 && index < bools.Count && AsBoolValue(bools[index]);
                        break;
                    default:
                        parameter.type = AnimatorControllerParameterType.Float;
                        parameter.defaultFloat = index >= 0 && index < floats.Count ? AsFloatValue(floats[index]) : 0f;
                        break;
                }

                found.Add(parameter);
            }

            return found;
        }

        public static Dictionary<long, string> ReadClipNames(WPFMASerializedFile cab)
        {
            var names = new Dictionary<long, string>();
            if (cab == null)
                return names;

            foreach (var obj in cab.Objects)
            {
                if (obj.Type.ClassId != 74)
                    continue;

                try
                {
                    var clip = cab.ReadObject(obj) as Dictionary<string, object>;
                    if (clip != null)
                        names[obj.PathId] = clip["m_Name"] as string ?? string.Empty;
                }
                catch { }
            }

            return names;
        }

        private sealed class ControllerCache
        {
            public readonly Dictionary<long, Dictionary<string, object>> ByPath =
                new Dictionary<long, Dictionary<string, object>>();

            public readonly Dictionary<string, Dictionary<string, object>> ByName =
                new Dictionary<string, Dictionary<string, object>>(StringComparer.Ordinal);

            public bool AllLoaded;
        }

        private static readonly System.Runtime.CompilerServices.ConditionalWeakTable<WPFMASerializedFile, ControllerCache>
            ControllerCaches = new System.Runtime.CompilerServices.ConditionalWeakTable<WPFMASerializedFile, ControllerCache>();

        private static Dictionary<string, object> FindController(WPFMASerializedFile cab, string name, long pathId)
        {
            var cache = ControllerCaches.GetOrCreateValue(cab);
            Dictionary<string, object> hit;

            if (pathId != 0)
            {
                if (cache.ByPath.TryGetValue(pathId, out hit))
                    return hit;

                foreach (var obj in cab.Objects)
                {
                    if (obj.PathId != pathId || obj.Type.ClassId != 91)
                        continue;

                    var exact = cab.ReadObject(obj) as Dictionary<string, object>;
                    if (exact != null)
                    {
                        cache.ByPath[pathId] = exact;
                        return exact;
                    }
                }
            }

            if (!cache.AllLoaded)
            {
                cache.AllLoaded = true;

                foreach (var obj in cab.Objects)
                {
                    if (obj.Type.ClassId != 91)
                        continue;

                    Dictionary<string, object> value;
                    if (!cache.ByPath.TryGetValue(obj.PathId, out value))
                    {
                        value = cab.ReadObject(obj) as Dictionary<string, object>;
                        if (value == null)
                            continue;

                        cache.ByPath[obj.PathId] = value;
                    }

                    object rawName;
                    var controllerName = value.TryGetValue("m_Name", out rawName) ? rawName as string : null;
                    if (controllerName != null && !cache.ByName.ContainsKey(controllerName))
                        cache.ByName[controllerName] = value;
                }
            }

            return name != null && cache.ByName.TryGetValue(name, out hit) ? hit : null;
        }

        private static Dictionary<uint, string> ReadTos(Dictionary<string, object> root)
        {
            var tos = new Dictionary<uint, string>();
            foreach (var entry in ListOf(root["m_TOS"]))
            {
                var pair = Dict(entry);
                if (pair != null)
                    tos[AsUInt(pair["first"])] = pair["second"] as string;
            }

            return tos;
        }

        private static void BindParameter(Dictionary<string, object> stateData, string key,
            Dictionary<uint, string> tos, Action<string> apply)
        {
            object raw;
            if (!stateData.TryGetValue(key, out raw))
                return;

            uint id = AsUInt(raw);
            if (id == 0 || id == InvalidId)
                return;

            string name = Name(tos, id, null);
            if (name != null)
                apply(name);
        }

        private static string Name(Dictionary<uint, string> tos, uint id, string fallback)
        {
            string name;
            return tos.TryGetValue(id, out name) && !string.IsNullOrEmpty(name) ? name : fallback;
        }

        private static Dictionary<string, object> Dict(object value)
        {
            return value as Dictionary<string, object>;
        }

        private static Dictionary<string, object> Data(object value)
        {
            var d = Dict(value);
            if (d == null)
                return new Dictionary<string, object>();

            object inner;
            if (d.Count == 1 && d.TryGetValue("data", out inner))
                return Dict(inner) ?? d;

            return d;
        }

        private static List<object> ListOf(object value)
        {
            return value as List<object> ?? new List<object>();
        }

        private static long AsLong(object value)
        {
            if (value is int) return (int)value;
            if (value is uint) return (uint)value;
            if (value is long) return (long)value;
            if (value is ulong) return (long)(ulong)value;
            if (value is short) return (short)value;
            if (value is ushort) return (ushort)value;
            if (value is byte) return (byte)value;
            if (value is sbyte) return (sbyte)value;
            if (value is bool) return (bool)value ? 1 : 0;
            if (value is float) return (long)(float)value;
            return 0;
        }

        private static uint AsUInt(object value)
        {
            return unchecked((uint)AsLong(value));
        }

        private static float AsFloatValue(object value)
        {
            if (value is float) return (float)value;
            if (value is double) return (float)(double)value;
            return AsLong(value);
        }

        private static float AsFloat(Dictionary<string, object> map, string key, float fallback)
        {
            object raw;
            return map.TryGetValue(key, out raw) ? AsFloatValue(raw) : fallback;
        }

        private static float Reciprocal(float duration)
        {
            return duration > 0.0001f ? 1f / duration : 1f;
        }

        private static bool AsBoolValue(object value)
        {
            if (value is bool) return (bool)value;
            return AsLong(value) != 0;
        }

        private static bool AsBool(Dictionary<string, object> map, string key)
        {
            object raw;
            if (!map.TryGetValue(key, out raw))
                return false;
            if (raw is bool)
                return (bool)raw;
            return AsLong(raw) != 0;
        }
    }
}
#endif
