using System;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.Windows;

public enum InputState { Started, Performing, Canceled }

public class InputManager : MonoBehaviour
{
    public static InputManager Instance;

    private PlayerInput _playerInput;
    private InputActionMap _globalInputActionMap;
    private InputActionMap _uiInputActionMap;
    private InputActionMap _characterInputActionMap;

    //콜백 이벤트들
    //캐릭터 조작관련은 따로 분류
    public event Action<float> OnMouseScrollEvent;
    public event Action<Vector2> OnMoveEvent;
    public event Action<InputState> OnSprintEvent;
    public event Action<InputState> OnJumpEvent;
    public event Action<InputState> OnAimToggleEvent;
    public event Action<Vector2> OnLookEvent;
    public event Action<InputState> OnDodgeEvent;
    public event Action OnNormalAttackEvent;
    public event Action OnHeavyAttackEvent;
    public event Action OnInteractionEvent;
    public event Action<InputState> OnKeyDown_SlotQEvent;
    public event Action<InputState> OnKeyDown_SlotEEvent;
    public event Action<InputState> OnKeyDown_SlotREvent;
    public event Action<InputState> OnKeyDown_SlotTEvent;
    public event Action<InputState> OnKeyDown_SlotFEvent;
    public event Action<InputState> OnKeyDown_SlotGEvent;
    public event Action<InputState> OnAreaConfirmEvent; // Remote 스킬 범위 확정

    // 범위 지정 중 기본 공격 차단용 플래그 (SkillModule이 제어)
    public bool SuppressNormalAttack { get; set; }


    //키조작
    public event Action OnKeyDown_UpArrowEvent;
    public event Action OnKeyDown_DownArrowEvent;
    public event Action OnKeyDown_EnterEvent;
    public event Action OnKeyDown_IKeyEvent;
    public event Action OnKeyDown_KKeyEvent;



    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this; //만들어진 자신을 인스턴스로 설정
        }
        else
        {
            Destroy(gameObject); //이미 인스턴스가 있으면 자신을 파괴
        }

        _playerInput = GetComponent<PlayerInput>();
    }

    private void Start()
    {
        SetGlobalInputMap("Global");
    }

    public void UnPairDevices()
    {
        if(_playerInput != null)
        {
            _playerInput.user.UnpairDevices();
            PlayerInputEnable(false);
        }
    }

    public void PlayerInputEnable(bool flag)
    {
        _playerInput.enabled = flag;
    }    

    private void SetGlobalInputMap(string mapName)
    {
        _globalInputActionMap = _playerInput?.actions?.FindActionMap(mapName);
    }

    public void SetUIInputMap(string mapName)
    {
        _uiInputActionMap = _playerInput?.actions?.FindActionMap(mapName);
        if (_uiInputActionMap == null) return;

        //바인딩
        BindActionUI("OnKeyDown_UpArrow", OnKeyDown_UpArrow);
        BindActionUI("OnKeyDown_DownArrow", OnKeyDown_DownArrow);
        BindActionUI("OnKeyDown_Enter", OnKeyDown_Enter);
        BindActionUI("OnkeyDown_IKey", OnKeyDown_IKey);
        BindActionUI("OnKeyDown_KKey", OnKeyDown_KKey);

        _uiInputActionMap.Disable();

    }

    public void SetCharacterInputMap(string mapName)
    {
        _characterInputActionMap = _playerInput?.actions?.FindActionMap(mapName);
        if (_characterInputActionMap == null) return;

        //바인딩
        BindActionCharacter("Scroll", OnMouseScroll);
        BindActionCharacter("Move", OnMove);
        BindActionCharacter("Sprint", OnSprint);
        BindActionCharacter("Jump", OnJump);
        BindActionCharacter("AimToggle", OnAimToggle);
        BindActionCharacter("Look", OnLook);
        BindActionCharacter("Dodge", OnDodge);
        BindActionCharacter("NormalAttack", OnNormalAttack);
        BindActionCharacter("HeavyAttack", OnHeavyAttack);

        //퀵슬롯은 하나의 메서드로 관리
        BindActionCharacter("UseSlot_Q",OnKeyDown_Slot);
        BindActionCharacter("UseSlot_E",OnKeyDown_Slot);
        BindActionCharacter("UseSlot_R",OnKeyDown_Slot);
        BindActionCharacter("UseSlot_T",OnKeyDown_Slot);
        BindActionCharacter("UseSlot_F",OnKeyDown_Slot);
        BindActionCharacter("UseSlot_G",OnKeyDown_Slot);

        BindActionCharacter("AreaConfirm", OnAreaConfirm);

        BindActionCharacter("Interaction", OnInteraction);

        BindActionCharacter("OnkeyDown_IKey", OnKeyDown_IKey);
        BindActionCharacter("OnKeyDown_KKey", OnKeyDown_KKey);
        

        _characterInputActionMap.Disable();

    }

    //매핑용 함수
    private void BindActionUI(string actionName, Action<InputAction.CallbackContext> callback)
    {
        InputAction action = _uiInputActionMap.FindAction(actionName);
        if (action != null)
        {
            action.performed -= callback;
            action.canceled -= callback;
            action.started -= callback;

            action.performed += callback;
            action.canceled += callback;
            action.started += callback;
        }
    }
    private void BindActionCharacter(string actionName, Action<InputAction.CallbackContext> callback)
    {
        InputAction action = _characterInputActionMap.FindAction(actionName);
        if (action != null)
        {
            action.performed -= callback;
            action.canceled -= callback;
            action.started -= callback;

            action.performed += callback;
            action.canceled += callback;
            action.started += callback;
        }
    }

    public void ActiveOnlyOneActionMap(string actionMapName)
    {
        _playerInput.SwitchCurrentActionMap(actionMapName);
    }

    #region 캐릭터 조작
    private void OnMouseScroll(InputAction.CallbackContext ctx)
    {
        Vector2 scroll = ctx.ReadValue<Vector2>();
        OnMouseScrollEvent?.Invoke(scroll.y);
    }

    private void OnMove(InputAction.CallbackContext ctx)
    {
        Vector2 move = ctx.ReadValue<Vector2>();
        OnMoveEvent?.Invoke(move);
    }

    private void OnSprint(InputAction.CallbackContext ctx)
    {
        if(ctx.performed)
        {
            OnSprintEvent?.Invoke(InputState.Performing);
        } 

        if(ctx.canceled)
        {
            OnSprintEvent?.Invoke(InputState.Canceled);
        }
    }

    private void OnJump(InputAction.CallbackContext ctx)
    {
        if(ctx.started)
        {
            OnJumpEvent?.Invoke(InputState.Started);
        }

        if (ctx.canceled)
        {
            OnJumpEvent?.Invoke(InputState.Canceled);
        }
    }
    private void OnAimToggle(InputAction.CallbackContext ctx)
    {
        if (ctx.started)
        {
            OnAimToggleEvent?.Invoke(InputState.Started);
        }
    }
    private void OnLook(InputAction.CallbackContext ctx)
    {
        Vector2 look = ctx.ReadValue<Vector2>();
        OnLookEvent?.Invoke(look);
    }

    private void OnDodge(InputAction.CallbackContext ctx)
    {
        if(ctx.started)
        {
            OnDodgeEvent?.Invoke(InputState.Started);
        }
    }

    private void OnNormalAttack(InputAction.CallbackContext ctx)
    {
        if (SuppressNormalAttack) return;
        OnNormalAttackEvent?.Invoke();
    }

    private void OnHeavyAttack(InputAction.CallbackContext ctx)
    {
        OnHeavyAttackEvent?.Invoke();
    }

    private void OnInteraction(InputAction.CallbackContext ctx)
    {
        if (ctx.started)
            OnInteractionEvent?.Invoke();
    }

    private void OnAreaConfirm(InputAction.CallbackContext ctx)
    {
        if (ctx.started)
            OnAreaConfirmEvent?.Invoke(InputState.Started);
    }

    private void OnKeyDown_Slot(InputAction.CallbackContext ctx)
    {
        if (ctx.started)
        {
            if (ctx.action.name == "UseSlot_Q")
            {
                OnKeyDown_SlotQEvent?.Invoke(InputState.Started);
            }
            else if (ctx.action.name == "UseSlot_E")
            {
                OnKeyDown_SlotEEvent?.Invoke(InputState.Started);
            }
            else if (ctx.action.name == "UseSlot_R")
            {
                OnKeyDown_SlotREvent?.Invoke(InputState.Started);
            }
            else if (ctx.action.name == "UseSlot_T")
            {
                OnKeyDown_SlotTEvent?.Invoke(InputState.Started);
            }
            else if (ctx.action.name == "UseSlot_F")
            {
                OnKeyDown_SlotFEvent?.Invoke(InputState.Started);
            }
            else if (ctx.action.name == "UseSlot_G")
            {
                OnKeyDown_SlotGEvent?.Invoke(InputState.Started);
            }
        }
    }
    #endregion

    #region 키별 조작
    private void OnKeyDown_UpArrow(InputAction.CallbackContext ctx)
    {
        if(ctx.started)
            OnKeyDown_UpArrowEvent?.Invoke();
    }

    private void OnKeyDown_DownArrow(InputAction.CallbackContext ctx)
    {
        if (ctx.started)
            OnKeyDown_DownArrowEvent?.Invoke();
    }

    private void OnKeyDown_Enter(InputAction.CallbackContext ctx)
    {
        if (ctx.started)
            OnKeyDown_EnterEvent?.Invoke();
    }

    private void OnKeyDown_IKey(InputAction.CallbackContext ctx)
    {
        if(ctx.started)
            OnKeyDown_IKeyEvent?.Invoke();
    }

    private void OnKeyDown_KKey(InputAction.CallbackContext ctx)
    {
        if (ctx.started)
            OnKeyDown_KKeyEvent?.Invoke();
    }
    #endregion
}