using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Player : MonoBehaviour, IKitchenObjectParent
{
    public static Player Instance {  get; private set; }  // this is a property ( Singleton patern ), this makes is public to get from other classes but privet to set it.

    public event EventHandler<OnSelectedCounterChangedEventArgs> OnSelectedCounterChanged;
    public class OnSelectedCounterChangedEventArgs : EventArgs {
        public BaseCounter selectedCounter;
    }

    [SerializeField] private float moveSpeed = 7f;
    [SerializeField] private float rotateSpeed = 15f;
    [SerializeField] private GameInput gameInput;
    const string GAME_INPUT = "GameInput";
    [SerializeField] private LayerMask countersLayerMask;
    [SerializeField] private Transform kitchenObjectHoldPoint;

    private bool isWalking; // For the animaitor
    private Vector3 lastInteractDir;
    private BaseCounter selectedCounter;
    private KitchenObject kitchenObject;
    /// <summary>
    /// you do not want to define the move direction as a local variable because it won't work as good with the 
    /// move direction. So that is why it is defined twice.
    /// </summary>
    /// 
    private void Awake()
    {
        if(Instance != null)
        {
            Debug.LogError("THERE IS MORE THAN ONE PLAYER");
        }
        Instance = this;
        gameInput = GameObject.Find(GAME_INPUT).GetComponent<GameInput>();
    }

    private void Start()
    {
        gameInput.OnInteractAction += GameInput_OnInteractAction;
        gameInput.OnInteractAlternateAction += GameInput_OnInteractAlternateAction;
    }

    private void GameInput_OnInteractAlternateAction(object sender, EventArgs e)
    {
        if (selectedCounter != null)
        {
            selectedCounter.InteractAlternate(this);
        }
    }

    private void GameInput_OnInteractAction(object sender, System.EventArgs e)
    {
        if(selectedCounter != null)
        {
            selectedCounter.Interact(this);
        }
    }

    private void Update()
    {
        HandleMovement();
        HandleInteraction();
    }

    public bool IsWalking()
    {
        return isWalking;
    }
    private void HandleInteraction()
    {
        // Get the interact input from the InputSystem.
        Vector2 inputVector = gameInput.GetNormalizedMovementVector();
        // Put the input inside vector, to check which direction we are looking.
        Vector3 moveDir = new Vector3(inputVector.x, 0f, inputVector.y);

        if (moveDir != Vector3.zero) // We are moving
        {
            lastInteractDir = moveDir;
        }

        float interactDistance = 2f; // Define the interact distance ( We don't want to change this that is why it is defined here.)

        if (Physics.Raycast(transform.position, lastInteractDir, out RaycastHit raycastHit, interactDistance, countersLayerMask))// Returns a boolean if it hits something
        {
            if (raycastHit.transform.TryGetComponent(out BaseCounter baseCounter)) // Checks en try's to get the baseCounter componenet otherwise it returns null
            {
                // Has baseCounter
                if (baseCounter != selectedCounter)
                {
                    //Debug.Log("CLEARCOUNTER != SELECTEDCOUNTER");
                    SetSelectedCounter(baseCounter);
                }
            }
            else
            {
                SetSelectedCounter(null);
            }
        }
        else
        {
            SetSelectedCounter(null);
        }
    }
    private void HandleMovement()
    {
        // Get the move input via the new input system
        Vector2 inputVector = gameInput.GetNormalizedMovementVector();
        // Put the move input in a vector
        Vector3 moveDir = new Vector3(inputVector.x, 0f, inputVector.y); 
        // set value's we need in the Capsule Cast. We don't want to change these values that is why we define them here.
        float moveDistance = moveSpeed * Time.deltaTime;
        float playerRadius = .8f;
        float playerHeigth = 2f;
        // This checks if there is an obstacle in the way.
        bool canMove = !Physics.CapsuleCast(transform.position, transform.position + Vector3.up * playerHeigth, playerRadius, moveDir, moveDistance); 

        if (!canMove)
        {
            // Cannot move towards movedir, Try only X movement
            Vector3 moveDirX = new Vector3(moveDir.x, 0, 0).normalized;
            canMove = moveDir.x != 0 && !Physics.CapsuleCast(transform.position, transform.position + Vector3.up * playerHeigth, playerRadius, moveDirX, moveDistance);

            if (canMove)
            {
                // Can move only on the X
                moveDir = moveDirX;
            }
            else
            {
                // Cannot move on the X, Try only on Z movement
                Vector3 moveDirZ = new Vector3(0, 0, moveDir.z).normalized;
                canMove = moveDir.z != 0 && !Physics.CapsuleCast(transform.position, transform.position + Vector3.up * playerHeigth, playerRadius, moveDirZ, moveDistance);
                if (canMove)
                {
                    // Move only in the Z
                    moveDir = moveDirZ;
                }
                else
                {
                    // Can not move in any direction.
                }
            }
        }

        if (canMove)
        {
            transform.position += moveDir * moveDistance;
        }
        isWalking = moveDir != Vector3.zero;
        transform.forward = Vector3.Slerp(transform.forward, moveDir, Time.deltaTime * rotateSpeed); // Makes the player rotate smoothly
    }

    private void SetSelectedCounter(BaseCounter selectedCounter) // This fires of the event of the selected counter
    {
        this.selectedCounter = selectedCounter;
        OnSelectedCounterChanged?.Invoke(this, new OnSelectedCounterChangedEventArgs
        {
            selectedCounter = selectedCounter
        });

    }
    // This function returns the transfom that holds the object. (Hands position)
    public Transform GetKitchenObjectFollowTransform()
    {
        return kitchenObjectHoldPoint;
    }
    // This sets the grabbed object to player 'kitchenObjectHoldPoint' position
    public void SetKitchenObject(KitchenObject kitchenObject) // here you can place some animaton for grabbing!?
    {
        this.kitchenObject = kitchenObject;
    }

    public KitchenObject GetKitchenObject()
    {
        return kitchenObject;
    }
    public void ClearKitchenObject()
    {
        kitchenObject = null;
    }
    public bool HasKitchenObject()
    {
        return kitchenObject != null;
    }
}