using UnityEngine;
using UnityEngine.InputSystem;
using Unheimlich.Core;
using Unheimlich.Gameplay.Player;

namespace Unheimlich.Managers
{
    /// <summary>
    /// Centralizes Input System handling for the player.
    /// Manages input state, action references, and global input enable/disable functionality.
    /// Supports different input contexts (Normal, Dialogue, Listening) to control which inputs are active.
    /// </summary>
    [RequireComponent(typeof(PlayerInput))]
    public class PlayerInputManager : Singleton<PlayerInputManager>
    {
        /// <summary>
        /// Defines different input contexts that control which player actions are enabled.
        /// </summary>
        public enum InputContext
        {
            Normal,      // All inputs enabled (movement, look, jump, interact, diapason)
            Dialogue,    // Only look and interact enabled (for dialogues/UI)
            Listening    // Only look enabled, movement disabled (for diapason camera pan)
        }

    [Header("Input Values (Read only)")]
    public Vector2 MoveInput; 
    public Vector2 LookInput; 
    
    public static bool IsInputEnabled { get; private set; } = true; 
    public static bool IsLookingEnabled { get; private set; } = true;
    public static InputContext CurrentContext { get; private set; } = InputContext.Normal;

    private InputActionMap _playerActionMap;
    private InputAction _moveAction;
    private InputAction _lookAction;
    private InputAction _jumpAction;
    private InputAction _interactAction;
    private InputAction _diapasonAction;
    private InputAction _fireAction;
    private InputAction _exitAction;

    private PlayerMovement _playerMovement;
    private PlayerLook _playerLook;
    private CameraHeadBob _headBob;

    protected override void OnAwake()
    {
        IsInputEnabled = true;
        
        PlayerInput playerInput = GetComponent<PlayerInput>();
        playerInput.actions.Enable();
        
        _playerActionMap = playerInput.actions.FindActionMap("Player");
        _moveAction = _playerActionMap.FindAction("Move");
        _lookAction = _playerActionMap.FindAction("Look");
        _jumpAction = _playerActionMap.FindAction("Jump");
        _interactAction = _playerActionMap.FindAction("Interact");
        _diapasonAction = _playerActionMap.FindAction("Diapason");
        _fireAction = _playerActionMap.FindAction("Fire");
        _exitAction = _playerActionMap.FindAction("Exit");

        _playerMovement = GetComponent<PlayerMovement>();
        _playerLook = GetComponent<PlayerLook>();
        _headBob = GetComponentInChildren<CameraHeadBob>();
    }

    /// <summary>
    /// Sets the input context, controlling which inputs and player components are active.
    /// </summary>
    public static void SetContext(InputContext context)
    {
        if (Instance == null) return;

        CurrentContext = context;

        switch (context)
        {
            case InputContext.Normal:
                Instance._playerActionMap.Enable();
                Instance.SetComponentsEnabled(true, true, true);
                IsInputEnabled = true;
                IsLookingEnabled = true;
                Cursor.lockState = CursorLockMode.Locked;
                Cursor.visible = false;
                break;

            case InputContext.Dialogue:
                Instance._playerActionMap.Disable();
                Instance._lookAction.Enable();
                Instance._interactAction.Enable();
                if (Instance._diapasonAction != null)
                    Instance._diapasonAction.Enable();
                Instance.SetComponentsEnabled(false, false, false);
                IsInputEnabled = false;
                IsLookingEnabled = false;
                break;

            case InputContext.Listening:
                Instance._playerActionMap.Disable();
                Instance._lookAction.Enable();
                if (Instance._diapasonAction != null)
                    Instance._diapasonAction.Enable();
                if (Instance._fireAction != null)
                    Instance._fireAction.Enable();
                if (Instance._exitAction != null)
                    Instance._exitAction.Enable();
                Instance.SetComponentsEnabled(false, false, true);
                IsInputEnabled = false;
                IsLookingEnabled = false;
                break;
        }
    }

    /// <summary>
    /// Enables or disables player movement components.
    /// </summary>
    private void SetComponentsEnabled(bool movement, bool look, bool headBob)
    {
        if (_playerMovement != null)
            _playerMovement.enabled = movement;
        if (_playerLook != null)
            _playerLook.enabled = look;
        if (_headBob != null)
            _headBob.enabled = headBob;
    }

    /// <summary>
    /// Globally toggles player input on/off. When disabled, only look and interact actions remain active.
    /// Used during dialogues, inspections, or UI interactions.
    /// LEGACY: Use SetContext(InputContext.Dialogue) instead.
    /// </summary>
    public static void ToggleInput(bool enable) 
    {
        SetContext(enable ? InputContext.Normal : InputContext.Dialogue);
    }
    
    public void OnMove(InputAction.CallbackContext context)
    {
        MoveInput = context.ReadValue<Vector2>(); 
    }

    public void Look(InputAction.CallbackContext context)
    {
        LookInput = context.ReadValue<Vector2>(); 
    }

    public void OnJump(InputAction.CallbackContext context)
    {
    }

    public void OnInteract(InputAction.CallbackContext context)
    {
    }

    public void OnDiapason(InputAction.CallbackContext context)
    {
    }
    
    public void OnFire(InputAction.CallbackContext context)
    {
    }
    
    public void OnExit(InputAction.CallbackContext context)
    {
    }
    
    /// <summary>
    /// Provides public access to input actions for other systems.
    /// </summary>
    public static InputAction GetMoveAction() => Instance?._moveAction;
    public static InputAction GetLookAction() => Instance?._lookAction;
    public static InputAction GetJumpAction() => Instance?._jumpAction;
    public static InputAction GetInteractAction() => Instance?._interactAction;
    public static InputAction GetDiapasonAction() => Instance?._diapasonAction;
    public static InputAction GetFireAction() => Instance?._fireAction;
    public static InputAction GetExitAction() => Instance?._exitAction;
}
}