using UnityEngine;

namespace MSCO
{
    /// <summary>
    /// Figur eines Mitspielers mit echter Körperhaltung. Aus Kopfposition (Kamera) und Bodenhöhe wird
    /// jedes Frame die Pose berechnet: Ducken beugt die Knie, nach vorne Lehnen neigt den Oberkörper,
    /// Laufen bewegt Beine und Arme, beim Halten greift der rechte Arm (mit Ellbogen) zum Item, im Auto
    /// sitzt die Figur. Die Körperteile sind abgerundete Kapseln zwischen den Gelenken.
    /// </summary>
    public class RemotePlayer : MonoBehaviour
    {
        const float Smoothing = 15f;
        const float StandingEyeHeight = 1.65f;
        const float MaxHeadPitch = 55f;

        // Körpermaße (Meter)
        const float ThighLength = 0.45f, ShinLength = 0.45f;
        const float UpperArmLength = 0.3f, ForearmLength = 0.29f;
        const float TorsoLength = 0.55f;          // Hüfte bis Hals
        const float HipWidth = 0.1f, ShoulderWidth = 0.21f;
        const float AnkleHeight = 0.07f;

        static readonly Color Skin = new Color(0.93f, 0.76f, 0.62f);
        static readonly Color Jeans = new Color(0.18f, 0.25f, 0.42f);
        static readonly Color Boots = new Color(0.24f, 0.16f, 0.1f);
        static readonly Color Dark = new Color(0.08f, 0.08f, 0.08f);

        Color jacket;
        Transform headPivot, view;
        Transform pelvis, torso, belt, neck;
        readonly Transform[] thigh = new Transform[2], shin = new Transform[2], boot = new Transform[2];
        readonly Transform[] upperArm = new Transform[2], forearm = new Transform[2], hand = new Transform[2];

        Vector3 targetFeet;
        Vector3 targetHead;
        Vector3 headWorld;
        float targetYaw, targetPitch, pitch;
        Quaternion targetViewRot = Quaternion.identity;
        PlayerState last;

        Vector3 lastPosition;
        float walkPhase, walkAmount, speed;

        // Echtes Spielmodell (NPC aus der Szene); null = eigene Figur als Rückfall
        GameCharacter model;

        public int HeldId { get { return last.HeldId; } }
        public PlayerState LastState { get { return last; } }
        public Vector3 HeadPosition { get { return model != null ? model.HeadPosition : headPivot.position; } }
        public string ModelDescription { get { return model != null ? "game model: " + model.Description : "fallback figure (no NPC template found)"; } }

        // ---------------------------------------------------------------- Aufbau

        public static RemotePlayer Create(string name, Color jacketColor, PlayerState state, int variant)
        {
            var root = new GameObject(name);
            var rp = root.AddComponent<RemotePlayer>();
            rp.jacket = jacketColor;
            rp.Build();
            rp.SetTarget(state);
            root.transform.position = rp.targetFeet;
            root.transform.rotation = Quaternion.Euler(0f, rp.targetYaw, 0f);

            // Wenn möglich einen echten NPC aus dem Spiel als Figur nehmen, sonst die eigene Figur
            try { rp.model = GameCharacter.TryCreate(root.transform, variant); }
            catch (System.Exception e) { MSCLoader.ModConsole.Warning("[MSCO] Game model failed: " + e.Message); }
            if (rp.model != null)
                foreach (Renderer r in root.GetComponentsInChildren<Renderer>(true))
                    if (!r.transform.IsChildOf(rp.model.Root)) r.enabled = false;
            rp.headWorld = rp.targetHead;
            rp.pitch = rp.targetPitch;
            rp.view.rotation = rp.targetViewRot;
            rp.lastPosition = root.transform.position;
            if (rp.model == null) rp.Pose(0f);
            return rp;
        }

        void Build()
        {
            Transform r = transform;
            Color jacketDark = jacket * 0.75f;
            jacketDark.a = 1f;

            pelvis = Capsule("Pelvis", r, Jeans);
            torso = Capsule("Torso", r, jacket);
            belt = Capsule("Belt", r, Dark);
            neck = Capsule("Neck", r, Skin);

            for (int i = 0; i < 2; i++)
            {
                thigh[i] = Capsule("Thigh", r, Jeans);
                shin[i] = Capsule("Shin", r, Jeans);
                boot[i] = Box("Boot", r, Boots);
                upperArm[i] = Capsule("UpperArm", r, jacket);
                forearm[i] = Capsule("Forearm", r, jacketDark);
                hand[i] = Sphere("Hand", r, Skin, 0.1f);
            }

            // Kopf: dreht mit Blick (hoch/runter), Gesicht nach +Z
            headPivot = new GameObject("Head").transform;
            headPivot.SetParent(r, false);
            Transform skull = Sphere("Skull", headPivot, Skin, 0.24f);
            skull.localScale = new Vector3(0.22f, 0.26f, 0.24f);
            Transform hair = Sphere("Hair", headPivot, new Color(0.25f, 0.17f, 0.1f), 0.24f);
            hair.localPosition = new Vector3(0f, 0.02f, -0.025f);
            hair.localScale = new Vector3(0.23f, 0.25f, 0.23f);
            Transform cap = Sphere("Cap", headPivot, jacketDark, 0.25f);
            cap.localPosition = new Vector3(0f, 0.07f, -0.005f);
            cap.localScale = new Vector3(0.245f, 0.16f, 0.255f);
            Transform brim = Box("CapBrim", headPivot, jacketDark);
            brim.localPosition = new Vector3(0f, 0.075f, 0.13f);
            brim.localScale = new Vector3(0.2f, 0.02f, 0.11f);
            brim.localRotation = Quaternion.Euler(-8f, 0f, 0f);
            for (int i = 0; i < 2; i++)
            {
                Transform eye = Sphere("Eye", headPivot, Dark, 0.035f);
                eye.localPosition = new Vector3(i == 0 ? -0.045f : 0.045f, 0.015f, 0.105f);
            }
            Transform nose = Box("Nose", headPivot, Skin * 0.95f);
            nose.localPosition = new Vector3(0f, -0.02f, 0.12f);
            nose.localScale = new Vector3(0.035f, 0.05f, 0.04f);

            // Unsichtbarer "Blick" mit der exakten Kameradrehung - daran hängt das gehaltene Item
            view = new GameObject("View").transform;
            view.SetParent(r, false);
        }

        static Transform Capsule(string name, Transform parent, Color color) { return Primitive(PrimitiveType.Capsule, name, parent, color); }

        static Transform Box(string name, Transform parent, Color color) { return Primitive(PrimitiveType.Cube, name, parent, color); }

        static Transform Sphere(string name, Transform parent, Color color, float size)
        {
            Transform t = Primitive(PrimitiveType.Sphere, name, parent, color);
            t.localScale = Vector3.one * size;
            return t;
        }

        static Transform Primitive(PrimitiveType type, string name, Transform parent, Color color)
        {
            GameObject go = GameObject.CreatePrimitive(type);
            go.name = name;
            Destroy(go.GetComponent<Collider>()); // stört sonst Physik/Trigger
            var renderer = go.GetComponent<Renderer>();
            renderer.material.color = color;
            renderer.receiveShadows = true;
            go.transform.SetParent(parent, false);
            return go.transform;
        }

        // ---------------------------------------------------------------- Zustand

        public void SetTarget(PlayerState state)
        {
            last = state;
            targetHead = state.CamPos;

            // Füße: Bodenhöhe vom Spieler, waagerecht an der Spielerposition (Lehnen = Kopf woanders als Füße).
            // Liegt der Kopf unplausibel weit weg (andere Kamera), Füße unter den Kopf.
            float feetY = state.FeetY != 0f ? state.FeetY : state.CamPos.y - StandingEyeHeight;
            var feet = new Vector3(state.Position.x, feetY, state.Position.z);
            var horizontal = new Vector3(state.CamPos.x - feet.x, 0f, state.CamPos.z - feet.z);
            if (horizontal.sqrMagnitude > 0.8f * 0.8f || state.Seated) feet = new Vector3(state.CamPos.x, feetY, state.CamPos.z);
            targetFeet = feet;

            // Blickrichtung ohne seitliches Kippen
            Vector3 forward = state.CamRot * Vector3.forward;
            Vector3 flat = new Vector3(forward.x, 0f, forward.z);
            targetYaw = flat.sqrMagnitude > 0.0001f ? Quaternion.LookRotation(flat).eulerAngles.y : state.RotationY;
            targetPitch = Mathf.Clamp(-Mathf.Asin(Mathf.Clamp(forward.y, -1f, 1f)) * Mathf.Rad2Deg, -MaxHeadPitch, MaxHeadPitch);
            targetViewRot = state.CamRot;
        }

        public void Tick(float dt)
        {
            // Bei großen Sprüngen (Teleport, Laden) direkt setzen statt gleiten
            bool snap = (transform.position - targetFeet).sqrMagnitude > 100f;
            float t = snap ? 1f : Mathf.Clamp01(dt * Smoothing);

            transform.position = Vector3.Lerp(transform.position, targetFeet, t);
            transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.Euler(0f, targetYaw, 0f), t);
            headWorld = snap ? targetHead : Vector3.Lerp(headWorld, targetHead, t);
            pitch = Mathf.Lerp(pitch, targetPitch, t);
            view.position = headWorld;
            view.rotation = Quaternion.Slerp(view.rotation, targetViewRot, t);

            UpdateWalk(dt);
            if (model != null) model.Animate(speed); // Spiel-Animation (Idle/Walk) läuft vor LateUpdate
            else Pose(dt);
        }

        /// <summary>Spielmodell: nach der Animation Ducken/Lehnen/Kopf/Arme anpassen.</summary>
        void LateUpdate()
        {
            if (model == null) return;
            Vector3 heldPos;
            Quaternion heldRot;
            bool holding = TryGetHeldPose(out heldPos, out heldRot);
            model.Pose(transform, headWorld, pitch, last.Seated, holding, heldPos);
        }

        void UpdateWalk(float dt)
        {
            Vector3 moved = transform.position - lastPosition;
            lastPosition = transform.position;
            moved.y = 0f;
            speed = dt > 0f ? moved.magnitude / dt : 0f;
            if (speed > 12f || last.Seated) speed = 0f; // Teleport oder im Auto

            walkAmount = Mathf.Lerp(walkAmount, Mathf.Clamp01(speed / 2.5f), Mathf.Clamp01(dt * 8f));
            walkPhase += speed * dt * 3.4f;
        }

        // ---------------------------------------------------------------- Pose (alles im lokalen Raum der Figur)

        void Pose(float dt)
        {
            Vector3 head = transform.InverseTransformPoint(headWorld) + new Vector3(0f, -0.02f, -0.03f);
            Vector3 neckTop = head + new Vector3(0f, -0.12f, -0.01f);
            Vector3 neckBase = head + new Vector3(0f, -0.2f, -0.02f);

            // Hüfte: beim Lehnen nach hinten ausweichen, beim Ducken absinken (Füße bleiben am Boden)
            Vector3 hip;
            if (last.Seated)
            {
                hip = neckBase + new Vector3(0f, -TorsoLength, -0.08f);
            }
            else
            {
                var lean = new Vector3(neckBase.x, 0f, neckBase.z);
                hip = -lean * 0.25f;
                float horizontal = (new Vector3(neckBase.x - hip.x, 0f, neckBase.z - hip.z)).magnitude;
                float vertical = Mathf.Sqrt(Mathf.Max(0.04f, TorsoLength * TorsoLength - horizontal * horizontal));
                hip.y = Mathf.Clamp(neckBase.y - vertical, 0.3f, ThighLength + ShinLength + AnkleHeight - 0.02f);
            }

            Vector3 up = (neckBase - hip).normalized;
            Vector3 right = Vector3.right;
            Vector3 forward = Vector3.Cross(right, up).normalized;

            // Rumpf
            Segment(torso, hip + up * 0.08f, neckBase, 0.38f, 0.24f);
            Segment(belt, hip + up * 0.06f, hip + up * 0.1f, 0.37f, 0.23f);
            Segment(pelvis, hip - right * HipWidth, hip + right * HipWidth, 0.2f, 0.22f);
            Segment(neck, neckBase, neckTop, 0.09f, 0.09f);

            // Kopf
            headPivot.localPosition = head;
            headPivot.localRotation = Quaternion.Euler(pitch, 0f, 0f);

            float swing = Mathf.Sin(walkPhase) * walkAmount;
            for (int i = 0; i < 2; i++)
            {
                float side = i == 0 ? -1f : 1f;
                float phase = i == 0 ? swing : -swing;

                // Beine
                Vector3 hipJoint = hip + right * (HipWidth * side);
                Vector3 ankle;
                if (last.Seated)
                    ankle = hipJoint + new Vector3(0f, -0.4f, 0.48f);
                else
                    ankle = new Vector3(HipWidth * side, AnkleHeight + Mathf.Max(0f, Mathf.Cos(walkPhase + i * Mathf.PI)) * 0.07f * walkAmount, phase * 0.3f);
                Vector3 knee = Joint(hipJoint, ankle, ThighLength, ShinLength, Vector3.forward);
                Segment(thigh[i], hipJoint, knee, 0.17f, 0.17f);
                Segment(shin[i], knee, ankle, 0.14f, 0.14f);
                boot[i].localPosition = ankle + new Vector3(0f, -0.02f, 0.05f);
                boot[i].localRotation = Quaternion.identity;
                boot[i].localScale = new Vector3(0.12f, 0.1f, 0.27f);

                // Arme
                Vector3 shoulder = neckBase - up * 0.06f + right * (ShoulderWidth * side);
                Vector3 handTarget;
                Vector3 heldPos;
                Quaternion heldRot;
                if (i == 1 && TryGetHeldPose(out heldPos, out heldRot))
                    handTarget = transform.InverseTransformPoint(heldPos);
                else if (last.Seated)
                    handTarget = shoulder + new Vector3(-side * 0.05f, -0.3f, 0.38f); // Hände nach vorne (Lenkrad)
                else
                    handTarget = shoulder + new Vector3(side * 0.03f, -(UpperArmLength + ForearmLength) + 0.04f, -phase * 0.22f);

                // Nicht weiter als die Armlänge
                Vector3 reach = handTarget - shoulder;
                float maxReach = UpperArmLength + ForearmLength - 0.01f;
                if (reach.magnitude > maxReach) handTarget = shoulder + reach.normalized * maxReach;

                Vector3 elbow = Joint(shoulder, handTarget, UpperArmLength, ForearmLength, new Vector3(side * 0.4f, -0.2f, -1f));
                Segment(upperArm[i], shoulder, elbow, 0.12f, 0.12f);
                Segment(forearm[i], elbow, handTarget, 0.11f, 0.11f);
                hand[i].localPosition = handTarget;
            }
        }

        /// <summary>Zwei-Knochen-Gelenk (Knie/Ellbogen): Punkt zwischen a und b, zur Seite "bend" geknickt.</summary>
        static Vector3 Joint(Vector3 a, Vector3 b, float lengthA, float lengthB, Vector3 bend)
        {
            Vector3 ab = b - a;
            float d = Mathf.Clamp(ab.magnitude, 0.01f, lengthA + lengthB - 0.001f);
            Vector3 dir = ab.normalized;
            // Abstand vom Startpunkt entlang ab und seitlicher Abstand (Kosinussatz)
            float along = (lengthA * lengthA - lengthB * lengthB + d * d) / (2f * d);
            float sideways = Mathf.Sqrt(Mathf.Max(0f, lengthA * lengthA - along * along));
            Vector3 bendDir = bend - dir * Vector3.Dot(bend, dir);
            if (bendDir.sqrMagnitude < 0.0001f) bendDir = Vector3.forward - dir * Vector3.Dot(Vector3.forward, dir);
            return a + dir * along + bendDir.normalized * sideways;
        }

        /// <summary>Kapsel von a nach b spannen (lokaler Raum der Figur).</summary>
        static void Segment(Transform part, Vector3 a, Vector3 b, float width, float depth)
        {
            Vector3 dir = b - a;
            float length = dir.magnitude;
            part.localPosition = (a + b) * 0.5f;
            part.localRotation = length > 0.0001f ? Quaternion.FromToRotation(Vector3.up, dir / length) : Quaternion.identity;
            part.localScale = new Vector3(width, length * 0.5f + Mathf.Min(width, depth) * 0.5f, depth);
        }

        /// <summary>Wo das gehaltene Item beim Spieler gerade ist (relativ zum Blick).</summary>
        public bool TryGetHeldPose(out Vector3 pos, out Quaternion rot)
        {
            pos = Vector3.zero;
            rot = Quaternion.identity;
            if (last.HeldId == 0) return false;
            pos = view.TransformPoint(last.HeldLocalPos);
            rot = view.rotation * last.HeldLocalRot;
            return true;
        }
    }
}