using UnityEngine;

namespace MSCO
{
    /// <summary>
    /// Figur eines Mitspielers im Stil der My-Summer-Car-Leute (selbst gebaut, keine NPC-Kopie):
    /// Karohemd/Arbeitsjacke, Jeans, Arbeitsschuhe, Schnurrbart, Kappe oder Haare, leichter Bauch.
    /// 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
    /// zum Item, im Auto sitzt die Figur.
    /// </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.86f, 0.66f, 0.52f);
        static readonly Color Jeans = new Color(0.2f, 0.26f, 0.38f);
        static readonly Color Boots = new Color(0.22f, 0.15f, 0.09f);
        static readonly Color Sole = new Color(0.07f, 0.06f, 0.05f);
        static readonly Color Dark = new Color(0.08f, 0.08f, 0.08f);
        static readonly Color Metal = new Color(0.62f, 0.62f, 0.6f);
        static readonly Color[] HairColors =
        {
            new Color(0.23f, 0.15f, 0.09f), new Color(0.45f, 0.33f, 0.2f), new Color(0.12f, 0.1f, 0.08f), new Color(0.55f, 0.5f, 0.45f)
        };

        Color jacket;
        int variant;
        Transform headPivot, view;
        Transform pelvis, torso, belt, neck, belly, collar, placket, buckle;
        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];
        readonly Transform[] sole = new Transform[2], cuff = 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;

        public int HeldId { get { return last.HeldId; } }
        public PlayerState LastState { get { return last; } }
        public Vector3 HeadPosition { get { return headPivot.position; } }
        public string ModelDescription { get { return "MSCO figure, variant " + variant; } }

        // ---------------------------------------------------------------- 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.variant = Mathf.Abs(variant);
            rp.Build();
            rp.SetTarget(state);
            root.transform.position = rp.targetFeet;
            root.transform.rotation = Quaternion.Euler(0f, rp.targetYaw, 0f);
            rp.headWorld = rp.targetHead;
            rp.pitch = rp.targetPitch;
            rp.view.rotation = rp.targetViewRot;
            rp.lastPosition = root.transform.position;
            rp.Pose(0f);
            return rp;
        }

        void Build()
        {
            Transform r = transform;
            Color jacketDark = jacket * 0.7f;
            jacketDark.a = 1f;
            Color hairColor = HairColors[variant % HairColors.Length];
            bool wearsCap = variant % 3 != 2;
            bool sunglasses = variant % 4 == 1;
            Texture2D plaid = Plaid(jacket);

            // Körper: Karohemd/Jacke, Jeans, Gürtel, leichter Bauch (wie die Leute in MSC)
            pelvis = Capsule("Pelvis", r, Jeans);
            torso = Textured(Capsule("Torso", r, Color.white), plaid, new Vector2(2f, 3f));
            belly = Textured(Sphere("Belly", r, Color.white, 1f), plaid, new Vector2(2f, 2f));
            belt = Capsule("Belt", r, new Color(0.2f, 0.13f, 0.08f));
            buckle = Box("Buckle", r, Metal);
            placket = Box("Buttons", r, jacketDark);
            collar = Capsule("Collar", r, jacketDark);
            neck = Capsule("Neck", r, Skin);

            for (int i = 0; i < 2; i++)
            {
                thigh[i] = Capsule("Thigh", r, Jeans);
                shin[i] = Capsule("Shin", r, Jeans * 0.92f);
                boot[i] = Box("Boot", r, Boots);
                sole[i] = Box("Sole", r, Sole);
                upperArm[i] = Textured(Capsule("UpperArm", r, Color.white), plaid, new Vector2(1f, 2f));
                forearm[i] = Textured(Capsule("Forearm", r, Color.white), plaid, new Vector2(1f, 2f));
                cuff[i] = Capsule("Cuff", 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.21f, 0.255f, 0.235f);
            Transform jaw = Sphere("Jaw", headPivot, Skin, 0.2f);
            jaw.localPosition = new Vector3(0f, -0.065f, 0.02f);
            jaw.localScale = new Vector3(0.18f, 0.13f, 0.19f);
            Transform hair = Sphere("Hair", headPivot, hairColor, 0.24f);
            hair.localPosition = new Vector3(0f, 0.025f, -0.03f);
            hair.localScale = new Vector3(0.22f, 0.24f, 0.22f);
            for (int i = 0; i < 2; i++)
            {
                float side = i == 0 ? -1f : 1f;
                Transform ear = Sphere("Ear", headPivot, Skin * 0.96f, 0.05f);
                ear.localPosition = new Vector3(side * 0.105f, -0.005f, 0f);
                ear.localScale = new Vector3(0.035f, 0.065f, 0.05f);
                Transform eye = Sphere("Eye", headPivot, Dark, 0.028f);
                eye.localPosition = new Vector3(side * 0.042f, 0.018f, 0.105f);
                Transform brow = Box("Brow", headPivot, hairColor);
                brow.localPosition = new Vector3(side * 0.043f, 0.045f, 0.108f);
                brow.localScale = new Vector3(0.045f, 0.012f, 0.012f);
                brow.localRotation = Quaternion.Euler(0f, 0f, side * -8f);
            }
            Transform nose = Box("Nose", headPivot, Skin * 0.93f);
            nose.localPosition = new Vector3(0f, -0.012f, 0.12f);
            nose.localScale = new Vector3(0.035f, 0.055f, 0.045f);
            // Der typische Schnurrbart
            Transform mustache = Box("Mustache", headPivot, hairColor);
            mustache.localPosition = new Vector3(0f, -0.052f, 0.113f);
            mustache.localScale = new Vector3(0.085f, 0.024f, 0.03f);
            Transform mouth = Box("Mouth", headPivot, new Color(0.45f, 0.25f, 0.22f));
            mouth.localPosition = new Vector3(0f, -0.078f, 0.108f);
            mouth.localScale = new Vector3(0.05f, 0.01f, 0.01f);

            if (sunglasses)
            {
                Transform glasses = Box("Sunglasses", headPivot, Dark);
                glasses.localPosition = new Vector3(0f, 0.018f, 0.113f);
                glasses.localScale = new Vector3(0.14f, 0.035f, 0.012f);
            }
            if (wearsCap)
            {
                // Kappe ("lippis") in der Jackenfarbe
                Transform cap = Sphere("Cap", headPivot, jacketDark, 0.25f);
                cap.localPosition = new Vector3(0f, 0.075f, -0.005f);
                cap.localScale = new Vector3(0.235f, 0.15f, 0.245f);
                Transform brim = Box("CapBrim", headPivot, jacketDark);
                brim.localPosition = new Vector3(0f, 0.078f, 0.13f);
                brim.localScale = new Vector3(0.19f, 0.018f, 0.11f);
                brim.localRotation = Quaternion.Euler(-10f, 0f, 0f);
                Transform patch = Box("CapPatch", headPivot, new Color(0.9f, 0.88f, 0.8f));
                patch.localPosition = new Vector3(0f, 0.105f, 0.112f);
                patch.localScale = new Vector3(0.06f, 0.035f, 0.01f);
                patch.localRotation = Quaternion.Euler(-25f, 0f, 0f);
            }

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

        /// <summary>Kleines Karomuster (Flanellhemd) in der Grundfarbe; wird auf die Kapseln gekachelt.</summary>
        static Texture2D Plaid(Color baseColor)
        {
            const int size = 16;
            var tex = new Texture2D(size, size, TextureFormat.RGB24, false);
            Color light = Color.Lerp(baseColor, Color.white, 0.18f);
            Color dark = baseColor * 0.62f;
            for (int y = 0; y < size; y++)
            {
                for (int x = 0; x < size; x++)
                {
                    bool bandX = (x / 4) % 2 == 0, bandY = (y / 4) % 2 == 0;
                    Color c = bandX && bandY ? dark : bandX || bandY ? baseColor : light;
                    if (x % 8 == 1 || y % 8 == 1) c = Color.Lerp(c, Color.black, 0.45f); // dünne dunkle Linien
                    c.a = 1f;
                    tex.SetPixel(x, y, c);
                }
            }
            tex.filterMode = FilterMode.Point;
            tex.wrapMode = TextureWrapMode.Repeat;
            tex.Apply();
            return tex;
        }

        static Transform Textured(Transform part, Texture2D tex, Vector2 tiling)
        {
            Material m = part.GetComponent<Renderer>().material;
            m.mainTexture = tex;
            m.mainTextureScale = tiling;
            return part;
        }

        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);
            Pose(dt);
        }

        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
            Quaternion torsoRot = Quaternion.LookRotation(forward, up);
            Segment(torso, hip + up * 0.08f, neckBase, 0.4f, 0.25f);
            belly.localPosition = hip + up * 0.2f + forward * 0.06f;
            belly.localRotation = torsoRot;
            belly.localScale = new Vector3(0.34f, 0.28f, 0.27f);
            Segment(belt, hip + up * 0.05f, hip + up * 0.1f, 0.38f, 0.26f);
            buckle.localPosition = hip + up * 0.075f + forward * 0.13f;
            buckle.localRotation = torsoRot;
            buckle.localScale = new Vector3(0.06f, 0.045f, 0.015f);
            placket.localPosition = Vector3.Lerp(hip + up * 0.1f, neckBase, 0.62f) + forward * 0.122f;
            placket.localRotation = torsoRot;
            placket.localScale = new Vector3(0.025f, 0.26f, 0.01f);
            Segment(pelvis, hip - right * HipWidth, hip + right * HipWidth, 0.22f, 0.24f);
            Segment(collar, neckBase - up * 0.02f, neckBase + up * 0.035f, 0.17f, 0.15f);
            Segment(neck, neckBase, neckTop, 0.1f, 0.1f);

            // 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.015f, 0.05f);
                boot[i].localRotation = Quaternion.identity;
                boot[i].localScale = new Vector3(0.12f, 0.1f, 0.27f);
                sole[i].localPosition = ankle + new Vector3(0f, -0.065f, 0.05f);
                sole[i].localRotation = Quaternion.identity;
                sole[i].localScale = new Vector3(0.13f, 0.025f, 0.29f);

                // 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);
                Vector3 wrist = Vector3.Lerp(elbow, handTarget, 0.86f);
                Segment(cuff[i], wrist, Vector3.Lerp(elbow, handTarget, 0.94f), 0.12f, 0.12f);
                hand[i].localPosition = handTarget;
                hand[i].localScale = new Vector3(0.085f, 0.1f, 0.1f);
            }
        }

        /// <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;
        }
    }
}