using System;
using System.Collections.Generic;
using System.Reflection;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using KinematicCharacterController;
using Skopje.Modding;
using UnityEngine;

namespace PioneerSize
{
    [BepInPlugin(PluginGuid, PluginName, PluginVersion)]
    public class PioneerSizePlugin : BasePlugin
    {
        public const string PluginGuid = "com.skopje.pioneersize";
        public const string PluginName = "PioneerSize";
        public const string PluginVersion = "1.0.2";

        internal static ManualLogSource LogSource;
        internal static ConfigEntry<float> Height;
        internal static ConfigEntry<float> SpeedMultiplier;

        static Harmony _harmony;
        static GameObject _host;
        static Il2CppSystem.Action<SkopjePlayer> _onPlayerStartedClient;
        static Il2CppSystem.Action<SkopjePlayer> _onPlayerStoppedClient;

        public override void Load()
        {
            LogSource = Log;
            Height = Config.Bind("Size", "Height", 1.8f, new ConfigDescription(
                "Standing height in meters. Crouch keeps the game's own crouch fraction of this height.",
                new AcceptableValueRange<float>(0.5f, 3f)));
            SpeedMultiplier = Config.Bind("Size", "SpeedMultiplier", 1f, new ConfigDescription(
                "Multiplies walk, sprint, crouch, air, jump, and dash speed. 1 is normal.",
                new AcceptableValueRange<float>(0.05f, 10f)));

            ClassInjector.RegisterTypeInIl2Cpp<PioneerSizeDriver>();

            _onPlayerStartedClient = DelegateSupport.ConvertDelegate<Il2CppSystem.Action<SkopjePlayer>>(new Action<SkopjePlayer>(PioneerSizeApply.OnPlayerStartedClient));
            _onPlayerStoppedClient = DelegateSupport.ConvertDelegate<Il2CppSystem.Action<SkopjePlayer>>(new Action<SkopjePlayer>(PioneerSizeApply.OnPlayerStoppedClient));
            ModAPI.add_OnPlayerStartedClient(_onPlayerStartedClient);
            ModAPI.add_OnPlayerStoppedClient(_onPlayerStoppedClient);

            _harmony = new Harmony(PluginGuid);
            Patch(AccessTools.Method(typeof(SkopjePlayer), "OnStartClient"), nameof(PioneerSizeApply.AfterPlayer));
            Patch(AccessTools.Method(typeof(SkopjeCharacterController), "Start"), nameof(PioneerSizeApply.AfterController));
            Patch(AccessTools.Method(typeof(SkopjeCharacterController), "ResetController"), nameof(PioneerSizeApply.AfterReset));
            Patch(AccessTools.Method(typeof(SkopjePlayer), "RefreshActiveModels"), nameof(PioneerSizeApply.AfterPlayer));
            Patch(AccessTools.Method(typeof(SkopjePlayer), "RefreshPlayerCollider"), nameof(PioneerSizeApply.AfterPlayer));

            _host = new GameObject("PioneerSize");
            UnityEngine.Object.DontDestroyOnLoad(_host);
            _host.hideFlags = HideFlags.HideAndDontSave;
            _host.AddComponent<PioneerSizeDriver>();

            LogSource.LogInfo($"{PluginName} {PluginVersion} loaded. Height {Height.Value} m, speed {SpeedMultiplier.Value}. Config: {Config.ConfigFilePath}");
        }

        public override bool Unload()
        {
            PioneerSizeApply.RestoreAll();
            if (_harmony != null)
                _harmony.UnpatchSelf();
            if (_onPlayerStartedClient != null)
                ModAPI.remove_OnPlayerStartedClient(_onPlayerStartedClient);
            if (_onPlayerStoppedClient != null)
                ModAPI.remove_OnPlayerStoppedClient(_onPlayerStoppedClient);
            if (_host != null)
            {
                UnityEngine.Object.Destroy(_host);
                _host = null;
            }

            return true;
        }

        static void Patch(MethodInfo method, string postfix)
        {
            if (method == null)
            {
                LogSource.LogWarning("PioneerSize hook was not found: " + postfix);
                return;
            }

            _harmony.Patch(method, postfix: new HarmonyMethod(typeof(PioneerSizeApply), postfix));
        }
    }

    public class PioneerSizeDriver : MonoBehaviour
    {
        void Update()
        {
            PioneerSizeApply.Pump();
        }
    }

    static class PioneerSizeApply
    {
        const float MinHeight = 0.5f;
        const float MaxHeight = 3f;
        const float MinSpeed = 0.05f;
        const float MaxSpeed = 10f;

        sealed class Body
        {
            public float Walk;
            public float Air;
            public float AirAccel;
            public float Crouch;
            public float Sprint;
            public float Jump;
            public float Dash;
            public float Height;
            public float Radius;
            public float Step;
            public float YOffset;
            public Vector3 Head;
            public Vector3 Chest;
            public Vector3 Center;
            public bool HeadLocal;
            public bool ChestLocal;
            public bool CenterLocal;
            public float AppliedScale = -1f;
            public float AppliedHeight = -1f;
            public float AppliedSpeed = -1f;
            public bool Logged;
        }

        sealed class Avatar
        {
            public Vector3 Mesh = Vector3.one;
            public bool HasMesh;
            public Vector3 First = Vector3.one;
            public bool HasFirst;
            public Vector3 Third = Vector3.one;
            public bool HasThird;
            public float FirstPersonPlayerScale = 1f;
            public Vector3 CameraLocal;
            public bool HasCamera;
            public bool CameraUnderVisual;
            public float OwnerHeight;
            public float OwnerRadius;
            public Vector3 OwnerCenter;
            public bool HasOwner;
            public bool OwnerIsMotor;
            public float AppliedScale = -1f;
        }

        static readonly Dictionary<IntPtr, Body> Bodies = new Dictionary<IntPtr, Body>();
        static readonly Dictionary<IntPtr, Avatar> Avatars = new Dictionary<IntPtr, Avatar>();
        static readonly List<SkopjePlayer> Watching = new List<SkopjePlayer>();
        static bool _restoring;
        static int _errors;

        public static void OnPlayerStartedClient(SkopjePlayer player)
        {
            if (!Alive(player))
                return;

            Watch(player);
            bool applied = Apply(player, false);
            if (PioneerSizePlugin.LogSource != null)
            {
                PioneerSizePlugin.LogSource.LogInfo(applied
                    ? $"OnPlayerStartedClient applied size to player {player.PlayerIdx}."
                    : $"OnPlayerStartedClient queued player {player.PlayerIdx}. The body is not ready yet.");
            }
        }

        public static void OnPlayerStoppedClient(SkopjePlayer player)
        {
            IntPtr key = Key(player);
            if (key == IntPtr.Zero)
                return;

            for (int i = Watching.Count - 1; i >= 0; i--)
            {
                if (Key(Watching[i]) == key)
                    Watching.RemoveAt(i);
            }

            Avatars.Remove(key);
            SkopjeCharacterController controller = player.SkopjeCharacterController;
            IntPtr bodyKey = Key(controller);
            if (bodyKey != IntPtr.Zero)
                Bodies.Remove(bodyKey);
        }

        public static void AfterPlayer(SkopjePlayer __instance)
        {
            if (!Alive(__instance))
                return;

            Watch(__instance);
            Apply(__instance, false);
        }

        public static void AfterController(SkopjeCharacterController __instance)
        {
            if (!Alive(__instance))
                return;

            SkopjePlayer player = __instance.Player;
            if (!Alive(player))
                return;

            Watch(player);
            Apply(player, false);
        }

        public static void AfterReset(SkopjeCharacterController __instance)
        {
            if (!Alive(__instance))
                return;

            SkopjePlayer player = __instance.Player;
            if (!Alive(player))
                return;

            Watch(player);
            Apply(player, true);
        }

        public static void Pump()
        {
            for (int i = Watching.Count - 1; i >= 0; i--)
            {
                SkopjePlayer player = Watching[i];
                if (!Alive(player))
                {
                    Watching.RemoveAt(i);
                    continue;
                }

                Apply(player, false);
            }
        }

        public static void RestoreAll()
        {
            _restoring = true;
            try
            {
                for (int i = 0; i < Watching.Count; i++)
                {
                    if (Alive(Watching[i]))
                        Apply(Watching[i], true);
                }
            }
            finally
            {
                _restoring = false;
                Watching.Clear();
                Bodies.Clear();
                Avatars.Clear();
            }
        }

        static bool Apply(SkopjePlayer player, bool reset)
        {
            if (!Alive(player))
                return false;

            try
            {
                SkopjeCharacterController controller = player.SkopjeCharacterController;
                if (!Alive(controller))
                    return false;

                IntPtr id = Key(controller);
                if (!Bodies.TryGetValue(id, out Body body))
                {
                    if (!Ready(controller))
                        return false;

                    body = Capture(controller);
                    Bodies[id] = body;
                }

                float height = _restoring ? body.Height : ReadHeight();
                float speed = ReadSpeed();
                float scale = body.Height > 0.01f ? height / body.Height : 1f;
                bool sizeDirty = reset || body.AppliedScale < 0f || Mathf.Abs(body.AppliedHeight - height) > 0.0001f;
                bool speedDirty = reset || body.AppliedSpeed < 0f || Mathf.Abs(body.AppliedSpeed - speed) > 0.0001f;
                if (!sizeDirty && !speedDirty)
                    return true;

                if (speedDirty)
                    WriteSpeeds(controller, body, speed);
                if (sizeDirty)
                    WriteSize(controller, player, body, scale, reset || body.AppliedScale < 0f);

                body.AppliedScale = scale;
                body.AppliedHeight = height;
                body.AppliedSpeed = speed;

                if (!body.Logged && PioneerSizePlugin.LogSource != null)
                {
                    body.Logged = true;
                    PioneerSizePlugin.LogSource.LogInfo($"Pioneer height {height:0.##} m, stock {body.Height:0.##} m, speed x{speed:0.##} on player {player.PlayerIdx}.");
                }

                return true;
            }
            catch (Exception ex)
            {
                LogOnce(ex);
                return false;
            }
        }

        static void WriteSpeeds(SkopjeCharacterController controller, Body body, float speed)
        {
            controller.MaxStableMoveSpeed = body.Walk * speed;
            controller.MaxAirMoveSpeed = body.Air * speed;
            controller.AirAccelerationSpeed = body.AirAccel * speed;
            controller.CrouchMoveSpeed = body.Crouch * speed;
            controller.SprintSpeed = body.Sprint * speed;
            controller.JumpSpeed = body.Jump * speed;
            controller.DashSpeed = body.Dash * speed;
        }

        // Standing height is the crouch system's full-height reference. The live capsule is scaled
        // from wherever the stance currently is, so a crouch in progress is not popped back up.
        static void WriteSize(SkopjeCharacterController controller, SkopjePlayer player, Body body, float scale, bool fromVanilla)
        {
            float ratio = fromVanilla || body.AppliedScale <= 0.0001f ? scale : scale / body.AppliedScale;
            controller.standingHeight = body.Height * scale;
            controller.playerRadius = body.Radius * scale;

            KinematicCharacterMotor motor = controller.Motor;
            if (Alive(motor))
            {
                motor.MaxStepHeight = body.Step * scale;
                float radius = fromVanilla ? body.Radius * scale : motor.CapsuleRadius * ratio;
                float height = fromVanilla ? body.Height * scale : motor.CapsuleHeight * ratio;
                float yOffset = fromVanilla
                    ? (body.YOffset > 0.001f ? body.YOffset * scale : height * 0.5f)
                    : motor.CapsuleYOffset * ratio;
                motor.SetCapsuleDimensions(radius, height, yOffset);
            }

            if (body.HeadLocal)
                controller.originalHeadPosition = (fromVanilla ? body.Head : controller.originalHeadPosition) * (fromVanilla ? scale : ratio);
            if (body.ChestLocal)
                controller.originalChestPosition = (fromVanilla ? body.Chest : controller.originalChestPosition) * (fromVanilla ? scale : ratio);
            if (body.CenterLocal)
                controller.originalCenterPosition = (fromVanilla ? body.Center : controller.originalCenterPosition) * (fromVanilla ? scale : ratio);

            ScaleVisuals(player, controller, scale, ratio, fromVanilla);
        }

        static void ScaleVisuals(SkopjePlayer player, SkopjeCharacterController controller, float scale, float ratio, bool fromVanilla)
        {
            IntPtr id = Key(player);
            if (id == IntPtr.Zero || Mathf.Abs(ratio - 1f) < 0.0001f)
                return;

            if (!Avatars.TryGetValue(id, out Avatar avatar))
            {
                avatar = new Avatar();
                Avatars[id] = avatar;
            }

            CaptureAvatar(player, avatar);

            Transform mesh = controller.MeshRoot;
            if (avatar.HasMesh && mesh != null)
                mesh.localScale = fromVanilla ? avatar.Mesh * scale : mesh.localScale * ratio;

            if (avatar.HasFirst && player.FirstPerson != null && player.FirstPerson.transform.localScale.sqrMagnitude > 0.0001f)
                player.FirstPerson.transform.localScale = fromVanilla ? avatar.First * scale : player.FirstPerson.transform.localScale * ratio;

            if (avatar.HasThird && player.ThirdPerson != null && player.ThirdPerson.transform.localScale.sqrMagnitude > 0.0001f)
                player.ThirdPerson.transform.localScale = fromVanilla ? avatar.Third * scale : player.ThirdPerson.transform.localScale * ratio;

            player.FirstPersonPlayerScale = fromVanilla ? avatar.FirstPersonPlayerScale * scale : player.FirstPersonPlayerScale * ratio;

            if (avatar.HasCamera && !avatar.CameraUnderVisual && player.SkopjeFPSCamera != null)
            {
                Transform cam = player.SkopjeFPSCamera.transform;
                cam.localPosition = fromVanilla ? avatar.CameraLocal * scale : cam.localPosition * ratio;
            }

            CapsuleCollider owner = OwnerCapsule(player);
            if (avatar.HasOwner && owner != null && !avatar.OwnerIsMotor)
            {
                owner.height = fromVanilla ? avatar.OwnerHeight * scale : owner.height * ratio;
                owner.radius = fromVanilla ? avatar.OwnerRadius * scale : owner.radius * ratio;
                owner.center = fromVanilla ? avatar.OwnerCenter * scale : owner.center * ratio;
            }
        }

        static void CaptureAvatar(SkopjePlayer player, Avatar avatar)
        {
            Transform mesh = Alive(player.SkopjeCharacterController) ? player.SkopjeCharacterController.MeshRoot : null;
            if (!avatar.HasMesh && mesh != null && mesh.localScale.sqrMagnitude > 0.0001f)
            {
                avatar.Mesh = mesh.localScale;
                avatar.HasMesh = true;
            }

            if (!avatar.HasFirst && player.FirstPerson != null && player.FirstPerson.transform.localScale.sqrMagnitude > 0.0001f)
            {
                avatar.First = player.FirstPerson.transform.localScale;
                avatar.HasFirst = true;
            }

            if (!avatar.HasThird && player.ThirdPerson != null && player.ThirdPerson.transform.localScale.sqrMagnitude > 0.0001f)
            {
                avatar.Third = player.ThirdPerson.transform.localScale;
                avatar.HasThird = true;
            }

            if (avatar.AppliedScale < 0f)
            {
                avatar.FirstPersonPlayerScale = player.FirstPersonPlayerScale;
                avatar.AppliedScale = 1f;
            }

            if (!avatar.HasCamera && player.SkopjeFPSCamera != null)
            {
                avatar.CameraLocal = player.SkopjeFPSCamera.transform.localPosition;
                avatar.HasCamera = true;
                avatar.CameraUnderVisual = IsUnder(player.SkopjeFPSCamera.transform, mesh)
                    || (player.FirstPerson != null && IsUnder(player.SkopjeFPSCamera.transform, player.FirstPerson.transform))
                    || (player.ThirdPerson != null && IsUnder(player.SkopjeFPSCamera.transform, player.ThirdPerson.transform));
            }

            if (!avatar.HasOwner)
            {
                CapsuleCollider owner = OwnerCapsule(player);
                KinematicCharacterMotor motor = Alive(player.SkopjeCharacterController) ? player.SkopjeCharacterController.Motor : null;
                if (owner != null)
                {
                    avatar.OwnerHeight = owner.height;
                    avatar.OwnerRadius = owner.radius;
                    avatar.OwnerCenter = owner.center;
                    avatar.HasOwner = true;
                    avatar.OwnerIsMotor = Alive(motor) && Same(motor.Capsule, owner);
                }
            }
        }

        static Body Capture(SkopjeCharacterController controller)
        {
            KinematicCharacterMotor motor = controller.Motor;
            float height = controller.standingHeight;
            float radius = controller.playerRadius;
            float yOffset = 0f;
            float step = 0.3f;
            if (Alive(motor))
            {
                if (height <= 0.01f)
                    height = motor.CapsuleHeight;
                if (radius <= 0.01f)
                    radius = motor.CapsuleRadius;
                yOffset = motor.CapsuleYOffset;
                step = motor.MaxStepHeight;
            }

            return new Body
            {
                Walk = controller.MaxStableMoveSpeed,
                Air = controller.MaxAirMoveSpeed,
                AirAccel = controller.AirAccelerationSpeed,
                Crouch = controller.CrouchMoveSpeed,
                Sprint = controller.SprintSpeed,
                Jump = controller.JumpSpeed,
                Dash = controller.DashSpeed,
                Height = height,
                Radius = radius,
                Step = step,
                YOffset = yOffset,
                Head = controller.originalHeadPosition,
                Chest = controller.originalChestPosition,
                Center = controller.originalCenterPosition,
                HeadLocal = IsLocalOffset(controller.originalHeadPosition),
                ChestLocal = IsLocalOffset(controller.originalChestPosition),
                CenterLocal = IsLocalOffset(controller.originalCenterPosition),
            };
        }

        static bool Ready(SkopjeCharacterController controller)
        {
            if (!Alive(controller.Motor))
                return false;
            if (controller.MaxStableMoveSpeed <= 0.01f)
                return false;
            return controller.standingHeight > 0.01f || controller.Motor.CapsuleHeight > 0.01f;
        }

        static void Watch(SkopjePlayer player)
        {
            IntPtr key = Key(player);
            if (key == IntPtr.Zero)
                return;

            for (int i = 0; i < Watching.Count; i++)
            {
                if (Key(Watching[i]) == key)
                    return;
            }

            Watching.Add(player);
        }

        static bool Alive(Il2CppObjectBase obj)
        {
            return obj != null && obj.Pointer != IntPtr.Zero;
        }

        static IntPtr Key(Il2CppObjectBase obj)
        {
            return obj == null ? IntPtr.Zero : obj.Pointer;
        }

        static bool Same(UnityEngine.Object left, UnityEngine.Object right)
        {
            IntPtr a = Key(left as Il2CppObjectBase);
            IntPtr b = Key(right as Il2CppObjectBase);
            return a != IntPtr.Zero && a == b;
        }

        static bool IsLocalOffset(Vector3 value)
        {
            return value.sqrMagnitude > 0.0001f && value.sqrMagnitude < 25f && value.y > 0f && value.y < 3f;
        }

        static bool IsUnder(Transform child, Transform parent)
        {
            if (child == null || parent == null)
                return false;

            for (Transform cursor = child; cursor != null; cursor = cursor.parent)
            {
                if (cursor == parent)
                    return true;
            }

            return false;
        }

        static CapsuleCollider OwnerCapsule(SkopjePlayer player)
        {
            if (player.OwnerCollider == null)
                return null;
            return player.OwnerCollider.TryCast<CapsuleCollider>();
        }

        static float ReadHeight()
        {
            float value = PioneerSizePlugin.Height != null ? PioneerSizePlugin.Height.Value : 1.8f;
            return Mathf.Clamp(value, MinHeight, MaxHeight);
        }

        static float ReadSpeed()
        {
            if (_restoring)
                return 1f;
            float value = PioneerSizePlugin.SpeedMultiplier != null ? PioneerSizePlugin.SpeedMultiplier.Value : 1f;
            return Mathf.Clamp(value, MinSpeed, MaxSpeed);
        }

        static void LogOnce(Exception ex)
        {
            if (_errors++ > 4 || PioneerSizePlugin.LogSource == null)
                return;
            PioneerSizePlugin.LogSource.LogError("PioneerSize failed to resize the player:\n" + ex);
        }
    }
}