PlayerMovement

using _FDP_;
using System.Security.Cryptography;
using UnityEngine;

/// P: Player
[RequireComponent(typeof(Rigidbody))]
public class P_Movement_Control : FDP_UpdatingControl_Base {
    #region Variables
    private SP_Input_Control input_c;
    private P_Sprint_Control sprint_c;
    private P_Attack_Control attack_c;

    public Rigidbody body;
    public Transform camAnchor_tf;
    public Animator animator;

    public float moveSmoothTime = 0.25f;
    Vector3 vecVelocity = Vector3.zero;
    float fVelocity = 0f;

    public float rotationSmoothTime = 0.05f;
    Vector3 rotVecVelocity = Vector3.zero;
    float rotFVelocity = 0f;

    public float speed = 5f;
    /// jelenleg a soundEffects_c-ben használjuk
    public bool isMoving;

    /// A játékos lehetséges állapotai a mozgás vezérléséhez.
    public enum MovementState {
        Normal,    // Normál mozgás input alapján
        Attack,    // Támadás közbeni állapot
        Falling,   // Leesés közbeni korlátozott mozgás
        Interact   // Interakciós (pl. beszélgetés, elemek kezelése)
    }
    [SerializeField] private MovementState movementState  = MovementState.Normal;

    [Header("Ground Check beállítások")]
    public Transform groundCheck;       // Az üres GameObject (lábaid magasságában)
    public float groundDistance = 0.2f;  // Raycast félátmérő
    public LayerMask groundMask;        // Talaj réteg
    [SerializeField] private bool isGrounded; // Változó

    [Space(5)]
    [Header("DEBUG")]

    private FDP_DelegateVConnector<float> fdpDlgt_SpeedMultiplierChange;
    private float actualSpeed;
    #endregion

    #region Setup
    protected void PreSetup(P_Master_Control playerMaster_c) {
        input_c = SP_Input_Control.instance;
        sprint_c = GetComponent<P_Sprint_Control>();
        attack_c = playerMaster_c.attack_c;

        body = GetComponent<Rigidbody>();

        camAnchor_tf = playerMaster_c.camera_c.transform;

        actualSpeed = speed;

        fdpDlgt_SpeedMultiplierChange = new FDP_DelegateVConnector<float>(
            this, SpeedMultiplierChanged, $"P_Sprint_Control:OnSpeedMultiplierChange"
        );
    }
    protected override void PreSetup() {
        throw FDP_ErrorHandler.NewError(
            $"QCSERROR: P_Movement_Control:PreSetup: Használd a PreSetup(Transform camAnchorTransform) függvényt!" +
            "\nA PreSetup függvényt a P_Master_Control paraméterrel kell meghívni." +
            "\nEllenőrizd, hogy a megfelelő master script megfelelően inicializálja ezt a komponenst."
        );
    }

    public void Setup(
        P_Master_Control playerMaster_c
    ) {
        if (debugLog) Debug.Log($"{this}.Setup...");

        PreSetup(playerMaster_c);

        CheckPreSetupOk();

        sprint_c.OnSpeedMultiplierChange.Add(fdpDlgt_SpeedMultiplierChange);

        setupDone = true;
        enabled = setupDone;
        if (debugLog) Debug.Log($"{this}:Setup done\n");
    }

    public override void Setup() {
        throw FDP_ErrorHandler.NewError(
            $"QCSERROR: P_Movement_Control: Setup() nem hívható meg paraméter nélkül!" +
            "\nA Setup függvényt a P_Master_Control paraméterrel kell meghívni." +
            "\nEllenőrizd, hogy a megfelelő master script megfelelően inicializálja ezt a komponenst."
        );
    }
    #endregion

    #region Updates
    private Vector3 lastLookDirection = Vector3.zero;
    void FixedUpdate() {

        // 1) Talajdetekció (GroundCheck)
        GroundCheck();

        // 2) Falling státusz ellenőrzése
        CheckFalling();

        // 3) State switch – minden állapotot külön metódusban kezelünk
        switch (movementState) {
            case MovementState.Normal:
                MovementStateNormal_Settings();   // Ha a Játékos állapot nélküli akkor a Freeze ki kapcsolva
                break;

            case MovementState.Attack:
                MovementStateAttack_Settings();   // Ha a Játékos attackol akkor a mozgás Freezelve van!
                break;

            case MovementState.Falling:
                MovementStateFalling_Settings();  // Ha a Játékos valahonnan leseik, az riányitás kikapcsol de a mozgás direction megmarad gravitációval
                break;

            case MovementState.Interact:
                //body.velocity = new Vector3(0f, body.velocity.y, 0f);
                break;
        }
        // Ez felel a teljes forgás/irányításért! [Eredeti változtatások nélkül]
        BaseMovementControll();
    }

    void Update() {
        float animSpeed = (movementState == MovementState.Falling)? 0f: body.velocity.magnitude;
        animator.SetFloat("velocity", animSpeed);
    }
    #endregion

    //EXTRA SPEEDET A BUFFBOL BEKOTNI
    #region Functions
    private void SpeedMultiplierChanged(float spendMultiplier) {
        if (debugLog) Debug.Log($"SpeedMultiplierChanged {spendMultiplier}");
        actualSpeed = speed * spendMultiplier;
    }

    public void ChangeMovementState(MovementState newState) {
        this.movementState = newState;
    }

    //================Player Mozgás Logika===========\\
    //Normál Mozgás

    private void BaseMovementControll()
    {
        if (movementState == MovementState.Falling || !isGrounded)
            return;

        if (input_c.horizontalInput != 0 || input_c.verticalInput != 0) {
            isMoving = true;
            Vector3 moveDirection = new Vector3(input_c.horizontalInput, 0, input_c.verticalInput);
            // maximalizáljuk a mozgás irány vektor hosszát 1-re
            moveDirection = Vector3.ClampMagnitude(moveDirection, 1);

            // a camAnchor és a saját transform elforgatása alapján a kamera, talajra vetített irányvektorát használjuk
            float camAngle = camAnchor_tf.eulerAngles.y;
            moveDirection = Quaternion.Euler(0, camAngle, 0) * moveDirection;

            // Preserve the current velocity's y-component (gravity effect)
            Vector3 velocity = body.velocity;
            velocity.x = actualSpeed * moveDirection.x;
            velocity.z = actualSpeed * moveDirection.z;
            body.velocity = velocity;

            if (moveDirection != Vector3.zero) {
                // a moveDirection-ra apply-olunk egy elfordulást, hogy a karakter ne instant forduljon a mozgás irányába
                moveDirection = Vector3.SmoothDamp(
                    transform.forward,
                    moveDirection.normalized,
                    ref rotVecVelocity,
                    rotationSmoothTime
                );
                // a karakter elfordulása a mozgás irányába az y tengely körül
            }

            lastLookDirection = attack_c.attackDirection != Vector3.zero ?
                attack_c.attackDirection.normalized :
                moveDirection;
        }
        else if (attack_c.attackDirection != Vector3.zero) {
            isMoving = false;

            // a attackDirection-ra apply-olunk egy elfordulást,
            // hogy a karakter ne instant forduljon a támadás irányába
            lastLookDirection = Vector3.SmoothDamp(
                transform.forward,
                attack_c.attackDirection.normalized,
                ref rotVecVelocity,
                rotationSmoothTime
            );
        } else {
            isMoving = false;
        }

        if (lastLookDirection != Vector3.zero) {
            transform.rotation = Quaternion.LookRotation(lastLookDirection);
        }
    }

    private void GroundCheck() {
        // Talajon vagyok-e?
        isGrounded = Physics.CheckSphere(
            groundCheck.position,
            groundDistance,
            groundMask
        );
    }

    private void CheckFalling()
    {
        //Ha nem Falling & és nem grounded
        if (!isGrounded && movementState != MovementState.Falling)
        {
            //TODO: Változtassa meg a Movement state-t Falling-ra
            ChangeMovementState(MovementState.Falling);

            //Animáció lejátszása
        }
        else if (isGrounded && movementState == MovementState.Falling) {
            ChangeMovementState(MovementState.Normal);
        }
    }

    private void MovementStateNormal_Settings()
    {
        // Vedd le a FreezePositionX és FreezePositionZ zászlókat
        body.constraints &= ~(RigidbodyConstraints.FreezePositionX | RigidbodyConstraints.FreezePositionZ);
    }

    private void MovementStateAttack_Settings()
    {
        body.velocity = new Vector3(0f, body.velocity.y, 0f);

        // constraints: csak pozíció X/Z és X-Z forgás tiltása
        body.constraints = RigidbodyConstraints.FreezePositionX
                         | RigidbodyConstraints.FreezePositionZ
                         | RigidbodyConstraints.FreezeRotationX
                         | RigidbodyConstraints.FreezeRotationZ;
    }

    private void MovementStateFalling_Settings()
    {
        // Falling: horizontális velocity megtartása, gravitáció-t a RigidBody Use Gravity kezeli
        // lastLookDirection már BaseMovementControll beállítódott, amikor Falling-olunk
        Vector3 horizontalVelocity = lastLookDirection.normalized * actualSpeed;

        body.velocity = new Vector3(
                horizontalVelocity.x,
                body.velocity.y,    // gravitáció továbbra is hat
                horizontalVelocity.z
         );
    }

    #endregion

    #region Checks
    protected override void CheckPreSetupOk() {
        if (!input_c) {
            throw FDP_ErrorHandler.NewError(
                $"QCSERROR: input_c HIÁNYZIK! Character_Control:{this}" +
                "\nAz Input Control singleton nem található." +
                "\nEllenőrizd, hogy az SP_Input_Control megfelelően inicializálva van-e a játékban."
            );
        }
        if (!body) {
            throw FDP_ErrorHandler.NewError(
                $"QCSERROR: body HIÁNYZIK! Character_Control:{this}" +
                "\nA Rigidbody komponens nem található a GameObject-en." +
                "\nEllenőrizd, hogy a RequireComponent attribútum megfelelően működik-e."
            );
        }
        if (!camAnchor_tf) {
            throw FDP_ErrorHandler.NewError(
                $"QCSERROR: camAnchor_tf HIÁNYZIK! Character_Control:{this}" +
                "\nA kamera anchor Transform nem található." +
                "\nEllenőrizd, hogy a P_Master_Control megfelelően be van állítva és tartalmazza a camera_c referenciát."
            );
        }
        if (!animator) {
            throw FDP_ErrorHandler.NewError(
                $"QCSERROR: animator HIÁNYZIK! Character_Control:{this}" +
                "\nAz Animator komponens nincs beállítva." +
                "\nHúzd be a megfelelő Animator komponenst az Inspectorban."
            );
        }
        if (speed <= 0) {
            throw FDP_ErrorHandler.NewError(
                $"QCSERROR: speed <= 0! Character_Control:{this}" +
                "\nA mozgás sebességnek nagyobbnak kell lennie 0-nál." +
                "\nÁllítsd be a megfelelő értéket az Inspectorban."
            );
        }
    }
    #endregion
}