using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using HarmonyLib;
using RedLoader;
using RedLoader.Utils;
using Sons.Ai.Vail;
using Sons.Multiplayer.Client;
using Sons.Wearable.Clothing;
using Sons.Wearable.Race;
using SonsSdk;
using SonsSdk.Attributes;
using TheForest.Utils;
using UnityEngine;

namespace RigProbe;

public class RigProbe : SonsMod
{
    private static readonly JsonSerializerOptions Json = new() { WriteIndented = true };
    private static HashSet<string> _playerBoneNames = new();

    private static readonly string[] EmoteNames =
    {
        "HappyThumbsUp", "ThumbsUp", "Nod", "HappyFistPump", "FistPump", "Confused", "HitHeadSmall", "HitHeadBig",
        "ShakeHead", "NoHandUp", "Sad", "Happy", "Laugh", "WagFingerNo", "SkunkReact", "OnPlayerNod",
        "OnPlayerCrash", "OnPlayerSmallHit", "Wave", "Point", "Cheer", "Dance", "Salute", "Clap", "Shrug",
        "NodHead", "IdleScratchHead", "IdleSwatFly", "IdleLookVar1", "couchIdle", "seatedRockIdle", "injuredLoop",
        "standUpIdle", "standup", "wakeUp", "checkArms", "coldIdleVar1", "PlayerALighterLookAt", "PlayerAAngry", "PlayerAScared"
    };

    private const BindingFlags AllDeclared = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly;

    private static Animator _watchAnimator;
    private static string _watchTarget;
    private static int[] _watchLast;
    private static StreamWriter _watchLog;
    private static Dictionary<int, string> _watchNames;
    private static readonly Dictionary<string, WatchEntry> WatchSeen = new();
    private static string _watchStatesPath;
    private static float[] _watchWeights;
    private static List<(string Name, int Hash, AnimatorControllerParameterType Type)> _watchParams;
    private static int[] _watchParamLast;

    private static bool _netHooked;
    private static StreamWriter _netLog;
    private static Type _netEventType;
    private static Type _il2cppStackType;
    private static HarmonyLib.Harmony _harmony;
    private static Dictionary<int, string> _netNames = new();
    private static readonly Dictionary<string, int> NetCallCounts = new();

    public RigProbe()
    {
        OnUpdateCallback = OnUpdate;
    }

    protected override void OnSdkInitialized()
    {
        RLog.Msg("RigProbe loaded. Commands: rigprobe [filter], rigscene, rigwatch [player|robby|virginia|off], rigspawn <TypeName> [variation], rigplay <layer> <state|hash> [fade], rigparam <name> [value], rigweight <layer> <weight>, rignet");
    }

    [DebugCommand("rigprobe")]
    private static void ProbeCommand(string args)
    {
        try
        {
            RunProbe((args ?? string.Empty).Trim(), false);
        }
        catch (Exception e)
        {
            RLog.Error($"rigprobe failed: {e}");
        }
    }

    [DebugCommand("rigscene")]
    private static void SceneCommand(string args)
    {
        try
        {
            RunProbe(string.Empty, true);
        }
        catch (Exception e)
        {
            RLog.Error($"rigscene failed: {e}");
        }
    }

    [DebugCommand("rigwatch")]
    private static void WatchCommand(string args)
    {
        try
        {
            StartWatch((args ?? string.Empty).Trim().ToLowerInvariant());
        }
        catch (Exception e)
        {
            RLog.Error($"rigwatch failed: {e}");
        }
    }

    [DebugCommand("rigspawn")]
    private static void SpawnCommand(string args)
    {
        var parts = (args ?? string.Empty).Trim().Split(' ', StringSplitOptions.RemoveEmptyEntries);
        if (parts.Length == 0 || !Enum.TryParse<VailActorTypeId>(parts[0], true, out var id))
        {
            Say("Usage: rigspawn <TypeName> [variation]  e.g. rigspawn Virginia");
            return;
        }

        var variation = parts.Length > 1 && int.TryParse(parts[1], out var v) ? v : 0;
        var player = LocalPlayer.GameObject;
        if (!player)
        {
            Say("Load into a game first");
            return;
        }

        try
        {
            var t = player.transform;
            var actor = ActorTools.Spawn(id, t.position + t.forward * 4f, variation);
            Say(actor ? $"Spawned {id} variation {variation}" : $"Spawn returned null for {id}");
        }
        catch (Exception e)
        {
            RLog.Error($"rigspawn {id} failed: {e.Message}");
        }
    }

    [DebugCommand("rigplay")]
    private static void PlayCommand(string args)
    {
        var parts = SplitArgs(args);
        if (parts.Length < 2)
        {
            Say("Usage: rigplay <layer> <state|hash> [fade]  e.g. rigplay fullBodyActions couchIdle 0.25");
            return;
        }

        try
        {
            var a = PlayerAnimator();
            if (!a)
            {
                Say("Load into a game first");
                return;
            }

            var layer = ResolveLayer(a, parts[0]);
            if (layer < 0)
            {
                Say($"rigplay: no layer {parts[0]}");
                return;
            }

            var ln = a.GetLayerName(layer);
            if (!int.TryParse(parts[1], out var hash))
            {
                var sh = Animator.StringToHash(parts[1]);
                var fh = Animator.StringToHash($"{ln}.{parts[1]}");
                hash = SafeHasState(a, layer, sh) ? sh : SafeHasState(a, layer, fh) ? fh : 0;
            }
            if (hash == 0 || !SafeHasState(a, layer, hash))
            {
                Say($"rigplay: {ln} has no state {parts[1]}");
                return;
            }

            var fade = parts.Length > 2 && float.TryParse(parts[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var f) ? f : 0.25f;
            if (fade <= 0f)
                a.Play(hash, layer, 0f);
            else
                a.CrossFadeInFixedTime(hash, fade, layer);

            Say($"rigplay: {ln} ({layer}) hash {hash} fade {fade:F2}, layer weight {a.GetLayerWeight(layer):F2}");
        }
        catch (Exception e)
        {
            RLog.Error($"rigplay failed: {e}");
        }
    }

    [DebugCommand("rigparam")]
    private static void ParamCommand(string args)
    {
        var parts = SplitArgs(args);
        if (parts.Length < 1)
        {
            Say("Usage: rigparam <name> [value]  e.g. rigparam couchBool 1");
            return;
        }

        try
        {
            var a = PlayerAnimator();
            if (!a)
            {
                Say("Load into a game first");
                return;
            }

            AnimatorControllerParameter found = null;
            foreach (var p in a.parameters)
            {
                if (string.Equals(p.name, parts[0], StringComparison.OrdinalIgnoreCase))
                {
                    found = p;
                    break;
                }
            }
            if (found is null)
            {
                Say($"rigparam: no parameter {parts[0]}");
                return;
            }

            var v = parts.Length > 1 ? parts[1] : "1";
            switch (found.type)
            {
                case AnimatorControllerParameterType.Trigger:
                    a.SetTrigger(found.nameHash);
                    break;
                case AnimatorControllerParameterType.Bool:
                    a.SetBool(found.nameHash, v == "1" || v.Equals("true", StringComparison.OrdinalIgnoreCase));
                    break;
                case AnimatorControllerParameterType.Int:
                    a.SetInteger(found.nameHash, int.Parse(v, CultureInfo.InvariantCulture));
                    break;
                case AnimatorControllerParameterType.Float:
                    a.SetFloat(found.nameHash, float.Parse(v, CultureInfo.InvariantCulture));
                    break;
            }

            Say($"rigparam: {found.name} ({found.type}) = {ParamValue(a, found.nameHash, found.type)}");
        }
        catch (Exception e)
        {
            RLog.Error($"rigparam failed: {e}");
        }
    }

    [DebugCommand("rigweight")]
    private static void WeightCommand(string args)
    {
        var parts = SplitArgs(args);
        if (parts.Length < 2 || !float.TryParse(parts[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var w))
        {
            Say("Usage: rigweight <layer> <weight>  e.g. rigweight fullBodyActions 1");
            return;
        }

        try
        {
            var a = PlayerAnimator();
            if (!a)
            {
                Say("Load into a game first");
                return;
            }

            var layer = ResolveLayer(a, parts[0]);
            if (layer < 0)
            {
                Say($"rigweight: no layer {parts[0]}");
                return;
            }

            a.SetLayerWeight(layer, w);
            Say($"rigweight: {a.GetLayerName(layer)} ({layer}) = {a.GetLayerWeight(layer):F2}");
        }
        catch (Exception e)
        {
            RLog.Error($"rigweight failed: {e}");
        }
    }

    [DebugCommand("rignet")]
    private static void NetCommand(string args)
    {
        try
        {
            HookNet();
        }
        catch (Exception e)
        {
            RLog.Error($"rignet failed: {e}");
        }
    }

    private static void RunProbe(string filter, bool sceneMode)
    {
        var player = LocalPlayer.GameObject;
        if (!player)
        {
            Say("Load into a game first");
            return;
        }

        var outDir = Path.Combine(LoaderEnvironment.UserDataDirectory, "RigProbe", sceneMode ? "scene" : "characters");
        if (Directory.Exists(outDir))
            Directory.Delete(outDir, true);
        Directory.CreateDirectory(outDir);

        var dumps = new List<CharacterDump>();
        var carryRoot = FindChild(player.transform, "CarryBody");

        var playerDump = DumpObject(player, "player", player.name, carryRoot);
        AddPlayerData(playerDump, player);
        _playerBoneNames = new HashSet<string>(playerDump.SkinnedMeshes.SelectMany(s => s.Bones).Select(LeafName));
        dumps.Add(playerDump);

        if (!sceneMode)
        {
            foreach (var setup in Resources.FindObjectsOfTypeAll<CoopPlayerRemoteSetup>())
            {
                if (!setup || !setup.gameObject.scene.IsValid() || IsUnder(setup.transform, player.transform))
                    continue;
                var go = setup.gameObject;
                var d = DumpObject(go, "remotePlayer", $"{go.name}_{go.GetInstanceID()}", null);
                AddPlayerData(d, go);
                dumps.Add(d);
            }

            if (carryRoot)
            {
                for (int i = 0; i < carryRoot.childCount; i++)
                {
                    var child = carryRoot.GetChild(i);
                    dumps.Add(DumpObject(child.gameObject, "carry", child.name, null));
                }
            }

            foreach (var id in Enum.GetValues(typeof(VailActorTypeId)).Cast<VailActorTypeId>())
            {
                if (id == VailActorTypeId.None)
                    continue;
                if (filter.Length > 0 && id.ToString().IndexOf(filter, StringComparison.OrdinalIgnoreCase) < 0)
                    continue;

                VailActor prefab = null;
                try
                {
                    prefab = ActorTools.GetPrefab(id);
                }
                catch (Exception e)
                {
                    RLog.Warning($"GetPrefab {id}: {e.Message}");
                }
                if (prefab)
                {
                    var d = DumpObject(prefab.gameObject, "actorPrefab", id.ToString(), null);
                    d.ActorType = id.ToString();
                    dumps.Add(d);
                }

                List<VailActor> live = null;
                try
                {
                    live = ActorTools.GetActors(id)?.Where(a => a).ToList();
                }
                catch (Exception e)
                {
                    RLog.Warning($"GetActors {id}: {e.Message}");
                }
                if (live == null)
                    continue;
                for (int i = 0; i < live.Count; i++)
                {
                    var d = DumpObject(live[i].gameObject, "actorLive", $"{id}_{i}", null);
                    d.ActorType = id.ToString();
                    dumps.Add(d);
                }
            }

            WriteClips(outDir);
        }
        else
        {
            var skip = new HashSet<int>();
            foreach (var t in player.GetComponentsInChildren<Transform>(true))
                skip.Add(t.GetInstanceID());

            var roots = new Dictionary<int, Transform>();
            var members = new Dictionary<int, List<SkinnedMeshRenderer>>();
            foreach (var smr in Resources.FindObjectsOfTypeAll<SkinnedMeshRenderer>())
            {
                if (!smr || !smr.gameObject.scene.IsValid() || skip.Contains(smr.transform.GetInstanceID()))
                    continue;
                var root = CharacterRoot(smr);
                if (!root)
                    continue;
                var key = root.GetInstanceID();
                if (!roots.ContainsKey(key))
                {
                    roots[key] = root;
                    members[key] = new List<SkinnedMeshRenderer>();
                }
                members[key].Add(smr);
            }
            foreach (var kv in roots)
            {
                var root = kv.Value;
                dumps.Add(DumpObject(root.gameObject, "scene", $"{root.name}_{kv.Key}", null, members[kv.Key]));
            }
        }

        foreach (var d in dumps)
        {
            d.PlayerNameMatch = PlayerMatch(d);
            d.RigFamily = Family(d);
            var file = Path.Combine(outDir, $"{d.Source}_{Sanitize(d.Name)}.json");
            File.WriteAllText(file, JsonSerializer.Serialize(d, Json));
        }

        WriteIndex(outDir, dumps);
        WriteFamilies(outDir, dumps);
        Say($"RigProbe: {dumps.Count} characters written to {outDir}");
    }

    private static CharacterDump DumpObject(GameObject go, string source, string name, Transform exclude, List<SkinnedMeshRenderer> only = null)
    {
        var root = go.transform;
        var dump = new CharacterDump
        {
            Name = name,
            Source = source,
            Path = HierPath(root),
            Active = go.activeInHierarchy
        };

        var smrs = only ?? go.GetComponentsInChildren<SkinnedMeshRenderer>(true)
            .Where(r => r && !(exclude && IsUnder(r.transform, exclude)))
            .ToList();

        var rigIds = new HashSet<int>();
        foreach (var r in smrs)
        {
            var bones = r.bones;
            if (bones != null)
            {
                foreach (var b in bones)
                    AddWithAncestors(b, root, rigIds);
            }
            AddWithAncestors(r.rootBone, root, rigIds);
        }

        var animatorIds = new HashSet<int>();
        foreach (var a in go.GetComponentsInChildren<Animator>(true))
        {
            if (!a || (exclude && IsUnder(a.transform, exclude)))
                continue;
            if (only != null && a.transform != root && !rigIds.Contains(a.transform.GetInstanceID()))
                continue;
            AddWithAncestors(a.transform, root, rigIds);
            animatorIds.Add(a.transform.GetInstanceID());
            dump.Animators.Add(DumpAnimator(a, root));
        }

        foreach (var t in go.GetComponentsInChildren<Transform>(true))
        {
            var id = t.GetInstanceID();
            var inRig = rigIds.Contains(id);
            if (inRig)
            {
                dump.Rig.Add(new BoneInfo
                {
                    Path = RelPath(t, root),
                    Parent = t.parent && t != root ? RelPath(t.parent, root) : string.Empty,
                    LocalPosition = V3(t.localPosition),
                    LocalRotation = Q(t.localRotation),
                    LocalScale = V3(t.localScale)
                });
            }

            if (exclude && IsUnder(t, exclude))
                continue;
            if (inRig || animatorIds.Contains(id) || t == root || t.parent == root)
            {
                var types = ComponentTypes(t);
                if (types.Length > 0)
                    dump.Components.Add($"{RelPath(t, root)}: {types}");
            }
        }

        foreach (var r in smrs)
            dump.SkinnedMeshes.Add(DumpSmr(r, root));

        foreach (var mf in go.GetComponentsInChildren<MeshFilter>(true))
        {
            if (!mf || !mf.sharedMesh || (exclude && IsUnder(mf.transform, exclude)))
                continue;
            if (!rigIds.Contains(mf.transform.parent ? mf.transform.parent.GetInstanceID() : 0))
                continue;
            dump.AttachedMeshes.Add($"{RelPath(mf.transform, root)} mesh={mf.sharedMesh.name}");
        }

        return dump;
    }

    private static string ComponentTypes(Transform t)
    {
        var names = new List<string>();
        foreach (var c in t.GetComponents<Component>())
        {
            if (!c)
                continue;
            string n;
            try
            {
                n = c.GetIl2CppType().FullName;
            }
            catch
            {
                n = c.GetType().FullName;
            }
            if (n == "UnityEngine.Transform")
                continue;
            names.Add(n);
        }
        return string.Join(", ", names);
    }

    private static SmrInfo DumpSmr(SkinnedMeshRenderer r, Transform root)
    {
        var info = new SmrInfo
        {
            Path = RelPath(r.transform, root),
            Enabled = r.enabled,
            Active = r.gameObject.activeInHierarchy,
            Layer = r.gameObject.layer,
            LayerName = LayerMask.LayerToName(r.gameObject.layer),
            Shadow = r.shadowCastingMode.ToString(),
            RootBone = r.rootBone ? RelPath(r.rootBone, root) : string.Empty
        };

        var mesh = r.sharedMesh;
        var bones = r.bones;
        Matrix4x4[] binds = null;
        if (mesh)
        {
            info.Mesh = mesh.name;
            info.Vertices = mesh.vertexCount;
            info.SubMeshes = mesh.subMeshCount;
            info.Readable = mesh.isReadable;
            try
            {
                binds = mesh.bindposes.ToArray();
            }
            catch
            {
                binds = null;
            }
            for (int i = 0; i < mesh.blendShapeCount; i++)
                info.BlendShapes.Add(mesh.GetBlendShapeName(i));
        }

        if (bones != null)
        {
            for (int i = 0; i < bones.Length; i++)
            {
                var b = bones[i];
                var path = b ? RelPath(b, root) : "null";
                info.Bones.Add(path);
                if (binds != null && i < binds.Length)
                {
                    var rest = binds[i].inverse;
                    info.BindRest.Add(new RestInfo
                    {
                        Bone = path,
                        Position = V3(new Vector3(rest.m03, rest.m13, rest.m23)),
                        Rotation = Q(rest.rotation)
                    });
                }
            }
        }

        foreach (var m in r.sharedMaterials)
        {
            if (!m)
                continue;
            var mi = new MaterialInfo { Name = m.name, Shader = m.shader ? m.shader.name : string.Empty };
            try
            {
                foreach (var prop in m.GetTexturePropertyNames())
                {
                    var tex = m.GetTexture(prop);
                    if (tex)
                        mi.Textures[prop] = tex.name;
                }
            }
            catch
            {
            }
            info.Materials.Add(mi);
        }

        return info;
    }

    private static AnimatorInfo DumpAnimator(Animator a, Transform root)
    {
        var info = new AnimatorInfo
        {
            Path = RelPath(a.transform, root),
            Enabled = a.enabled
        };

        RuntimeAnimatorController controller = null;
        try
        {
            controller = a.runtimeAnimatorController;
            info.Controller = controller ? controller.name : string.Empty;
        }
        catch
        {
        }

        var avatar = a.avatar;
        if (avatar)
        {
            info.Avatar = avatar.name;
            info.IsHuman = avatar.isHuman;
            info.IsValid = avatar.isValid;
            if (avatar.isHuman)
            {
                try
                {
                    foreach (var hb in avatar.humanDescription.human)
                        info.HumanBones[hb.humanName] = hb.boneName;
                }
                catch (Exception e)
                {
                    info.HumanBones["error"] = e.Message;
                }
            }
        }

        var clipNames = new List<string>();
        if (controller)
        {
            try
            {
                var seen = new HashSet<string>();
                foreach (var clip in controller.animationClips)
                {
                    if (!clip || !seen.Add(clip.name))
                        continue;
                    clipNames.Add(clip.name);
                    info.Clips.Add(DescribeClip(clip));
                }
            }
            catch
            {
            }
        }

        try
        {
            info.Initialized = a.isInitialized;
        }
        catch
        {
        }

        if (!info.Initialized)
            return info;

        try
        {
            info.LayerCount = a.layerCount;
            for (int i = 0; i < a.layerCount; i++)
                info.Layers.Add(new LayerInfo { Index = i, Name = a.GetLayerName(i), Weight = R(a.GetLayerWeight(i)) });
        }
        catch
        {
        }

        try
        {
            foreach (var p in a.parameters)
                info.Parameters.Add($"{p.name}:{p.type}:{p.nameHash}");
        }
        catch
        {
        }

        var candidates = clipNames.Concat(EmoteNames).Distinct().ToList();
        for (int layer = 0; layer < info.Layers.Count; layer++)
        {
            foreach (var name in candidates)
            {
                var hash = Animator.StringToHash(name);
                bool has;
                try
                {
                    has = a.HasState(layer, hash);
                }
                catch
                {
                    has = false;
                }
                if (has)
                    info.States.Add(new StateHit { Layer = layer, LayerName = info.Layers[layer].Name, Name = name, ShortHash = hash });
            }

            try
            {
                var st = a.GetCurrentAnimatorStateInfo(layer);
                var clips = new List<string>();
                foreach (var ci in a.GetCurrentAnimatorClipInfo(layer))
                {
                    var c = ci.clip;
                    if (c)
                        clips.Add(c.name);
                }
                info.Current.Add(new CurrentState
                {
                    Layer = layer,
                    ShortHash = st.shortNameHash,
                    FullHash = st.fullPathHash,
                    NormalizedTime = R(st.normalizedTime),
                    Clips = string.Join("|", clips)
                });
            }
            catch
            {
            }
        }

        return info;
    }

    private static ClipInfo DescribeClip(AnimationClip clip)
    {
        var ci = new ClipInfo
        {
            Name = clip.name,
            Length = R(clip.length),
            Loop = clip.isLooping,
            FrameRate = R(clip.frameRate),
            Legacy = clip.legacy,
            HumanMotion = clip.humanMotion
        };
        try
        {
            var events = clip.events;
            if (events != null)
                ci.Events = events.Where(e => e != null).Select(e => $"{R(e.time)}:{e.functionName}").ToList();
        }
        catch
        {
        }
        return ci;
    }

    private static void WriteClips(string outDir)
    {
        var sb = new StringBuilder();
        sb.AppendLine("name\tlength\tloop\tframeRate\tlegacy\thumanMotion\tevents");
        var seen = new HashSet<int>();
        foreach (var clip in Resources.FindObjectsOfTypeAll<AnimationClip>())
        {
            if (!clip || !seen.Add(clip.GetInstanceID()))
                continue;
            var ci = DescribeClip(clip);
            sb.AppendLine($"{ci.Name}\t{ci.Length}\t{ci.Loop}\t{ci.FrameRate}\t{ci.Legacy}\t{ci.HumanMotion}\t{string.Join(" ", ci.Events)}");
        }
        File.WriteAllText(Path.Combine(outDir, "clips.tsv"), sb.ToString());

        var cb = new StringBuilder();
        cb.AppendLine("controller\tclips\tusedBy");
        var users = new Dictionary<string, HashSet<string>>();
        foreach (var a in Resources.FindObjectsOfTypeAll<Animator>())
        {
            if (!a)
                continue;
            try
            {
                var c = a.runtimeAnimatorController;
                if (!c)
                    continue;
                if (!users.TryGetValue(c.name, out var set))
                    users[c.name] = set = new HashSet<string>();
                if (set.Count < 20)
                    set.Add(a.transform.root.name);
            }
            catch
            {
            }
        }
        foreach (var c in Resources.FindObjectsOfTypeAll<RuntimeAnimatorController>())
        {
            if (!c)
                continue;
            int count = 0;
            try
            {
                count = c.animationClips.Length;
            }
            catch
            {
            }
            users.TryGetValue(c.name, out var set);
            cb.AppendLine($"{c.name}\t{count}\t{(set == null ? string.Empty : string.Join(", ", set))}");
        }
        File.WriteAllText(Path.Combine(outDir, "controllers.tsv"), cb.ToString());
    }

    private static void StartWatch(string target)
    {
        StopWatch();
        if (target == "off")
        {
            Say("rigwatch off");
            return;
        }
        if (target.Length == 0)
            target = "player";

        GameObject go = null;
        if (target == "player")
            go = LocalPlayer.GameObject;
        else if (target == "robby")
            go = ActorTools.GetRobby()?.gameObject;
        else if (target == "virginia")
            go = ActorTools.GetActors(VailActorTypeId.Virginia)?.FirstOrDefault(a => a)?.gameObject;

        if (!go)
        {
            Say($"rigwatch: no {target} found");
            return;
        }

        Animator best = null;
        foreach (var a in go.GetComponentsInChildren<Animator>(true))
        {
            if (!a || !a.isInitialized || !a.runtimeAnimatorController)
                continue;
            if (!best || a.layerCount > best.layerCount)
                best = a;
        }
        if (!best)
        {
            Say($"rigwatch: no initialized animator on {target}");
            return;
        }

        _watchAnimator = best;
        _watchTarget = target;
        _watchLast = Enumerable.Repeat(int.MinValue, best.layerCount).ToArray();
        _watchWeights = Enumerable.Repeat(-1f, best.layerCount).ToArray();
        _watchParams = new();
        foreach (var p in best.parameters)
        {
            if (p.type != AnimatorControllerParameterType.Float)
                _watchParams.Add((p.name, p.nameHash, p.type));
        }
        _watchParamLast = Enumerable.Repeat(int.MinValue, _watchParams.Count).ToArray();
        WatchSeen.Clear();
        _watchNames = BuildNames(best);

        var dir = Path.Combine(LoaderEnvironment.UserDataDirectory, "RigProbe", "watch");
        Directory.CreateDirectory(dir);
        var stamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
        _watchLog = new StreamWriter(Path.Combine(dir, $"{target}_{stamp}.log")) { AutoFlush = true };
        _watchStatesPath = Path.Combine(dir, $"{target}_{stamp}_states.tsv");
        _watchLog.WriteLine("time\tkind\tlayer\tlayerName\tweight\tshortHash\tfullHash\tresolved\tclips");
        Say($"rigwatch: watching {target} animator {best.name} ({best.layerCount} layers). rigwatch off to stop.");
    }

    private static void StopWatch()
    {
        if (_watchLog == null)
            return;
        try
        {
            var sb = new StringBuilder();
            sb.AppendLine("layer\tlayerName\tshortHash\tfullHash\tresolved\tclips\tcount");
            foreach (var e in WatchSeen.Values.OrderBy(e => e.Layer).ThenByDescending(e => e.Count))
                sb.AppendLine($"{e.Layer}\t{e.LayerName}\t{e.ShortHash}\t{e.FullHash}\t{e.Resolved}\t{e.Clips}\t{e.Count}");
            File.WriteAllText(_watchStatesPath, sb.ToString());
            _watchLog.Dispose();
            Say($"rigwatch: {WatchSeen.Count} states written to {_watchStatesPath}");
        }
        catch (Exception e)
        {
            RLog.Error($"rigwatch stop failed: {e.Message}");
        }
        _watchLog = null;
        _watchAnimator = null;
    }

    private static void OnUpdate()
    {
        if (_watchLog == null)
            return;
        var a = _watchAnimator;
        if (!a)
        {
            StopWatch();
            return;
        }

        try
        {
            for (int i = 0; i < _watchLast.Length; i++)
            {
                var w = a.GetLayerWeight(i);
                if (Mathf.Abs(w - _watchWeights[i]) >= 0.25f || (w != _watchWeights[i] && (w == 0f || w == 1f)))
                {
                    _watchWeights[i] = w;
                    _watchLog.WriteLine($"{Time.time:F2}\tweight\t{i}\t{a.GetLayerName(i)}\t{R(w)}");
                }

                var st = a.GetCurrentAnimatorStateInfo(i);
                if (st.fullPathHash == _watchLast[i])
                    continue;
                _watchLast[i] = st.fullPathHash;

                var clips = new List<string>();
                foreach (var ci in a.GetCurrentAnimatorClipInfo(i))
                {
                    var c = ci.clip;
                    if (c)
                        clips.Add(c.name);
                }
                var clipText = string.Join("|", clips);
                var layerName = a.GetLayerName(i);
                var resolved = _watchNames.TryGetValue(st.fullPathHash, out var fn) ? fn
                    : _watchNames.TryGetValue(st.shortNameHash, out var sn) ? sn : string.Empty;

                _watchLog.WriteLine($"{Time.time:F2}\tstate\t{i}\t{layerName}\t{R(a.GetLayerWeight(i))}\t{st.shortNameHash}\t{st.fullPathHash}\t{resolved}\t{clipText}");

                var key = $"{i}:{st.fullPathHash}";
                if (!WatchSeen.TryGetValue(key, out var entry))
                {
                    entry = new WatchEntry
                    {
                        Layer = i,
                        LayerName = layerName,
                        ShortHash = st.shortNameHash,
                        FullHash = st.fullPathHash,
                        Resolved = resolved,
                        Clips = clipText
                    };
                    WatchSeen[key] = entry;
                }
                entry.Count++;
            }

            for (int i = 0; i < _watchParams.Count; i++)
            {
                var p = _watchParams[i];
                var v = p.Type == AnimatorControllerParameterType.Int ? a.GetInteger(p.Hash) : a.GetBool(p.Hash) ? 1 : 0;
                if (v == _watchParamLast[i])
                    continue;
                var first = _watchParamLast[i] == int.MinValue;
                _watchParamLast[i] = v;
                if (!first)
                    _watchLog.WriteLine($"{Time.time:F2}\tparam\t{p.Name}\t{p.Type}\t{v}");
            }
        }
        catch (Exception e)
        {
            RLog.Error($"rigwatch update failed: {e.Message}");
            StopWatch();
        }
    }

    private static void AddPlayerData(CharacterDump dump, GameObject player)
    {
        var race = player.GetComponentInChildren<PlayerRaceSystem>(true);
        if (race)
        {
            try
            {
                dump.CurrentRace = race.CurrentRace.ToString();
                dump.ExpressionBlendsStartIndex = race.GetExpressionBlendsStartIndex();
            }
            catch
            {
            }

            var races = race._races;
            if (races != null)
            {
                for (int i = 0; i < races.Count; i++)
                {
                    var r = races[i];
                    if (!r)
                        continue;
                    dump.Races.Add(new RaceInfo
                    {
                        Index = i,
                        Race = r.GetRace.ToString(),
                        Asset = r.name,
                        HeadAssetGuid = r.HeadAsset?.AssetGUID ?? string.Empty,
                        ArmsAssetGuid = r.ArmsAsset?.AssetGUID ?? string.Empty
                    });
                }
            }
        }

        var clothing = player.GetComponentInChildren<PlayerClothingSystem>(true);
        if (!clothing)
            return;

        var defaults = new HashSet<int>();
        if (clothing._defaultClothing != null)
        {
            foreach (var c in clothing._defaultClothing)
                if (c)
                    defaults.Add(c.ItemId);
        }

        var worn = new HashSet<int>();
        try
        {
            foreach (var id in clothing.GetCurrentClothingIds())
                worn.Add(id);
        }
        catch
        {
        }

        if (clothing._allClothing == null)
            return;
        foreach (var c in clothing._allClothing)
        {
            if (!c)
                continue;
            dump.Clothing.Add(new ClothingInfo
            {
                Asset = c.name,
                ItemId = c.ItemId,
                Slot = c.Slot.ToString(),
                RenderableGuid = c.Renderable?.AssetGUID ?? string.Empty,
                Default = defaults.Contains(c.ItemId),
                Worn = worn.Contains(c.ItemId)
            });
        }
    }

    private static void WriteIndex(string outDir, List<CharacterDump> dumps)
    {
        var sb = new StringBuilder();
        sb.AppendLine($"RigProbe {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
        sb.AppendLine("source\tname\tactorType\tactive\tskinnedMeshes\tuniqueBones\thumanoid\trigFamily\tplayerNameMatch\tpath");
        foreach (var d in dumps)
        {
            var unique = d.SkinnedMeshes.SelectMany(s => s.Bones).Where(b => b != "null").Distinct().Count();
            var human = d.Animators.Any(a => a.IsHuman);
            sb.AppendLine($"{d.Source}\t{d.Name}\t{d.ActorType}\t{d.Active}\t{d.SkinnedMeshes.Count}\t{unique}\t{human}\t{d.RigFamily}\t{d.PlayerNameMatch}\t{d.Path}");
        }
        File.WriteAllText(Path.Combine(outDir, "index.tsv"), sb.ToString());
    }

    private static void WriteFamilies(string outDir, List<CharacterDump> dumps)
    {
        var sb = new StringBuilder();
        foreach (var g in dumps.Where(d => d.RigFamily.Length > 0).GroupBy(d => d.RigFamily).OrderByDescending(g => g.Count()))
        {
            var bones = g.First().SkinnedMeshes.SelectMany(s => s.Bones).Where(b => b != "null").Select(LeafName).Distinct().OrderBy(b => b).ToList();
            sb.AppendLine($"family {g.Key} bones={bones.Count} playerNameMatch={g.First().PlayerNameMatch}");
            sb.AppendLine($"  members: {string.Join(", ", g.Select(d => $"{d.Source}:{d.Name}"))}");
            sb.AppendLine($"  sample: {string.Join(" ", bones.Take(25))}");
            sb.AppendLine();
        }
        File.WriteAllText(Path.Combine(outDir, "rigfamilies.txt"), sb.ToString());
    }

    private static string Family(CharacterDump d)
    {
        var names = d.SkinnedMeshes.SelectMany(s => s.Bones).Where(b => b != "null").Select(LeafName).Distinct().OrderBy(b => b).ToList();
        if (names.Count == 0)
            return string.Empty;
        using var sha = SHA1.Create();
        var hash = sha.ComputeHash(Encoding.UTF8.GetBytes(string.Join("|", names)));
        return Convert.ToHexString(hash, 0, 4).ToLowerInvariant();
    }

    private static string PlayerMatch(CharacterDump d)
    {
        var names = d.SkinnedMeshes.SelectMany(s => s.Bones).Where(b => b != "null").Select(LeafName).Distinct().ToList();
        if (names.Count == 0)
            return "n/a";
        var hit = names.Count(n => _playerBoneNames.Contains(n));
        return $"{hit}/{names.Count} ({hit * 100 / names.Count}%)";
    }

    private static Transform CharacterRoot(SkinnedMeshRenderer smr)
    {
        var t = smr.transform.parent;
        while (t)
        {
            if (t.GetComponent<Animator>() || t.name.IndexOf("Poser", StringComparison.OrdinalIgnoreCase) >= 0)
                return t;
            t = t.parent;
        }

        var bone = smr.rootBone;
        if (!bone && smr.bones != null && smr.bones.Length > 0)
            bone = smr.bones[0];
        var lca = CommonAncestor(smr.transform, bone);
        return lca ? lca : smr.transform.parent ? smr.transform.parent : smr.transform;
    }

    private static Transform CommonAncestor(Transform a, Transform b)
    {
        if (!a || !b)
            return null;
        var chain = new HashSet<int>();
        var t = a;
        while (t)
        {
            chain.Add(t.GetInstanceID());
            t = t.parent;
        }
        t = b;
        while (t)
        {
            if (chain.Contains(t.GetInstanceID()))
                return t;
            t = t.parent;
        }
        return null;
    }

    private static void AddWithAncestors(Transform t, Transform root, HashSet<int> ids)
    {
        while (t)
        {
            if (!ids.Add(t.GetInstanceID()))
                return;
            if (t == root)
                return;
            t = t.parent;
        }
    }

    private static bool IsUnder(Transform t, Transform ancestor)
    {
        while (t)
        {
            if (t == ancestor)
                return true;
            t = t.parent;
        }
        return false;
    }

    private static Transform FindChild(Transform root, string name)
    {
        foreach (var t in root.GetComponentsInChildren<Transform>(true))
            if (t.name == name)
                return t;
        return null;
    }

    private static string LeafName(string path)
    {
        var i = path.LastIndexOf('/');
        return i < 0 ? path : path.Substring(i + 1);
    }

    private static string Sanitize(string s)
    {
        var invalid = Path.GetInvalidFileNameChars();
        var sb = new StringBuilder();
        foreach (var ch in s)
            sb.Append(invalid.Contains(ch) || ch == ':' || ch == ' ' ? '_' : ch);
        return sb.ToString();
    }

    private static float[] V3(Vector3 v)
    {
        return new[] { R(v.x), R(v.y), R(v.z) };
    }

    private static float[] Q(Quaternion q)
    {
        return new[] { R(q.x), R(q.y), R(q.z), R(q.w) };
    }

    private static float R(float f)
    {
        return (float)Math.Round(f, 5);
    }

    private static string HierPath(Transform t)
    {
        var parts = new List<string>();
        while (t)
        {
            parts.Add(t.name);
            t = t.parent;
        }
        parts.Reverse();
        return string.Join("/", parts);
    }

    private static string RelPath(Transform t, Transform root)
    {
        if (t == root)
            return t.name;
        var parts = new List<string>();
        while (t && t != root)
        {
            parts.Add(t.name);
            t = t.parent;
        }
        parts.Reverse();
        return string.Join("/", parts);
    }

    private static void HookNet()
    {
        if (_netHooked)
        {
            Say("rignet: already hooked");
            return;
        }

        var dir = Path.Combine(LoaderEnvironment.UserDataDirectory, "RigProbe", "net");
        Directory.CreateDirectory(dir);
        var path = Path.Combine(dir, $"net_{DateTime.Now:yyyyMMdd_HHmmss}.log");
        _netLog = new StreamWriter(path) { AutoFlush = true };
        var pa = PlayerAnimator();
        if (pa)
            _netNames = BuildNames(pa);

        var types = GameTypes();
        foreach (var t in types.Where(t => t.Name.IndexOf("mecanim", StringComparison.OrdinalIgnoreCase) >= 0))
            NetLine($"type\t{t.Assembly.GetName().Name}\t{t.FullName}\t{t.BaseType?.FullName}");

        _netEventType = types.FirstOrDefault(t => t.Name == "updateMecanimRemoteState");
        if (_netEventType == null)
        {
            Say($"rignet: updateMecanimRemoteState not found, see {path}");
            return;
        }

        _harmony ??= new HarmonyLib.Harmony("RigProbe.Net");
        var patched = 0;

        foreach (var p in _netEventType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
        {
            NetLine($"prop\t{p.Name}\t{p.PropertyType.FullName}");
            var set = p.GetSetMethod();
            if (set != null && NetPatch(set, null, nameof(NetOnSet)))
                patched++;
        }

        foreach (var m in _netEventType.GetMethods(AllDeclared))
        {
            if (m.IsSpecialName)
                continue;
            NetLine($"method\t{DescribeMethod(m)}");
            if ((m.Name == "Create" || m.Name == "Send") && NetPatch(m, null, nameof(NetOnCreateOrSend)))
                patched++;
        }

        var named = 0;
        foreach (var t in types)
        {
            if (t == _netEventType || t.IsInterface)
                continue;
            MethodInfo[] ms;
            try
            {
                ms = t.GetMethods(AllDeclared);
            }
            catch
            {
                continue;
            }

            foreach (var m in ms)
            {
                bool takesEvent;
                try
                {
                    takesEvent = m.GetParameters().Any(p => p.ParameterType == _netEventType);
                }
                catch
                {
                    continue;
                }

                var isNamed = !m.IsSpecialName && (m.Name.IndexOf("RemoteState", StringComparison.OrdinalIgnoreCase) >= 0
                                                   || m.Name.IndexOf("Mecanim", StringComparison.OrdinalIgnoreCase) >= 0);
                if (!takesEvent && !isNamed)
                    continue;

                NetLine($"{(takesEvent ? "receiver" : "named")}\t{t.FullName}\t{DescribeMethod(m)}");
                if (!takesEvent && ++named > 60)
                    continue;
                if (NetPatch(m, nameof(NetOnCall), null))
                    patched++;
            }
        }

        _netHooked = true;
        Say($"rignet: {patched} hooks installed, log {path}");
    }

    private static bool NetPatch(MethodInfo m, string prefix, string postfix)
    {
        if (m.IsAbstract || m.ContainsGenericParameters)
            return false;
        try
        {
            _harmony.Patch(m,
                prefix: prefix == null ? null : new HarmonyMethod(typeof(RigProbe).GetMethod(prefix, BindingFlags.NonPublic | BindingFlags.Static)),
                postfix: postfix == null ? null : new HarmonyMethod(typeof(RigProbe).GetMethod(postfix, BindingFlags.NonPublic | BindingFlags.Static)));
            return true;
        }
        catch (Exception e)
        {
            NetLine($"patchfail\t{m.DeclaringType?.FullName}.{m.Name}\t{e.Message}");
            return false;
        }
    }

    private static void NetOnSet(MethodBase __originalMethod, object[] __args)
    {
        var v = __args != null && __args.Length > 0 ? __args[0] : null;
        var extra = v is int h && _netNames.TryGetValue(h, out var n) ? $"\t{n}" : string.Empty;
        NetLine($"set\t{__originalMethod.Name.Substring(4)}\t{Fmt(v)}{extra}");
    }

    private static void NetOnCreateOrSend(MethodBase __originalMethod, object[] __args)
    {
        NetLine($"{__originalMethod.Name}\t{string.Join(", ", (__args ?? Array.Empty<object>()).Select(Fmt))}");
        NetLine($"stack\t{Il2CppStack()}");
    }

    private static void NetOnCall(MethodBase __originalMethod, object[] __args)
    {
        var key = $"{__originalMethod.DeclaringType?.FullName}.{__originalMethod.Name}";
        NetCallCounts.TryGetValue(key, out var n);
        n++;
        NetCallCounts[key] = n;
        if (n > 20 && n % 200 != 0)
            return;
        var parts = (__args ?? Array.Empty<object>()).Select(x => x != null && _netEventType != null && _netEventType.IsInstanceOfType(x) ? DumpNetEvent(x) : Fmt(x));
        NetLine($"call#{n}\t{key}\t{string.Join(", ", parts)}");
    }

    private static string DumpNetEvent(object e)
    {
        var sb = new StringBuilder("{");
        for (var t = e.GetType(); t != null && t != typeof(object) && t.FullName != "Il2CppSystem.Object" && t.Namespace?.StartsWith("Il2CppInterop") != true; t = t.BaseType)
        {
            foreach (var p in t.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
            {
                if (p.GetIndexParameters().Length > 0 || p.GetGetMethod() == null)
                    continue;
                object v;
                try
                {
                    v = p.GetValue(e);
                }
                catch
                {
                    v = "?";
                }
                var extra = v is int h && _netNames.TryGetValue(h, out var n) ? $"({n})" : string.Empty;
                sb.Append($"{p.Name}={Fmt(v)}{extra} ");
            }
        }
        return sb.Append('}').ToString();
    }

    private static string Il2CppStack()
    {
        try
        {
            _il2cppStackType ??= AppDomain.CurrentDomain.GetAssemblies().Select(x => x.GetType("Il2CppSystem.Diagnostics.StackTrace")).FirstOrDefault(x => x != null);
            if (_il2cppStackType == null)
                return "unavailable";
            var s = Activator.CreateInstance(_il2cppStackType)?.ToString() ?? string.Empty;
            return string.Join(" | ", s.Split('\n').Select(x => x.Trim()).Where(x => x.Length > 0).Take(15));
        }
        catch (Exception e)
        {
            return "unavailable: " + e.Message;
        }
    }

    private static List<Type> GameTypes()
    {
        var list = new List<Type>();
        foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
        {
            string loc;
            try
            {
                loc = asm.Location;
            }
            catch
            {
                continue;
            }
            if (string.IsNullOrEmpty(loc) || loc.Replace('/', '\\').IndexOf(@"_RedLoader\Game", StringComparison.OrdinalIgnoreCase) < 0)
                continue;
            var name = asm.GetName().Name ?? string.Empty;
            if (name.StartsWith("Il2Cppmscorlib") || name.StartsWith("Il2CppSystem") || name.StartsWith("UnityEngine") || name.StartsWith("Unity."))
                continue;

            Type[] ts;
            try
            {
                ts = asm.GetTypes();
            }
            catch (ReflectionTypeLoadException e)
            {
                ts = e.Types.Where(x => x != null).ToArray();
            }
            catch
            {
                continue;
            }
            list.AddRange(ts);
        }
        return list;
    }

    private static void NetLine(string line)
    {
        var t = Time.time.ToString("F2", CultureInfo.InvariantCulture);
        try
        {
            _netLog?.WriteLine($"{t}\t{line}");
            _watchLog?.WriteLine($"{t}\tnet\t{line}");
        }
        catch
        {
        }
    }

    private static Dictionary<int, string> BuildNames(Animator a)
    {
        var map = new Dictionary<int, string>();
        var layers = Enumerable.Range(0, a.layerCount).Select(a.GetLayerName).ToList();
        var names = new List<string>(EmoteNames);
        foreach (var clip in a.runtimeAnimatorController.animationClips)
        {
            if (clip)
                names.Add(clip.name);
        }
        foreach (var n in names)
        {
            map[Animator.StringToHash(n)] = n;
            foreach (var ln in layers)
                map[Animator.StringToHash($"{ln}.{n}")] = $"{ln}.{n}";
        }
        return map;
    }

    private static Animator PlayerAnimator()
    {
        var go = LocalPlayer.GameObject;
        if (!go)
            return null;

        var t = go.transform.Find("PlayerAnimator");
        if (t)
        {
            var pa = t.GetComponent<Animator>();
            if (pa && pa.isInitialized)
                return pa;
        }

        Animator best = null;
        foreach (var a in go.GetComponentsInChildren<Animator>(true))
        {
            if (!a || !a.isInitialized || !a.runtimeAnimatorController)
                continue;
            if (!best || a.layerCount > best.layerCount)
                best = a;
        }
        return best;
    }

    private static int ResolveLayer(Animator a, string s)
    {
        if (int.TryParse(s, out var i))
            return i >= 0 && i < a.layerCount ? i : -1;
        for (int l = 0; l < a.layerCount; l++)
        {
            if (string.Equals(a.GetLayerName(l), s, StringComparison.OrdinalIgnoreCase))
                return l;
        }
        return -1;
    }

    private static bool SafeHasState(Animator a, int layer, int hash)
    {
        try
        {
            return a.HasState(layer, hash);
        }
        catch
        {
            return false;
        }
    }

    private static string ParamValue(Animator a, int hash, AnimatorControllerParameterType type)
    {
        return type switch
        {
            AnimatorControllerParameterType.Float => a.GetFloat(hash).ToString("F3", CultureInfo.InvariantCulture),
            AnimatorControllerParameterType.Int => a.GetInteger(hash).ToString(CultureInfo.InvariantCulture),
            _ => a.GetBool(hash) ? "1" : "0"
        };
    }

    private static string DescribeMethod(MethodInfo m)
    {
        var ps = string.Join(", ", m.GetParameters().Select(p => $"{p.ParameterType.Name} {p.Name}"));
        return $"{(m.IsStatic ? "static " : string.Empty)}{m.ReturnType.Name} {m.Name}({ps})";
    }

    private static string Fmt(object o)
    {
        return o switch
        {
            null => "null",
            float f => f.ToString("F3", CultureInfo.InvariantCulture),
            UnityEngine.Object u => u ? $"{u.GetType().Name}:{u.name}" : "destroyed",
            _ => o.ToString()
        };
    }

    private static string[] SplitArgs(string args)
    {
        return (args ?? string.Empty).Trim().Split(' ', StringSplitOptions.RemoveEmptyEntries);
    }

    private static void Say(string text)
    {
        SonsTools.ShowMessage(text, 6f);
        RLog.Msg(text);
    }
}

public class CharacterDump
{
    public string Name { get; set; }
    public string Source { get; set; }
    public string ActorType { get; set; } = string.Empty;
    public string Path { get; set; }
    public bool Active { get; set; }
    public string RigFamily { get; set; } = string.Empty;
    public string PlayerNameMatch { get; set; } = string.Empty;
    public string CurrentRace { get; set; }
    public int? ExpressionBlendsStartIndex { get; set; }
    public List<RaceInfo> Races { get; set; } = new();
    public List<ClothingInfo> Clothing { get; set; } = new();
    public List<AnimatorInfo> Animators { get; set; } = new();
    public List<string> Components { get; set; } = new();
    public List<BoneInfo> Rig { get; set; } = new();
    public List<SmrInfo> SkinnedMeshes { get; set; } = new();
    public List<string> AttachedMeshes { get; set; } = new();
}

public class BoneInfo
{
    public string Path { get; set; }
    public string Parent { get; set; }
    public float[] LocalPosition { get; set; }
    public float[] LocalRotation { get; set; }
    public float[] LocalScale { get; set; }
}

public class SmrInfo
{
    public string Path { get; set; }
    public string Mesh { get; set; }
    public bool Enabled { get; set; }
    public bool Active { get; set; }
    public int Layer { get; set; }
    public string LayerName { get; set; }
    public string Shadow { get; set; }
    public bool Readable { get; set; }
    public int Vertices { get; set; }
    public int SubMeshes { get; set; }
    public string RootBone { get; set; }
    public List<string> Bones { get; set; } = new();
    public List<RestInfo> BindRest { get; set; } = new();
    public List<string> BlendShapes { get; set; } = new();
    public List<MaterialInfo> Materials { get; set; } = new();
}

public class RestInfo
{
    public string Bone { get; set; }
    public float[] Position { get; set; }
    public float[] Rotation { get; set; }
}

public class MaterialInfo
{
    public string Name { get; set; }
    public string Shader { get; set; }
    public Dictionary<string, string> Textures { get; set; } = new();
}

public class AnimatorInfo
{
    public string Path { get; set; }
    public bool Enabled { get; set; }
    public bool Initialized { get; set; }
    public string Controller { get; set; } = string.Empty;
    public string Avatar { get; set; } = string.Empty;
    public bool IsHuman { get; set; }
    public bool IsValid { get; set; }
    public int LayerCount { get; set; }
    public List<LayerInfo> Layers { get; set; } = new();
    public Dictionary<string, string> HumanBones { get; set; } = new();
    public List<string> Parameters { get; set; } = new();
    public List<ClipInfo> Clips { get; set; } = new();
    public List<StateHit> States { get; set; } = new();
    public List<CurrentState> Current { get; set; } = new();
}

public class LayerInfo
{
    public int Index { get; set; }
    public string Name { get; set; }
    public float Weight { get; set; }
}

public class ClipInfo
{
    public string Name { get; set; }
    public float Length { get; set; }
    public bool Loop { get; set; }
    public float FrameRate { get; set; }
    public bool Legacy { get; set; }
    public bool HumanMotion { get; set; }
    public List<string> Events { get; set; } = new();
}

public class StateHit
{
    public int Layer { get; set; }
    public string LayerName { get; set; }
    public string Name { get; set; }
    public int ShortHash { get; set; }
}

public class CurrentState
{
    public int Layer { get; set; }
    public int ShortHash { get; set; }
    public int FullHash { get; set; }
    public float NormalizedTime { get; set; }
    public string Clips { get; set; }
}

public class WatchEntry
{
    public int Layer { get; set; }
    public string LayerName { get; set; }
    public int ShortHash { get; set; }
    public int FullHash { get; set; }
    public string Resolved { get; set; }
    public string Clips { get; set; }
    public int Count { get; set; }
}

public class RaceInfo
{
    public int Index { get; set; }
    public string Race { get; set; }
    public string Asset { get; set; }
    public string HeadAssetGuid { get; set; }
    public string ArmsAssetGuid { get; set; }
}

public class ClothingInfo
{
    public string Asset { get; set; }
    public int ItemId { get; set; }
    public string Slot { get; set; }
    public string RenderableGuid { get; set; }
    public bool Default { get; set; }
    public bool Worn { get; set; }
}