#if UNITY_EDITOR
using System;
using System.IO;
using System.Linq;
using System.Collections.Generic;
using Newtonsoft.Json;
using AIGame.EditorTools;
using AIGame.Review;
using TMPro;
using UnityEditor;
using UnityEditor.Animations;
using UnityEditor.SceneManagement;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.EventSystems;
using UnityEngine.Rendering;
using UnityEngine.UI;

public static class BuildBotAnimationLab
{
    public const string Common = "Assets/Bundles/Characters/Human/Common";
    public const string Root = "Assets/Review/BotAnimationLab";
    public const string ScenePath = Root + "/BotAnimationLab.unity";
    static readonly string[] Names = { "XBot", "YBot", "XBot25", "XBot41" };
    static string Repo => Directory.GetParent(Application.dataPath).Parent.FullName;
    static string Output => Path.Combine(Repo, "Tools/output/bot_animation_lab");
    static void Folder(string path)
    {
        if (AssetDatabase.IsValidFolder(path)) return;
        Folder(Path.GetDirectoryName(path).Replace('\\', '/'));
        AssetDatabase.CreateFolder(Path.GetDirectoryName(path).Replace('\\', '/'), Path.GetFileName(path));
    }
    static void Report(string name, object report)
    {
        Directory.CreateDirectory(Output);
        File.WriteAllText(Path.Combine(Output, name + ".json"), JsonConvert.SerializeObject(report, Formatting.Indented));
    }
    public static string Configure()
    {
        if (EditorApplication.isPlayingOrWillChangePlaymode) throw new Exception("Edit Mode required");
        Folder(Root); Folder(Common + "/Prefabs");
        var reports = new List<object>();
        float referenceHeight = 0;
        foreach (string name in Names)
        {
            string path = Common + "/" + name + ".fbx";
            AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceSynchronousImport);
            var importer = (ModelImporter)AssetImporter.GetAtPath(path);
            if (importer.animationType != ModelImporterAnimationType.Human || importer.avatarSetup != ModelImporterAvatarSetup.CreateFromThisModel)
            {
                importer.animationType = ModelImporterAnimationType.Human;
                importer.avatarSetup = ModelImporterAvatarSetup.CreateFromThisModel;
                importer.SaveAndReimport();
            }
            var avatar = AssetDatabase.LoadAllAssetsAtPath(path).OfType<Avatar>().Single();
            if (!avatar.isValid || !avatar.isHuman) throw new Exception(name + " invalid Humanoid Avatar");
            var model = AssetDatabase.LoadAssetAtPath<GameObject>(path);
            var bones = model.GetComponentsInChildren<Transform>(true).Where(t => t.name.StartsWith("mixamorig:")).Select(t => t.name).ToArray();
            var mapped = importer.humanDescription.human;
            string controllerPath = Common + "/" + (name == "YBot" ? "YBot" : "XBot") + ".controller";
            var controller = AssetDatabase.LoadAssetAtPath<AnimatorController>(controllerPath);
            if (!controller) throw new Exception("Missing controller " + controllerPath);
            var preview = EditorSceneManager.NewPreviewScene();
            try
            {
                var go = (GameObject)PrefabUtility.InstantiatePrefab(model, preview);
                go.name = name;
                float sourceHeight = BoundsOf(go).size.y;
                if (name == "XBot") referenceHeight = sourceHeight;
                if (name == "XBot25" || name == "XBot41") go.transform.localScale *= referenceHeight / sourceHeight;
                var animator = go.GetComponent<Animator>();
                if (!animator) animator = go.AddComponent<Animator>();
                animator.avatar = avatar; animator.runtimeAnimatorController = controller;
                animator.applyRootMotion = false; animator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
                foreach (var skin in go.GetComponentsInChildren<SkinnedMeshRenderer>()) skin.updateWhenOffscreen = true;
                string prefab = Common + "/Prefabs/" + name + ".prefab";
                PrefabUtility.SaveAsPrefabAsset(go, prefab);
                reports.Add(new { name, path, bones = bones.Length, boneNames = bones, mapped = mapped.Select(b => new { b.humanName, b.boneName }),
                    avatar = avatar.name, avatarValid = avatar.isValid, avatarHuman = avatar.isHuman, controller = controllerPath, prefab,
                    sourceHeight, prefabHeight = BoundsOf(go).size.y, prefabScale = new[] { go.transform.localScale.x, go.transform.localScale.y, go.transform.localScale.z },
                    renderers = go.GetComponentsInChildren<SkinnedMeshRenderer>().Select(r => new { r.name, skinBones = r.bones.Length, material = r.sharedMaterial ? r.sharedMaterial.name : null }).ToArray() });
            }
            finally { EditorSceneManager.ClosePreviewScene(preview); }
        }
        Report("avatar_configuration", reports);
        return JsonConvert.SerializeObject(reports);
    }
    static Material Material(string name, Color color)
    {
        Folder(Root + "/Generated");
        string path = Root + "/Generated/" + name + ".mat";
        var material = AssetDatabase.LoadAssetAtPath<Material>(path);
        if (!material)
        {
            var shader = Shader.Find("Universal Render Pipeline/Lit") ?? Shader.Find("Standard");
            material = new Material(shader) { name = name };
            AssetDatabase.CreateAsset(material, path);
        }
        material.color = color;
        if (material.HasProperty("_Smoothness")) material.SetFloat("_Smoothness", .35f);
        EditorUtility.SetDirty(material); AssetDatabase.SaveAssetIfDirty(material);
        return material;
    }
    static Bounds BoundsOf(GameObject go)
    {
        var renderers = go.GetComponentsInChildren<Renderer>();
        var bounds = renderers[0].bounds;
        foreach (var r in renderers.Skip(1)) bounds.Encapsulate(r.bounds);
        return bounds;
    }
    public static string Build()
    {
        if (EditorApplication.isPlayingOrWillChangePlaymode) throw new Exception("Edit Mode required");
        for (int i = 0; i < SceneManager.sceneCount; i++)
            if (SceneManager.GetSceneAt(i).isDirty) throw new Exception("Unsaved scene: " + SceneManager.GetSceneAt(i).path);
        Configure();
        string uiPath = JsonUIPrefabBuilder.BuildFromJsonFile(Path.Combine(Repo, "Doc/UIPrefabCreater/UI_BotAnimationLab.json"));
        if (string.IsNullOrEmpty(uiPath)) throw new Exception("UI JSON generation failed");
        var scene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
        var root = new GameObject("BotAnimationLab");
        var viewer = root.AddComponent<BotAnimationLab>();
        viewer.actors = new BotAnimationLab.Actor[4];
        viewer.clayMaterial = Material("Clay", new Color(.65f, .69f, .74f));
        Color[] colors = { new Color(.20f,.60f,.90f), new Color(.96f,.55f,.18f), new Color(.28f,.72f,.43f), new Color(.66f,.42f,.85f) };
        for (int i = 0; i < Names.Length; i++)
        {
            string name = Names[i];
            var stage = new GameObject("Stage_" + name); stage.transform.SetParent(root.transform, false);
            stage.transform.localPosition = new Vector3((1.5f - i) * 20f, 0, 0);
            var go = (GameObject)PrefabUtility.InstantiatePrefab(AssetDatabase.LoadAssetAtPath<GameObject>(Common + "/Prefabs/" + name + ".prefab"), stage.transform);
            var bounds = BoundsOf(go);
            go.transform.localScale *= 1.6f / bounds.size.y;
            bounds = BoundsOf(go);
            go.transform.position -= new Vector3(bounds.center.x - stage.transform.position.x, bounds.min.y, bounds.center.z);
            var a = go.GetComponent<Animator>();
            var skins = go.GetComponentsInChildren<SkinnedMeshRenderer>();
            var color = Material(name + "Color", colors[i]);
            var joints = Material(name + "Joints", colors[i] * .6f);
            foreach (var skin in skins) skin.sharedMaterial = skin.name.Contains("Joint") ? joints : color;
            var controller = (AnimatorController)a.runtimeAnimatorController;
            var states = controller.layers[0].stateMachine.states.Select(s => s.state).ToArray();
            viewer.actors[i] = new BotAnimationLab.Actor { label = name, animator = a, stage = stage.transform, skins = skins,
                originalMaterials = skins.Select(s => s.sharedMaterial).ToArray(),
                clips = BotAnimationLab.StateNames.Select(n => (AnimationClip)states.Single(s => s.name == n).motion).ToArray() };
            var pedestal = GameObject.CreatePrimitive(PrimitiveType.Cylinder); pedestal.name = "Pedestal_" + name;
            pedestal.transform.SetParent(root.transform, false); pedestal.transform.position = stage.transform.position + new Vector3(0,-.035f,0);
            pedestal.transform.localScale = new Vector3(1.25f,.035f,1.25f); pedestal.GetComponent<Renderer>().sharedMaterial = color;
            UnityEngine.Object.DestroyImmediate(pedestal.GetComponent<Collider>());
        }
        var floor = GameObject.CreatePrimitive(PrimitiveType.Plane); floor.name = "ReviewFloor"; floor.transform.SetParent(root.transform, false);
        floor.transform.position = new Vector3(0,-.08f,0); floor.transform.localScale = new Vector3(10,1,1);
        floor.GetComponent<Renderer>().sharedMaterial = Material("Floor", new Color(.79f,.84f,.87f));
        UnityEngine.Object.DestroyImmediate(floor.GetComponent<Collider>());
        var background = new GameObject("BackgroundCamera").AddComponent<Camera>(); background.transform.SetParent(root.transform, false);
        background.clearFlags = CameraClearFlags.SolidColor; background.backgroundColor = new Color(.82f,.89f,.94f); background.depth = -10; background.cullingMask = 0;
        var camera = new GameObject("ReviewCamera").AddComponent<Camera>(); camera.transform.SetParent(root.transform, false);
        camera.tag = "MainCamera"; camera.rect = new Rect(0,.335f,1,.54f); camera.orthographic = true;
        camera.clearFlags = CameraClearFlags.SolidColor; camera.backgroundColor = background.backgroundColor;
        camera.nearClipPlane = .05f; camera.farClipPlane = 40; camera.allowHDR = false; camera.gameObject.AddComponent<AudioListener>();
        viewer.reviewCamera = camera;
        viewer.comparisonCameras = new Camera[4];
        for (int i = 0; i < 4; i++)
        {
            var cell = new GameObject("CompareCamera_" + Names[i]).AddComponent<Camera>(); cell.transform.SetParent(root.transform, false);
            cell.rect = new Rect((i % 2) * .5f, i < 2 ? .605f : .335f, .5f, .27f);
            cell.orthographic = true; cell.clearFlags = CameraClearFlags.SolidColor; cell.backgroundColor = background.backgroundColor;
            cell.nearClipPlane = .05f; cell.farClipPlane = 40; cell.allowHDR = false;
            viewer.comparisonCameras[i] = cell;
        }
        foreach (var config in new[] { ("KeyLight", new Vector3(35, -40, 0), 1.3f), ("FillLight", new Vector3(30, 140, 0), .6f) })
        {
            var light = new GameObject(config.Item1).AddComponent<Light>(); light.transform.SetParent(root.transform, false);
            light.type = LightType.Directional; light.transform.rotation = Quaternion.Euler(config.Item2); light.intensity = config.Item3;
        }
        RenderSettings.ambientMode = AmbientMode.Flat; RenderSettings.ambientLight = new Color(.65f,.68f,.73f); RenderSettings.fog = false;
        var ui = (GameObject)PrefabUtility.InstantiatePrefab(AssetDatabase.LoadAssetAtPath<GameObject>(uiPath), root.transform);
        viewer.ui = ui.transform; ui.GetComponentInChildren<BotAnimationSeekBar>(true).viewer = viewer;
        var events = new GameObject("EventSystem", typeof(EventSystem), typeof(StandaloneInputModule)); events.transform.SetParent(root.transform, false);
        viewer.RefreshView();
        EditorSceneManager.MarkSceneDirty(scene); EditorSceneManager.SaveScene(scene, ScenePath);
        EditorGUIUtility.PingObject(AssetDatabase.LoadAssetAtPath<SceneAsset>(ScenePath));
        return Verify();
    }
    static void Advance(Animator a, float seconds)
    {
        a.speed = 1;
        for (int i = 0; i < Mathf.CeilToInt(seconds * 60); i++) a.Update(1f / 60);
        a.speed = 0;
    }
    static void Expect(Animator a, string name)
    {
        if (!a.GetCurrentAnimatorStateInfo(0).IsName("Base Layer." + name) || a.IsInTransition(0)) throw new Exception("Expected " + name);
    }
    public static string Verify()
    {
        var reports = new List<object>();
        foreach (string name in Names)
        {
            var scene = EditorSceneManager.NewPreviewScene();
            var mesh = new Mesh();
            try
            {
                var go = (GameObject)PrefabUtility.InstantiatePrefab(AssetDatabase.LoadAssetAtPath<GameObject>(Common + "/Prefabs/" + name + ".prefab"), scene);
                var a = go.GetComponent<Animator>();
                if (!a.avatar || !a.avatar.isHuman || !a.avatar.isValid) throw new Exception(name + " invalid Avatar");
                var controller = (AnimatorController)a.runtimeAnimatorController;
                string expected = Common + "/" + (name == "YBot" ? "YBot" : "XBot") + ".controller";
                if (AssetDatabase.GetAssetPath(controller) != expected) throw new Exception(name + " wrong controller");
                a.Rebind(); a.speed = 0; a.Update(0);
                var states = new List<object>();
                foreach (var child in controller.layers[0].stateMachine.states)
                {
                    var state = child.state;
                    float minGap = float.MaxValue, maxGap = float.MinValue, motion = 0;
                    Vector3 first = Vector3.zero;
                    for (int i = 0; i < 25; i++)
                    {
                        a.Play("Base Layer." + state.name, 0, i / 25f); a.Update(0);
                        Vector3 hip = a.GetBoneTransform(HumanBodyBones.Hips).position;
                        Vector3 hand = a.GetBoneTransform(HumanBodyBones.LeftHand).position - hip;
                        Vector3 foot = a.GetBoneTransform(HumanBodyBones.LeftFoot).position - hip;
                        if (i == 0) first = hand + foot;
                        motion = Mathf.Max(motion, Vector3.Distance(first, hand + foot));
                        float gap = go.transform.InverseTransformPoint(a.GetBoneTransform(HumanBodyBones.RightFoot).position).x - go.transform.InverseTransformPoint(a.GetBoneTransform(HumanBodyBones.LeftFoot).position).x;
                        minGap = Mathf.Min(minGap, gap); maxGap = Mathf.Max(maxGap, gap);
                        foreach (var skin in go.GetComponentsInChildren<SkinnedMeshRenderer>())
                        {
                            skin.BakeMesh(mesh);
                            if (mesh.vertices.Any(v => float.IsNaN(v.sqrMagnitude) || float.IsInfinity(v.sqrMagnitude))) throw new Exception(name + " invalid skin");
                        }
                    }
                    if (motion < .00001f) throw new Exception(name + " has no motion in " + state.name);
                    states.Add(new { state = state.name, motion, minAnkleGap = minGap, maxAnkleGap = maxGap, samples = 25, source = AssetDatabase.GetAssetPath(state.motion) });
                }
                var checks = new List<string>();
                a.SetInteger("Motion", 0); a.Play("Base Layer.Idle", 0, 0); a.Update(0);
                a.SetInteger("Motion", 1); Advance(a,.4f); Expect(a,"Walk"); checks.Add("Idle -> Walk");
                a.SetInteger("Motion", 0); Advance(a,.4f); Expect(a,"Idle"); checks.Add("Walk -> Idle");
                foreach (int locomotion in new[] { 0, 1 }) foreach (string attack in new[] { "Attack01", "Attack02" })
                {
                    string rest = locomotion == 0 ? "Idle" : "Walk";
                    a.SetInteger("Motion", locomotion); a.Play("Base Layer." + rest, 0, 0); a.Update(0);
                    a.SetTrigger(attack); Advance(a,.2f); Expect(a,attack);
                    float length = ((AnimationClip)controller.layers[0].stateMachine.states.Single(s=>s.state.name==attack).state.motion).length;
                    Advance(a,length+.4f); Expect(a,rest); checks.Add(rest + " -> " + attack + " -> " + rest);
                }
                reports.Add(new { actor = name, controller = expected, avatar = a.avatar.name, validHumanoid = a.isHuman, states, checks });
            }
            finally { UnityEngine.Object.DestroyImmediate(mesh); EditorSceneManager.ClosePreviewScene(scene); }
        }
        var result = new { passed = true, scene = ScenePath, samples = 400, transitionPaths = 24, actors = reports, verification = "Isolated Editor Animator and BakeMesh" };
        Report("playback_validation", result);
        return JsonConvert.SerializeObject(result);
    }
    public static string Controls()
    {
        if (!Application.isPlaying) throw new Exception("Play Mode required");
        var v = UnityEngine.Object.FindObjectOfType<BotAnimationLab>();
        if (!v || v.actors.Length != 4) throw new Exception("Bot scene not active");
        var buttons = v.ui.GetComponentsInChildren<Button>(true).ToDictionary(b => b.name);
        void Click(string n) => buttons["Btn_" + n].onClick.Invoke();
        void Tick(float seconds) { for (int i = 0; i < Mathf.CeilToInt(seconds * 60); i++) v.Tick(1f / 60); }
        void All(string state) { foreach (var actor in v.actors) Expect(actor.animator, state); }
        Click("Idle"); v.Seek(0); Click("Walk"); Tick(.4f); All("Walk");
        Click("Idle"); Tick(.4f); All("Idle");
        foreach (string attack in new[] { "Attack01", "Attack02" })
        {
            Click(attack); Tick(.2f); All(attack); Tick(6); All("Idle");
        }
        Click("Walk"); Tick(.4f); Click("Play");
        if (v.playing) throw new Exception("Pause failed");
        v.Seek(.2f); float time = v.TimePosition;
        Click("Next"); if (v.TimePosition <= time) throw new Exception("Next frame failed");
        Click("Previous"); if (Mathf.Abs(v.TimePosition - time) > .002f) throw new Exception("Previous frame failed");
        var seek = v.ui.GetComponentInChildren<BotAnimationSeekBar>(true);
        Canvas.ForceUpdateCanvases(); var corners = new Vector3[4]; ((RectTransform)seek.transform).GetWorldCorners(corners);
        seek.OnPointerDown(new PointerEventData(EventSystem.current) { position = RectTransformUtility.WorldToScreenPoint(null, Vector3.Lerp(corners[0], corners[2], .5f)) });
        if (Mathf.Abs(v.TimePosition / v.Duration - .5f) > .002f) throw new Exception("Pointer seek failed");
        foreach (string speed in new[] { "Speed025", "Speed05", "Speed1", "Speed2" }) Click(speed);
        if (v.speed != 2) throw new Exception("Speed failed"); Click("Speed1");
        foreach (int i in Enumerable.Range(0,4))
        {
            Click("Focus" + (i + 1));
            if (v.actors.Where((a,j) => a.skins.Any(s => s.enabled) != (j == i)).Any()) throw new Exception("Focus failed");
        }
        Click("Detail"); Click("Detail"); if (v.detail != 2) throw new Exception("Hand view failed");
        Click("All"); Click("Material");
        if (!v.actors.All(a => a.skins.All(s => s.sharedMaterial == v.clayMaterial))) throw new Exception("Clay failed");
        Click("Material"); Click("Side"); Click("Back"); Click("Front");
        Click("Loop"); if (!v.repeatAttacks) throw new Exception("Loop toggle failed");
        Click("Attack01"); Tick(6);
        if (v.actors.Any(a=>a.animator.GetCurrentAnimatorStateInfo(0).IsName("Base Layer.Idle") && !a.animator.IsInTransition(0))) throw new Exception("Attack repeat failed");
        Click("Loop"); Click("Walk"); Tick(.4f); v.Seek(.25f); v.RefreshView();
        if (v.ui.GetComponentsInChildren<TMP_Text>(true).Any(t => t.text.Contains("Infinity") || t.text.Contains("NaN"))) throw new Exception("Invalid time display");
        var result = new { passed = true, buttons = buttons.Count, checks = new[] { "locomotion controller transitions", "attack triggers and auto return", "pause", "next/previous frame", "pointer seek", "four speeds", "four actor focus", "hand detail", "gray/color", "front/side/back", "repeat attacks" } };
        Report("play_controls", result); return JsonConvert.SerializeObject(result);
    }
    public static string Pose(int motion, int focus, float phase)
    {
        var v = UnityEngine.Object.FindObjectOfType<BotAnimationLab>();
        v.selectedMotion = motion; v.SetFocus(focus); v.Seek(phase); v.RefreshView();
        return JsonConvert.SerializeObject(new { v.selectedMotion, v.focus, phase });
    }
}
#endif