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

namespace WPFMA.Vrca
{
    public sealed class WPFMAAnimationClipDecoder
    {
        public sealed class Stats
        {
            public int ClipsMatched;
            public int ClipsRestored;
            public int CurvesWritten;
            public int BindingsUnresolvedPath;
            public int BindingsUnresolvedProperty;
            public int PPtrCurvesSkipped;
            public int PPtrCurvesWritten;
        }

        private static string[] animatorChannels;

        private static string[] AnimatorChannels
        {
            get
            {
                if (animatorChannels != null)
                    return animatorChannels;

                var names = new List<string>();
                foreach (var frame in new[] { "Motion", "Root" })
                    AddPose(names, frame);

                foreach (var goal in new[] { "LeftFoot", "RightFoot", "LeftHand", "RightHand" })
                    AddPose(names, goal);

                foreach (var muscle in HumanTrait.MuscleName)
                    names.Add(ToBindingName(muscle));

                foreach (var bone in TranslationDoFBones)
                    foreach (var axis in new[] { "x", "y", "z" })
                        names.Add(bone + "TDOF." + axis);

                return animatorChannels = names.ToArray();
            }
        }

        private static readonly string[] TranslationDoFBones =
        {
            "Spine", "Chest", "UpperChest", "Neck", "Head",
            "LeftUpperLeg", "LeftLowerLeg", "LeftFoot", "LeftToes",
            "RightUpperLeg", "RightLowerLeg", "RightFoot", "RightToes",
            "LeftShoulder", "LeftUpperArm", "LeftLowerArm", "LeftHand",
            "RightShoulder", "RightUpperArm", "RightLowerArm", "RightHand"
        };

        private static string ToBindingName(string muscle)
        {
            if (string.IsNullOrEmpty(muscle))
                return muscle;

            foreach (var side in new[] { "Left", "Right" })
            {
                foreach (var finger in new[] { "Thumb", "Index", "Middle", "Ring", "Little" })
                {
                    string prefix = side + " " + finger + " ";
                    if (muscle.StartsWith(prefix, StringComparison.Ordinal))
                        return side + "Hand." + finger + "." + muscle.Substring(prefix.Length);
                }
            }

            return muscle;
        }

        private static void AddPose(List<string> names, string prefix)
        {
            foreach (var axis in new[] { "x", "y", "z" })
                names.Add(prefix + "T." + axis);
            foreach (var axis in new[] { "x", "y", "z", "w" })
                names.Add(prefix + "Q." + axis);
        }

        private readonly List<string> warnings;

        private readonly Dictionary<string, List<Dictionary<string, object>>> byName =
            new Dictionary<string, List<Dictionary<string, object>>>();

        private readonly Dictionary<long, Dictionary<string, object>> byPathId =
            new Dictionary<long, Dictionary<string, object>>();

        private readonly Dictionary<uint, string> pathNames = new Dictionary<uint, string>();
        private readonly Dictionary<uint, string> propertyNames = new Dictionary<uint, string>();
        private readonly Dictionary<uint, string> blendShapeNames = new Dictionary<uint, string>();

        private readonly Dictionary<ulong, Type> exactTypes = new Dictionary<ulong, Type>();

        private static ulong BindingKey(uint pathHash, uint propertyHash)
        {
            return ((ulong)pathHash << 32) | propertyHash;
        }

        private readonly Dictionary<uint, string> materialProperties = new Dictionary<uint, string>();
        private readonly Dictionary<string, GameObject> objectsByPath = new Dictionary<string, GameObject>();

        private readonly HashSet<uint> reportedPaths = new HashSet<uint>();
        private readonly HashSet<uint> reportedProperties = new HashSet<uint>();

        public Stats Report { get; private set; }

        public Func<long, UnityEngine.Object> ResolveObject;

        public HashSet<long> ReferencedObjectIds()
        {
            var ids = new HashSet<long>();
            foreach (var raw in byPathId.Values)
                foreach (var id in ReadObjectMapping(raw))
                    if (id != 0)
                        ids.Add(id);
            return ids;
        }

        private static List<long> ReadObjectMapping(Dictionary<string, object> raw)
        {
            var ids = new List<long>();
            object constantValue;
            var constant = raw.TryGetValue("m_ClipBindingConstant", out constantValue)
                ? constantValue as Dictionary<string, object>
                : null;
            object mappingValue;
            var mapping = constant != null && constant.TryGetValue("pptrCurveMapping", out mappingValue)
                ? mappingValue as List<object>
                : null;
            if (mapping == null)
                return ids;

            foreach (var entry in mapping)
            {
                var pointer = entry as Dictionary<string, object>;
                ids.Add(pointer != null && Integer(pointer, "m_FileID") == 0 ? Integer(pointer, "m_PathID") : 0);
            }
            return ids;
        }

        public WPFMAAnimationClipDecoder(WPFMASerializedFile cab, GameObject avatarRoot, List<string> warnings)
        {
            Report = new Stats();
            this.warnings = warnings ?? new List<string>();

            IndexClips(cab);
            IndexHierarchy(avatarRoot);
            IndexAnimatableBindings(avatarRoot);
            IndexProperties(avatarRoot);
            IndexBundleMaterials(cab);
            IndexControllerNames(cab);
        }

        private void IndexClips(WPFMASerializedFile cab)
        {
            if (cab == null)
                return;

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

                Dictionary<string, object> raw = null;
                try { raw = cab.ReadObject(info) as Dictionary<string, object>; }
                catch { continue; }

                if (raw == null)
                    continue;

                byPathId[info.PathId] = raw;

                object nameValue;
                string name = raw.TryGetValue("m_Name", out nameValue) ? nameValue as string : null;
                if (string.IsNullOrEmpty(name))
                    continue;

                List<Dictionary<string, object>> list;
                if (!byName.TryGetValue(name, out list))
                    byName[name] = list = new List<Dictionary<string, object>>();
                list.Add(raw);
            }
        }

        private void IndexHierarchy(GameObject avatarRoot)
        {
            if (avatarRoot == null)
                return;

            var rootTransform = avatarRoot.transform;
            foreach (var transform in avatarRoot.GetComponentsInChildren<Transform>(true))
            {
                string path = RelativePath(rootTransform, transform);
                pathNames[Crc32(path)] = path;
                objectsByPath[path] = transform.gameObject;
            }
        }

        private static string RelativePath(Transform root, Transform target)
        {
            if (target == root)
                return string.Empty;

            var parts = new List<string>();
            for (var current = target; current != null && current != root; current = current.parent)
                parts.Add(current.name);
            parts.Reverse();
            return string.Join("/", parts.ToArray());
        }

        private void IndexProperties(GameObject avatarRoot)
        {
            foreach (var name in BuiltinProperties())
                Offer(propertyNames, name);

            foreach (var name in MuscleProperties())
                Offer(propertyNames, name);

            if (avatarRoot == null)
                return;

            foreach (var renderer in avatarRoot.GetComponentsInChildren<Renderer>(true))
            {
                var skinned = renderer as SkinnedMeshRenderer;
                if (skinned != null && skinned.sharedMesh != null)
                {
                    for (int i = 0; i < skinned.sharedMesh.blendShapeCount; i++)
                    {
                        string shape = skinned.sharedMesh.GetBlendShapeName(i);
                        if (!string.IsNullOrEmpty(shape))
                            blendShapeNames[Crc32(shape)] = shape;
                    }
                }

                for (int i = 0; i < 16; i++)
                    Offer(propertyNames, "m_Materials.Array.data[" + i + "]");

                foreach (var material in renderer.sharedMaterials)
                    OfferMaterialProperties(material);
            }

            foreach (var component in avatarRoot.GetComponentsInChildren<Component>(true))
                OfferSerializedFields(component);
        }

        private void OfferMaterialProperties(Material material)
        {
            if (material == null || material.shader == null)
                return;

            int count;
            try { count = ShaderUtil.GetPropertyCount(material.shader); }
            catch { return; }

            for (int i = 0; i < count; i++)
            {
                try { OfferMaterialProperty(ShaderUtil.GetPropertyName(material.shader, i)); }
                catch { }
            }
        }

        private void OfferMaterialProperty(string property)
        {
            if (string.IsNullOrEmpty(property))
                return;

            foreach (var variant in new[] { property, property + "_ST", property + "_TexelSize", property + "_HDR" })
            {
                uint low28 = Crc32(variant) & 0x0FFFFFFFu;
                if (!materialProperties.ContainsKey(low28))
                    materialProperties[low28] = variant;
            }

            string prefixed = "material." + property;
            Offer(propertyNames, prefixed);

            foreach (var suffix in new[] { ".x", ".y", ".z", ".w", ".r", ".g", ".b", ".a" })
            {
                Offer(propertyNames, prefixed + suffix);
                Offer(propertyNames, prefixed + "_ST" + suffix);
            }
        }

        private void IndexBundleMaterials(WPFMASerializedFile cab)
        {
            if (cab == null)
                return;

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

                Dictionary<string, object> material = null;
                try { material = cab.ReadObject(info) as Dictionary<string, object>; }
                catch { continue; }

                var saved = Unwrap(material, "m_SavedProperties");
                if (saved == null)
                    continue;

                foreach (var bucket in new[] { "m_TexEnvs", "m_Floats", "m_Colors", "m_Ints" })
                {
                    object listValue;
                    var list = saved.TryGetValue(bucket, out listValue) ? listValue as List<object> : null;
                    if (list == null)
                        continue;

                    foreach (var entry in list)
                        OfferMaterialProperty(PropertyNameOf(entry));
                }
            }
        }

        private void IndexControllerNames(WPFMASerializedFile cab)
        {
            if (cab == null)
                return;

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

                Dictionary<string, object> controller = null;
                try { controller = cab.ReadObject(info) as Dictionary<string, object>; }
                catch { continue; }

                object tosValue;
                var tos = controller != null && controller.TryGetValue("m_TOS", out tosValue) ? tosValue as List<object> : null;
                if (tos == null)
                    continue;

                foreach (var entry in tos)
                {
                    var pair = entry as Dictionary<string, object>;
                    object second;
                    if (pair != null && pair.TryGetValue("second", out second))
                        Offer(propertyNames, second as string);
                }
            }
        }

        private static string MaterialPropertyName(string property, uint attribute)
        {
            if ((attribute & 0x80000000u) != 0)
                return "material." + property;

            int channel = (int)((attribute >> 28) & 3u);
            bool colour = ((attribute >> 30) & 1u) != 0;
            return "material." + property + "." + (colour ? "rgba" : "xyzw")[channel];
        }

        private static string PropertyNameOf(object entry)
        {
            var pair = entry as Dictionary<string, object>;
            object first;
            if (pair == null || !pair.TryGetValue("first", out first))
                return null;

            var name = first as string;
            if (name != null)
                return name;

            var nested = first as Dictionary<string, object>;
            object nameValue;
            if (nested != null && nested.TryGetValue("name", out nameValue))
                return nameValue as string;

            return null;
        }

        private void IndexAnimatableBindings(GameObject avatarRoot)
        {
            if (avatarRoot == null)
                return;

            var animatedPaths = new HashSet<uint>();
            foreach (var raw in byPathId.Values)
            {
                object constantValue;
                var constant = raw.TryGetValue("m_ClipBindingConstant", out constantValue)
                    ? constantValue as Dictionary<string, object>
                    : null;
                object listValue;
                var bindings = constant != null && constant.TryGetValue("genericBindings", out listValue)
                    ? listValue as List<object>
                    : null;
                if (bindings == null)
                    continue;

                foreach (var entry in bindings)
                {
                    var item = entry as Dictionary<string, object>;
                    if (item == null)
                        continue;

                    long typeId = Integer(item, "typeID");
                    if (typeId == 1 || typeId == 4 || typeId == 95)
                        continue;

                    animatedPaths.Add(unchecked((uint)Integer(item, "path")));
                }
            }

            foreach (var hash in animatedPaths)
            {
                string path;
                GameObject target;
                if (!pathNames.TryGetValue(hash, out path) || !objectsByPath.TryGetValue(path, out target) || target == null)
                    continue;

                EditorCurveBinding[] available;
                try { available = AnimationUtility.GetAnimatableBindings(target, avatarRoot); }
                catch { continue; }

                foreach (var binding in available)
                {
                    string name = binding.propertyName;
                    if (string.IsNullOrEmpty(name))
                        continue;

                    if (name.StartsWith("blendShape.", StringComparison.Ordinal))
                    {
                        string shape = name.Substring("blendShape.".Length);
                        uint shapeHash = Crc32(shape);
                        if (!blendShapeNames.ContainsKey(shapeHash))
                            blendShapeNames[shapeHash] = shape;
                        continue;
                    }

                    if (name.StartsWith("material.", StringComparison.Ordinal))
                        continue;

                    Offer(propertyNames, name);

                    ulong key = BindingKey(hash, Crc32(name));
                    if (binding.type != null && !exactTypes.ContainsKey(key))
                        exactTypes[key] = binding.type;
                }
            }
        }

        private void OfferSerializedFields(Component component)
        {
            if (component == null)
                return;

            try
            {
                var serialized = new SerializedObject(component);
                var iterator = serialized.GetIterator();
                int guard = 0;
                while (iterator.NextVisible(true) && guard++ < 4096)
                    Offer(propertyNames, iterator.propertyPath);
                serialized.Dispose();
            }
            catch { }
        }

        private static void Offer(Dictionary<uint, string> table, string name)
        {
            if (string.IsNullOrEmpty(name))
                return;

            uint hash = Crc32(name);
            if (!table.ContainsKey(hash))
                table[hash] = name;
        }

        private static IEnumerable<string> BuiltinProperties()
        {
            yield return "m_IsActive";
            yield return "m_Enabled";

            foreach (var axis in new[] { "x", "y", "z" })
            {
                yield return "m_LocalPosition." + axis;
                yield return "m_LocalScale." + axis;
                yield return "localEulerAnglesRaw." + axis;
                yield return "localEulerAngles." + axis;
            }

            foreach (var axis in new[] { "x", "y", "z", "w" })
                yield return "m_LocalRotation." + axis;

            foreach (var channel in new[] { "r", "g", "b", "a" })
                yield return "m_Color." + channel;

            yield return "m_Intensity";
            yield return "m_Range";
            yield return "m_SpotAngle";
            yield return "m_Mesh";
            yield return "m_Sprite";
            yield return "m_Volume";
            yield return "m_Pitch";
            yield return "m_ReceiveShadows";
            yield return "m_CastShadows";
        }

        private static IEnumerable<string> MuscleProperties()
        {
            foreach (var muscle in HumanTrait.MuscleName)
                yield return ToBindingName(muscle);

            var roots = new[]
            {
                "RootT", "RootQ", "MotionT", "MotionQ",
                "LeftFootT", "LeftFootQ", "RightFootT", "RightFootQ",
                "LeftHandT", "LeftHandQ", "RightHandT", "RightHandQ"
            };

            foreach (var root in roots)
                foreach (var axis in new[] { ".x", ".y", ".z", ".w" })
                    yield return root + axis;

            foreach (var axis in new[] { ".x", ".y", ".z" })
            {
                yield return "LeftFootIK" + axis;
                yield return "RightFootIK" + axis;
                yield return "LeftHandIK" + axis;
                yield return "RightHandIK" + axis;
                yield return "LookAtPosition" + axis;
            }

            foreach (var axis in new[] { ".x", ".y", ".z", ".w" })
                yield return "LookAtWeight" + axis;
        }

        public bool Restore(AnimationClip target, long pathId)
        {
            Dictionary<string, object> raw;
            if (target == null || pathId == 0 || !byPathId.TryGetValue(pathId, out raw))
                return Restore(target);

            Report.ClipsMatched++;
            try
            {
                return Rebuild(target, raw);
            }
            catch (Exception e)
            {
                warnings.Add("Could not rebuild the curves for '" + target.name + "': " + e.Message);
                return false;
            }
        }

        public bool Restore(AnimationClip target)
        {
            List<Dictionary<string, object>> candidates;
            if (target == null || !byName.TryGetValue(target.name, out candidates) || candidates.Count == 0)
                return false;

            var raw = Pick(candidates, target);
            Report.ClipsMatched++;

            try
            {
                return Rebuild(target, raw);
            }
            catch (Exception e)
            {
                warnings.Add("Could not rebuild the curves for '" + target.name + "': " + e.Message);
                return false;
            }
        }

        private static Dictionary<string, object> Pick(List<Dictionary<string, object>> candidates, AnimationClip target)
        {
            if (candidates.Count == 1)
                return candidates[0];

            int best = 0;
            float bestDelta = float.MaxValue;

            for (int i = 0; i < candidates.Count; i++)
            {
                var muscle = Unwrap(candidates[i], "m_MuscleClip");
                float stop = muscle != null ? Single(muscle, "m_StopTime") : 0f;
                float delta = Mathf.Abs(stop - target.length);
                if (delta < bestDelta)
                {
                    bestDelta = delta;
                    best = i;
                }
            }

            var chosen = candidates[best];
            candidates.RemoveAt(best);
            return chosen;
        }

        private bool Rebuild(AnimationClip target, Dictionary<string, object> raw)
        {
            var muscle = Unwrap(raw, "m_MuscleClip");
            if (muscle == null)
                return false;

            var core = Unwrap(muscle, "m_Clip");
            if (core == null)
                return false;

            var bindings = ReadBindings(raw);
            if (bindings.Count == 0)
                return false;

            float startTime = Single(muscle, "m_StartTime");
            float stopTime = Single(muscle, "m_StopTime");

            var curves = new List<AnimationCurve>();
            ReadStreamed(core, curves, startTime);
            ReadDense(core, curves);
            ReadConstant(core, curves, startTime, stopTime);

            if (curves.Count == 0)
                return false;

            target.ClearCurves();

            int written = WriteCurves(target, bindings, curves, ReadObjectMapping(raw));
            ApplySettings(target, muscle);

            if (written > 0)
                Report.ClipsRestored++;

            Report.CurvesWritten += written;
            return written > 0;
        }

        private int WriteCurves(AnimationClip target, List<Binding> bindings, List<AnimationCurve> curves, List<long> objectMapping)
        {
            int slot = 0;
            int written = 0;

            foreach (var binding in bindings)
            {
                int dimension = binding.Dimension;

                if (binding.IsPPtr)
                {
                    if (slot < curves.Count && WriteObjectCurve(target, binding, curves[slot], objectMapping))
                    {
                        Report.PPtrCurvesWritten++;
                        written++;
                    }
                    else
                    {
                        Report.PPtrCurvesSkipped++;
                    }

                    slot += dimension;
                    continue;
                }

                if (slot + dimension > curves.Count)
                    break;

                string path = ResolvePath(binding.Path);
                if (path == null)
                {
                    slot += dimension;
                    continue;
                }

                var names = ResolveProperties(binding, dimension);
                if (names == null)
                {
                    slot += dimension;
                    continue;
                }

                Type type;
                if (dimension != 1 || !exactTypes.TryGetValue(BindingKey(binding.Path, binding.Attribute), out type))
                    type = ResolveType(binding, path, names[0]);

                for (int i = 0; i < dimension; i++)
                {
                    var curve = curves[slot + i];
                    if (curve == null || curve.length == 0)
                        continue;

                    var editorBinding = new EditorCurveBinding
                    {
                        path = path,
                        type = type,
                        propertyName = names[i]
                    };

                    AnimationUtility.SetEditorCurve(target, editorBinding, curve);
                    written++;
                }

                slot += dimension;
            }

            return written;
        }

        private bool WriteObjectCurve(AnimationClip target, Binding binding, AnimationCurve curve, List<long> objectMapping)
        {
            if (ResolveObject == null || curve == null || curve.length == 0 || objectMapping == null || objectMapping.Count == 0)
                return false;

            bool renderer = binding.TypeId == 137 || binding.TypeId == 23 || binding.TypeId == 25;
            if (!renderer || binding.CustomType != 21)
                return false;

            string path = ResolvePath(binding.Path);
            if (path == null)
                return false;

            string property = "m_Materials.Array.data[" + binding.Attribute + "]";
            var keys = new List<ObjectReferenceKeyframe>();
            foreach (var key in curve.keys)
            {
                int index = Mathf.RoundToInt(key.value);
                if (index < 0 || index >= objectMapping.Count || objectMapping[index] == 0)
                    continue;

                var resolved = ResolveObject(objectMapping[index]);
                if (resolved == null)
                    continue;

                keys.Add(new ObjectReferenceKeyframe { time = key.time, value = resolved });
            }

            if (keys.Count == 0)
                return false;

            var editorBinding = EditorCurveBinding.PPtrCurve(path, ResolveType(binding, path, property), property);
            AnimationUtility.SetObjectReferenceCurve(target, editorBinding, keys.ToArray());
            return true;
        }

        private void ApplySettings(AnimationClip target, Dictionary<string, object> muscle)
        {
            var settings = AnimationUtility.GetAnimationClipSettings(target);
            settings.startTime = Single(muscle, "m_StartTime");
            settings.stopTime = Single(muscle, "m_StopTime");
            settings.loopTime = Integer(muscle, "m_LoopTime") != 0;
            settings.loopBlend = Integer(muscle, "m_LoopBlend") != 0;
            settings.cycleOffset = Single(muscle, "m_CycleOffset");
            settings.orientationOffsetY = Single(muscle, "m_OrientationOffsetY");
            settings.level = Single(muscle, "m_Level");
            settings.keepOriginalPositionY = Integer(muscle, "m_KeepOriginalPositionY") != 0;
            settings.keepOriginalPositionXZ = Integer(muscle, "m_KeepOriginalPositionXZ") != 0;
            settings.keepOriginalOrientation = Integer(muscle, "m_KeepOriginalOrientation") != 0;
            settings.heightFromFeet = Integer(muscle, "m_HeightFromFeet") != 0;
            settings.mirror = Integer(muscle, "m_Mirror") != 0;
            AnimationUtility.SetAnimationClipSettings(target, settings);
        }

        private static void ReadStreamed(Dictionary<string, object> core, List<AnimationCurve> curves, float startTime)
        {
            object value;
            var streamed = core.TryGetValue("m_StreamedClip", out value) ? value as Dictionary<string, object> : null;
            if (streamed == null)
                return;

            int curveCount = (int)(Integer(streamed, "curveCount") + Integer(streamed, "discreteCurveCount"));
            if (curveCount <= 0)
                return;

            int baseIndex = curves.Count;
            for (int i = 0; i < curveCount; i++)
                curves.Add(new AnimationCurve());

            var words = Words(streamed, "data");
            if (words.Length == 0)
                return;

            var frames = ParseStreamedFrames(words, curveCount);

            for (int f = 1; f + 1 < frames.Count; f++)
            {
                var frame = frames[f];
                foreach (var key in frame.Keys)
                {
                    if (key.Index < 0 || key.Index >= curveCount)
                        continue;

                    float inSlope = InSlopeInto(frames, f, key.Index, frame.Time);
                    curves[baseIndex + key.Index].AddKey(new Keyframe(frame.Time, key.Value, inSlope, key.OutSlope));
                }
            }

            if (frames.Count > 0 && frames[0].Time <= -1e30f)
            {
                foreach (var key in frames[0].Keys)
                {
                    if (!key.IsStep || key.Index < 0 || key.Index >= curveCount)
                        continue;

                    var curve = curves[baseIndex + key.Index];
                    if (curve.length > 0 && curve.keys[0].time <= startTime + 1e-5f)
                        continue;

                    curve.AddKey(new Keyframe(startTime, key.Value, float.PositiveInfinity, float.PositiveInfinity));
                }
            }
        }

        private struct StreamedKey
        {
            public int Index;
            public float C0, C1, C2, C3;

            public float Value { get { return C3; } }
            public bool IsStep { get { return C0 == 0f && C1 == 0f && C2 == 0f; } }
            public float OutSlope { get { return IsStep ? float.PositiveInfinity : C2; } }
        }

        private sealed class StreamedFrame
        {
            public float Time;
            public readonly List<StreamedKey> Keys = new List<StreamedKey>();
        }

        private static List<StreamedFrame> ParseStreamedFrames(uint[] words, int curveCount)
        {
            var frames = new List<StreamedFrame>();
            int i = 0;

            while (i + 1 < words.Length)
            {
                var frame = new StreamedFrame { Time = AsFloat(words[i++]) };
                int count = (int)words[i++];

                if (count < 0 || count > curveCount || i + count * 5 > words.Length)
                {
                    frames.Add(frame);
                    break;
                }

                for (int k = 0; k < count; k++)
                {
                    frame.Keys.Add(new StreamedKey
                    {
                        Index = (int)words[i],
                        C0 = AsFloat(words[i + 1]),
                        C1 = AsFloat(words[i + 2]),
                        C2 = AsFloat(words[i + 3]),
                        C3 = AsFloat(words[i + 4])
                    });
                    i += 5;
                }

                frames.Add(frame);
            }

            return frames;
        }

        private static float InSlopeInto(List<StreamedFrame> frames, int frameIndex, int curveIndex, float time)
        {
            for (int f = frameIndex - 1; f >= 0; f--)
            {
                foreach (var key in frames[f].Keys)
                {
                    if (key.Index != curveIndex)
                        continue;

                    if (key.IsStep)
                        return float.PositiveInfinity;

                    float dt = Mathf.Max(time - frames[f].Time, 1e-4f);
                    return 3f * key.C0 * dt * dt + 2f * key.C1 * dt + key.C2;
                }
            }

            return 0f;
        }

        private static void ReadDense(Dictionary<string, object> core, List<AnimationCurve> curves)
        {
            object value;
            var dense = core.TryGetValue("m_DenseClip", out value) ? value as Dictionary<string, object> : null;
            if (dense == null)
                return;

            int curveCount = (int)Integer(dense, "m_CurveCount");
            if (curveCount <= 0)
                return;

            int frameCount = (int)Integer(dense, "m_FrameCount");
            float sampleRate = Single(dense, "m_SampleRate");
            float beginTime = Single(dense, "m_BeginTime");
            if (sampleRate <= 0f)
                sampleRate = 60f;

            var samples = Floats(dense, "m_SampleArray");

            for (int c = 0; c < curveCount; c++)
            {
                var curve = new AnimationCurve();
                for (int f = 0; f < frameCount; f++)
                {
                    int index = f * curveCount + c;
                    if (index >= samples.Length)
                        break;

                    float sample = samples[index];
                    float inSlope = 0f, outSlope = 0f;

                    if (f > 0)
                        inSlope = (sample - samples[(f - 1) * curveCount + c]) * sampleRate;
                    if (f + 1 < frameCount && (f + 1) * curveCount + c < samples.Length)
                        outSlope = (samples[(f + 1) * curveCount + c] - sample) * sampleRate;

                    curve.AddKey(new Keyframe(beginTime + f / sampleRate, sample, inSlope, outSlope));
                }

                curves.Add(curve);
            }
        }

        private static void ReadConstant(Dictionary<string, object> core, List<AnimationCurve> curves,
            float startTime, float stopTime)
        {
            object value;
            var constant = core.TryGetValue("m_ConstantClip", out value) ? value as Dictionary<string, object> : null;
            if (constant == null)
                return;

            var values = Floats(constant, "data");
            if (stopTime <= startTime)
                stopTime = startTime + 1f / 60f;

            foreach (var constantValue in values)
            {
                var curve = new AnimationCurve();
                curve.AddKey(new Keyframe(startTime, constantValue, 0f, 0f));
                curve.AddKey(new Keyframe(stopTime, constantValue, 0f, 0f));
                curves.Add(curve);
            }
        }

        private struct Binding
        {
            public uint Path;
            public uint Attribute;
            public int TypeId;
            public int CustomType;
            public bool IsPPtr;
            public int Dimension;
        }

        private static List<Binding> ReadBindings(Dictionary<string, object> raw)
        {
            var result = new List<Binding>();

            object value;
            var constant = raw.TryGetValue("m_ClipBindingConstant", out value)
                ? value as Dictionary<string, object>
                : null;
            if (constant == null)
                return result;

            var list = constant.TryGetValue("genericBindings", out value) ? value as List<object> : null;
            if (list == null)
                return result;

            foreach (var entry in list)
            {
                var item = entry as Dictionary<string, object>;
                if (item == null)
                    continue;

                var binding = new Binding
                {
                    Path = unchecked((uint)Integer(item, "path")),
                    Attribute = unchecked((uint)Integer(item, "attribute")),
                    TypeId = (int)Integer(item, "typeID"),
                    CustomType = (int)Integer(item, "customType"),
                    IsPPtr = Integer(item, "isPPtrCurve") != 0
                };

                binding.Dimension = DimensionOf(binding);
                result.Add(binding);
            }

            return result;
        }

        private static int DimensionOf(Binding binding)
        {
            if (binding.TypeId != 4)
                return 1;

            switch (binding.Attribute)
            {
                case 1: return 3;
                case 2: return 4;
                case 3: return 3;
                case 4: return 3;
                default: return 1;
            }
        }

        private string ResolvePath(uint hash)
        {
            if (hash == 0)
                return string.Empty;

            string path;
            if (pathNames.TryGetValue(hash, out path))
                return path;

            Report.BindingsUnresolvedPath++;
            if (reportedPaths.Add(hash) && reportedPaths.Count <= 12)
                warnings.Add("An animated object could not be located in the hierarchy (path hash " + hash + ").");
            return null;
        }

        private string[] ResolveProperties(Binding binding, int dimension)
        {
            if (binding.TypeId == 4)
            {
                switch (binding.Attribute)
                {
                    case 1:
                        return new[] { "m_LocalPosition.x", "m_LocalPosition.y", "m_LocalPosition.z" };
                    case 2:
                        return new[] { "m_LocalRotation.x", "m_LocalRotation.y", "m_LocalRotation.z", "m_LocalRotation.w" };
                    case 3:
                        return new[] { "m_LocalScale.x", "m_LocalScale.y", "m_LocalScale.z" };
                    case 4:
                        return new[] { "localEulerAnglesRaw.x", "localEulerAnglesRaw.y", "localEulerAnglesRaw.z" };
                }
            }

            if (binding.TypeId == 95)
            {
                var channels = AnimatorChannels;
                if (binding.Attribute < channels.Length)
                    return new[] { channels[binding.Attribute] };
            }

            string materialProperty;
            if (binding.CustomType == 22 && materialProperties.TryGetValue(binding.Attribute & 0x0FFFFFFFu, out materialProperty))
                return new[] { MaterialPropertyName(materialProperty, binding.Attribute) };

            string shape;
            if (binding.CustomType == 20 && blendShapeNames.TryGetValue(binding.Attribute, out shape))
                return new[] { "blendShape." + shape };

            string property;
            if (propertyNames.TryGetValue(binding.Attribute, out property))
            {
                if (dimension == 1)
                    return new[] { property };

                var expanded = new string[dimension];
                for (int i = 0; i < dimension; i++)
                    expanded[i] = property;
                return expanded;
            }

            Report.BindingsUnresolvedProperty++;
            if (reportedProperties.Add(binding.Attribute) && reportedProperties.Count <= 12)
                warnings.Add("An animated property could not be named (type " + binding.TypeId +
                             ", attribute hash " + binding.Attribute + ").");
            return null;
        }

        private Type ResolveType(Binding binding, string path, string property)
        {
            switch (binding.TypeId)
            {
                case 1: return typeof(GameObject);
                case 4: return typeof(Transform);
                case 20: return typeof(Camera);
                case 23: return typeof(MeshRenderer);
                case 25: return typeof(Renderer);
                case 33: return typeof(MeshFilter);
                case 54: return typeof(Rigidbody);
                case 64: return typeof(MeshCollider);
                case 65: return typeof(BoxCollider);
                case 82: return typeof(AudioSource);
                case 95: return typeof(Animator);
                case 96: return typeof(TrailRenderer);
                case 108: return typeof(Light);
                case 120: return typeof(LineRenderer);
                case 135: return typeof(SphereCollider);
                case 136: return typeof(CapsuleCollider);
                case 137: return typeof(SkinnedMeshRenderer);
                case 198: return typeof(ParticleSystem);
                case 212: return typeof(SpriteRenderer);
            }

            if (binding.TypeId == 114)
            {
                var resolved = ResolveBehaviourType(path, property);
                if (resolved != null)
                    return resolved;
            }

            var engineType = EngineTypeForClassId(binding.TypeId);
            if (engineType != null)
                return engineType;

            return typeof(GameObject);
        }

        private static readonly Dictionary<int, Type> engineTypeCache = new Dictionary<int, Type>();

        private static Type EngineTypeForClassId(int classId)
        {
            Type cached;
            if (engineTypeCache.TryGetValue(classId, out cached))
                return cached;

            Type found = null;
            try
            {
                var unityType = typeof(UnityEditor.Editor).Assembly.GetType("UnityEditor.UnityType");
                var find = unityType != null ? unityType.GetMethod("FindTypeByPersistentTypeID",
                    System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic) : null;
                var entry = find != null ? find.Invoke(null, new object[] { classId }) : null;
                var nameProperty = entry != null ? unityType.GetProperty("name",
                    System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic) : null;
                string name = nameProperty != null ? nameProperty.GetValue(entry, null) as string : null;

                if (!string.IsNullOrEmpty(name))
                {
                    foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
                    {
                        if (!assembly.GetName().Name.StartsWith("UnityEngine", StringComparison.Ordinal))
                            continue;

                        var candidate = assembly.GetType("UnityEngine." + name, false);
                        if (candidate != null && typeof(Component).IsAssignableFrom(candidate))
                        {
                            found = candidate;
                            break;
                        }
                    }
                }
            }
            catch (Exception)
            {
                found = null;
            }

            engineTypeCache[classId] = found;
            return found;
        }

        private Type ResolveBehaviourType(string path, string property)
        {
            GameObject target;
            if (!objectsByPath.TryGetValue(path ?? string.Empty, out target) || target == null)
                return null;

            foreach (var behaviour in target.GetComponents<MonoBehaviour>())
            {
                if (behaviour == null)
                    continue;

                try
                {
                    var serialized = new SerializedObject(behaviour);
                    bool found = serialized.FindProperty(property) != null;
                    serialized.Dispose();
                    if (found)
                        return behaviour.GetType();
                }
                catch { }
            }

            return null;
        }

        private static Dictionary<string, object> Unwrap(Dictionary<string, object> parent, string key)
        {
            object value;
            if (parent == null || !parent.TryGetValue(key, out value))
                return null;

            var dictionary = value as Dictionary<string, object>;
            if (dictionary == null)
                return null;

            object inner;
            if (dictionary.Count == 1 && dictionary.TryGetValue("data", out inner))
                return inner as Dictionary<string, object> ?? dictionary;

            return dictionary;
        }

        private static long Integer(Dictionary<string, object> source, string key)
        {
            object value;
            if (source == null || !source.TryGetValue(key, out value) || value == null)
                return 0;

            try { return Convert.ToInt64(value); }
            catch { return 0; }
        }

        private static float Single(Dictionary<string, object> source, string key)
        {
            object value;
            if (source == null || !source.TryGetValue(key, out value) || value == null)
                return 0f;

            try { return Convert.ToSingle(value); }
            catch { return 0f; }
        }

        private static uint[] Words(Dictionary<string, object> source, string key)
        {
            object value;
            var list = source != null && source.TryGetValue(key, out value) ? value as List<object> : null;
            if (list == null)
                return new uint[0];

            var result = new uint[list.Count];
            for (int i = 0; i < list.Count; i++)
            {
                try { result[i] = unchecked((uint)Convert.ToInt64(list[i])); }
                catch { result[i] = 0; }
            }
            return result;
        }

        private static float[] Floats(Dictionary<string, object> source, string key)
        {
            object value;
            var list = source != null && source.TryGetValue(key, out value) ? value as List<object> : null;
            if (list == null)
                return new float[0];

            var result = new float[list.Count];
            for (int i = 0; i < list.Count; i++)
            {
                try { result[i] = Convert.ToSingle(list[i]); }
                catch { result[i] = 0f; }
            }
            return result;
        }

        private static float AsFloat(uint bits)
        {
            return BitConverter.ToSingle(BitConverter.GetBytes(bits), 0);
        }

        public static uint Crc32(string text)
        {
            uint crc = 0xFFFFFFFFu;
            foreach (byte b in Encoding.UTF8.GetBytes(text ?? string.Empty))
            {
                crc ^= b;
                for (int i = 0; i < 8; i++)
                    crc = (crc & 1) != 0 ? (crc >> 1) ^ 0xEDB88320u : crc >> 1;
            }
            return crc ^ 0xFFFFFFFFu;
        }
    }
}
#endif
