using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Service;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Serialization;

namespace Convai.Scripts.Utils
{
    // STEP 1: Add the enum for your custom action here. 
    public enum ActionChoice
    {
        None,
        Jump,
        Crouch,
        MoveTo,
        PickUp,
        Drop,
        OpenWeb
    }

    /// <summary>
    ///     DISCLAIMER: The action API is in experimental stages and can misbehave. Meanwhile, feel free to try it out and play
    ///     around with it.
    /// </summary>
    [DisallowMultipleComponent]
    [AddComponentMenu("Convai/Convai Actions Handler")]
    [HelpURL(
        "https://docs.convai.com/api-docs/plugins-and-integrations/unity-plugin/scripts-overview/convaiactionshandler.cs")]
    public class ConvaiActionsHandler : MonoBehaviour
    {
        [SerializeField] public ActionMethod[] actionMethods;
        public List<string> actionResponseList = new();
        private readonly List<ConvaiAction> _actionList = new();
        public readonly ActionConfig ActionConfig = new();
        private List<string> _actions = new();
        private ConvaiNPC _currentNPC;
        private ConvaiInteractablesData _interactablesData;

        // Awake is called when the script instance is being loaded
        private void Awake()
        {
            // Find the global action settings object in the scene
            _interactablesData = FindObjectOfType<ConvaiInteractablesData>();

            // Check if the global action settings object is missing
            if (_interactablesData == null)
                // Log an error message to indicate missing Convai Action Settings
                Logger.Error("Convai Action Settings missing. Please create a game object that handles actions.",
                    Logger.LogCategory.Character);

            // Check if this GameObject has a ConvaiNPC component attached
            if (TryGetComponent(out ConvaiNPC npc))
                // If it does, set the current NPC to this GameObject
                _currentNPC = npc;


            // Iterate through each action method and add its name to the action configuration
            foreach (ActionMethod actionMethod in actionMethods) ActionConfig.Actions.Add(actionMethod.action);

            if (_interactablesData != null)
            {
                // Iterate through each character in global action settings and add them to the action configuration
                foreach (ConvaiInteractablesData.Character character in _interactablesData.Characters)
                {
                    ActionConfig.Types.Character rpcCharacter = new()
                    {
                        Name = character.Name,
                        Bio = character.Bio
                    };

                    ActionConfig.Characters.Add(rpcCharacter);
                }

                // Iterate through each object in global action settings and add them to the action configuration
                foreach (ConvaiInteractablesData.Object eachObject in _interactablesData.Objects)
                {
                    ActionConfig.Types.Object rpcObject = new()
                    {
                        Name = eachObject.Name,
                        Description = eachObject.Description
                    };
                    ActionConfig.Objects.Add(rpcObject);
                }
            }
        }

        private void Reset()
        {
            actionMethods = new ActionMethod[]
            {
                new() { action = "Move To", actionChoice = ActionChoice.MoveTo },
                new() { action = "Pick Up", actionChoice = ActionChoice.PickUp },
                new() { action = "Dance", animationName = "Dance", actionChoice = ActionChoice.None },
                new() { action = "Drop", actionChoice = ActionChoice.Drop },
                new() { action = "Jump", actionChoice = ActionChoice.Jump }
            };
        }

        // Start is called before the first frame update
        private void Start()
        {
            // Set up the action configuration

            #region Actions Setup

            // Set the classification of the action configuration to "multistep"
            ActionConfig.Classification = "multistep";

            // Log the configured action information
            Logger.DebugLog(ActionConfig, Logger.LogCategory.Actions);

            #endregion

            // Start playing the action list using a coroutine
            StartCoroutine(PlayActionList());
        }

        private void Update()
        {
            if (actionResponseList.Count > 0)
            {
                ParseActions(actionResponseList[0]);
                actionResponseList.RemoveAt(0);
            }
        }

        public void ParseActions(string actionsString)
        {
            // Trim the input string to remove leading and trailing spaces
            actionsString = actionsString.Trim();
            Logger.DebugLog($"Parsing actions from: {actionsString}", Logger.LogCategory.Actions);

            // Split the trimmed actions string into a list of individual actions
            _actions = new List<string>(actionsString.Split(", "));

            // Iterate through each action in the list of actions
            foreach (List<string> actionWords in _actions.Select(t => new List<string>(t.Split(" "))))
                // Iterate through the words in the current action
            {
                Logger.Info(
                    $"Processing action: {string.Join(" ", actionWords)}",
                    Logger.LogCategory.Actions); // Info: Checking each action being processed
                for (int j = 0; j < actionWords.Count; j++)
                {
                    // Separate the words into two parts: verb and object
                    string[] tempString1 = new string[j + 1];
                    string[] tempString2 = new string[actionWords.Count - j - 1];

                    Array.Copy(actionWords.ToArray(), tempString1, j + 1);
                    Array.Copy(actionWords.ToArray(), j + 1, tempString2,
                        0, actionWords.Count - j - 1);

                    // Check if any verb word ends with "s" and remove it
                    for (int k = 0; k < tempString1.Length; k++)
                        if (tempString1[k].EndsWith("s"))
                            tempString1[k] = tempString1[k].Remove(tempString1[k].Length - 1);

                    // Iterate through each defined Convai action
                    foreach (ActionMethod convaiAction in actionMethods)
                        // Check if the parsed verb matches any defined action
                        if (string.Equals(convaiAction.action, string.Join(" ", tempString1),
                                StringComparison.CurrentCultureIgnoreCase))
                        {
                            GameObject tempGameObject = null;

                            // Iterate through each object in global action settings to find a match
                            foreach (ConvaiInteractablesData.Object @object in _interactablesData.Objects)
                                if (string.Equals(@object.Name, string.Join(" ", tempString2),
                                        StringComparison.CurrentCultureIgnoreCase))
                                {
                                    Logger.DebugLog($"Active Target: {string.Join(" ", tempString2).ToLower()}",
                                        Logger.LogCategory.Actions);
                                    tempGameObject = @object.gameObject;
                                }

                            // Iterate through each character in global action settings to find a match
                            foreach (ConvaiInteractablesData.Character character in _interactablesData.Characters)
                                if (string.Equals(character.Name, string.Join(" ", tempString2),
                                        StringComparison.CurrentCultureIgnoreCase))
                                {
                                    Logger.DebugLog($"Active Target: {string.Join(" ", tempString2).ToLower()}",
                                        Logger.LogCategory.Actions);
                                    tempGameObject = character.gameObject;
                                }

                            if (tempGameObject != null)
                                Logger.DebugLog(
                                    $"Found matching target: {tempGameObject.name} for action: {string.Join(" ", tempString1).ToLower()}",
                                    Logger.LogCategory.Actions); // DebugLog: For successful matching
                            else
                                Logger.Warn(
                                    $"No matching target found for action: {string.Join(" ", tempString1).ToLower()}",
                                    Logger.LogCategory.Actions); // Warning: When expected matches aren't found

                            // Add the parsed action to the action list
                            _actionList.Add(new ConvaiAction(convaiAction.actionChoice, tempGameObject,
                                convaiAction.animationName));

                            break; // Break the loop as the action is found
                        }
                }
            }
        }

        /// <summary>
        ///     Event that is triggered when an action starts.
        /// </summary>
        /// <remarks>
        ///     This event can be subscribed to in order to perform custom logic when an action starts.
        ///     The event provides the name of the action and the GameObject that the action is targeting.
        /// </remarks>
        public event Action<string, GameObject> ActionStarted;

        /// <summary>
        ///     Event that is triggered when an action ends.
        /// </summary>
        /// <remarks>
        ///     This event can be subscribed to in order to perform custom logic when an action ends.
        ///     The event provides the name of the action and the GameObject that the action was targeting.
        /// </remarks>
        public event Action<string, GameObject> ActionEnded;

        /// <summary>
        ///     This coroutine handles playing the actions in the action list.
        /// </summary>
        /// <returns></returns>
        private IEnumerator PlayActionList()
        {
            while (true)
                // Check if there are actions in the action list
                if (_actionList.Count > 0)
                {
                    // Call the DoAction function for the first action in the list and wait until it's done
                    yield return DoAction(_actionList[0]);

                    // Remove the completed action from the list
                    _actionList.RemoveAt(0);
                }
                else
                {
                    // If there are no actions in the list, yield to wait for the next frame
                    yield return null;
                }
        }

        private IEnumerator DoAction(ConvaiAction action)
        {
            // STEP 2: Add the function call for your action here corresponding to your enum.
            //         Remember to yield until its return if it is a Enumerator function.

            // Use a switch statement to handle different action choices based on the ActionChoice enum
            switch (action.Verb)
            {
                case ActionChoice.MoveTo:
                    // Call the MoveTo function and yield until it's completed
                    yield return MoveTo(action.Target);
                    break;

                case ActionChoice.PickUp:
                    // Call the PickUp function and yield until it's completed
                    yield return PickUp(action.Target);
                    break;

                case ActionChoice.Drop:
                    // Call the Drop function
                    Drop(action.Target);
                    break;

                case ActionChoice.Jump:
                    // Call the Jump function
                    Jump();
                    break;

                case ActionChoice.Crouch:
                    // Call the Crouch function and yield until it's completed
                    yield return Crouch();
                    break;

                case ActionChoice.None:
                    // Call the AnimationActions function and yield until it's completed
                    yield return AnimationActions(action.Animation);
                    break;

                case ActionChoice.OpenWeb:
                    OpenWebsite();
                    break;
            }

            // Yield once to ensure the coroutine advances to the next frame
            yield return null;
        }

        private void OpenWebsite()
        {
            // Specify the URL you want to open
            string url = "https://www.convai.com";

            // Use Application.OpenURL to open the web page
            Application.OpenURL(url);
        }

        /// <summary>
        ///     This method is a coroutine that handles playing an animation for Convai NPC.
        ///     The method takes in the name of the animation to be played as a string parameter.
        /// </summary>
        /// <param name="animationName"> The name of the animation to be played. </param>
        /// <returns> A coroutine that plays the animation. </returns>
        private IEnumerator AnimationActions(string animationName)
        {
            // Logging the action of initiating the animation with the provided animation name.
            Logger.DebugLog("Doing animation: " + animationName, Logger.LogCategory.Actions);

            // Attempting to get the Animator component attached to the current NPC object.
            // The Animator component is responsible for controlling animations on the GameObject.
            Animator animator = _currentNPC.GetComponent<Animator>();

            // Converting the provided animation name to its corresponding hash code.
            // This is a more efficient way to refer to animations and Animator states.
            int animationHash = Animator.StringToHash(animationName);

            // Check if the Animator component has a state with the provided hash code.
            // This is a safety check to prevent runtime errors if the animation is not found.
            if (!animator.HasState(0, animationHash))
            {
                // Logging a message to indicate that the animation was not found.
                Logger.DebugLog("Could not find an animator state named: " + animationName, Logger.LogCategory.Actions);

                // Exiting the coroutine early since the animation is not available.
                yield break;
            }

            // Playing the animation with a cross-fade transition.
            // The second parameter '0.1f' specifies the duration of the cross-fade.
            animator.CrossFadeInFixedTime(animationHash, 0.1f);

            // Waiting for a short duration (just over the cross-fade time) to allow the animation transition to start.
            // This ensures that subsequent code runs after the animation has started playing.
            yield return new WaitForSeconds(0.11f);

            // Getting information about the current animation clip that is playing.
            AnimatorClipInfo[] clipInfo = animator.GetCurrentAnimatorClipInfo(0);

            // Checking if there is no animation clip information available.
            if (clipInfo == null || clipInfo.Length == 0)
            {
                // Logging a message to indicate that there are no animation clips associated with the state.
                Logger.DebugLog("Animator state named: " + animationName + " has no associated animation clips",
                    Logger.LogCategory.Actions);

                // Exiting the coroutine as there is no animation to play.
                yield break;
            }

            // Defining variables to store the length and name of the animation clip.
            float length = 0;
            string animationClipName = "";

            // Iterating through the array of animation clips to find the one that is currently playing.
            foreach (AnimatorClipInfo clipInf in clipInfo)
            {
                // Logging the name of the animation clip for debugging purposes.
                Logger.DebugLog("Clip name: " + clipInf.clip.name, Logger.LogCategory.Actions);

                // Storing the current animation clip in a local variable for easier access.
                AnimationClip clip = clipInf.clip;

                // Checking if the animation clip is valid.
                if (clip != null)
                {
                    // Storing the length and name of the animation clip.
                    length = clip.length;
                    animationClipName = clip.name;

                    // Exiting the loop as we've found the information we need.
                    break;
                }
            }

            // Checking if a valid animation clip was found.
            if (length > 0.0f)
            {
                // Logging a message indicating that the animation is now playing.
                Logger.DebugLog(
                    "Playing the animation " + animationClipName + " from the Animator State " + animationName +
                    " for " + length + " seconds", Logger.LogCategory.Actions);

                // Waiting for the duration of the animation to allow it to play out.
                yield return new WaitForSeconds(length);
            }
            else
            {
                // Logging a message to indicate that no valid animation clips were found or their length was zero.
                Logger.DebugLog(
                    "Animator state named: " + animationName +
                    " has no valid animation clips or they have a length of 0", Logger.LogCategory.Actions);

                // Exiting the coroutine early.
                yield break;
            }

            // Transitioning back to the idle animation.
            // It is assumed that an "Idle" animation exists and is set up in your Animator Controller.
            animator.CrossFadeInFixedTime(Animator.StringToHash("Idle"), 0.1f);

            // Yielding to wait for one frame to ensure that the coroutine progresses to the next frame.
            // This is often done at the end of a coroutine to prevent issues with Unity's execution order.
            yield return null;
        }

        /// <summary>
        ///     Registers the provided methods to the ActionStarted and ActionEnded events.
        ///     This allows external code to subscribe to these events and react when they are triggered.
        /// </summary>
        /// <param name="onActionStarted">
        ///     The method to be called when an action starts. It should accept a string (the action
        ///     name) and a GameObject (the target of the action).
        /// </param>
        /// <param name="onActionEnded">
        ///     The method to be called when an action ends. It should accept a string (the action name)
        ///     and a GameObject (the target of the action).
        /// </param>
        public void RegisterForActionEvents(Action<string, GameObject> onActionStarted,
            Action<string, GameObject> onActionEnded)
        {
            ActionStarted += onActionStarted;
            ActionEnded += onActionEnded;
        }

        /// <summary>
        ///     Unregisters the provided methods from the ActionStarted and ActionEnded events.
        ///     This allows external code to unsubscribe from these events when they are no longer interested in them.
        /// </summary>
        /// <param name="onActionStarted">
        ///     The method to be removed from the ActionStarted event. It should be the same method that
        ///     was previously registered.
        /// </param>
        /// <param name="onActionEnded">
        ///     The method to be removed from the ActionEnded event. It should be the same method that was
        ///     previously registered.
        /// </param>
        public void UnregisterForActionEvents(Action<string, GameObject> onActionStarted,
            Action<string, GameObject> onActionEnded)
        {
            ActionStarted -= onActionStarted;
            ActionEnded -= onActionEnded;
        }

        [Serializable]
        public class ActionMethod
        {
            [FormerlySerializedAs("Action")] [SerializeField]
            public string action;

            // feels unnecessary 
            // [SerializeField] public ActionType actionType;
            [SerializeField] public string animationName;
            [SerializeField] public ActionChoice actionChoice;
        }

        private class ConvaiAction
        {
            public ConvaiAction(ActionChoice verb, GameObject target, string animation)
            {
                Verb = verb;
                Target = target;
                Animation = animation;
            }

            #region 04. Public variables

            public readonly string Animation;
            public readonly GameObject Target;
            public readonly ActionChoice Verb;

            #endregion
        }

        // STEP 3: Add the function for your action here.

        #region Action Implementation Methods

        private IEnumerator Crouch()
        {
            ActionStarted?.Invoke("Crouch", _currentNPC.gameObject);
            Logger.DebugLog("Crouching!", Logger.LogCategory.Actions);
            Animator animator = _currentNPC.GetComponent<Animator>();
            animator.CrossFadeInFixedTime(Animator.StringToHash("Crouch"), 0.1f);

            // Wait for the next frame to ensure the Animator has transitioned to the new state.
            yield return new WaitForSeconds(0.11f);

            AnimatorClipInfo[] clipInfo = animator.GetCurrentAnimatorClipInfo(0);
            if (clipInfo == null || clipInfo.Length == 0)
            {
                Logger.DebugLog("No animation clips found for crouch state!", Logger.LogCategory.Actions);
                yield break;
            }

            float length = clipInfo[0].clip.length;

            _currentNPC.GetComponents<CapsuleCollider>()[0].height = 1.2f;
            _currentNPC.GetComponents<CapsuleCollider>()[0].center = new Vector3(0, 0.6f, 0);

            if (_currentNPC.GetComponents<CapsuleCollider>().Length > 1)
            {
                _currentNPC.GetComponents<CapsuleCollider>()[1].height = 1.2f;
                _currentNPC.GetComponents<CapsuleCollider>()[1].center = new Vector3(0, 0.6f, 0);
            }

            yield return new WaitForSeconds(length);
            animator.CrossFadeInFixedTime(Animator.StringToHash("Idle"), 0.1f);

            yield return null;
            ActionEnded?.Invoke("Crouch", _currentNPC.gameObject);
        }

        /// <summary>
        ///     Coroutine to move the NPC towards a specified target using NavMeshAgent.
        /// </summary>
        /// <param name="target">The target GameObject to move towards.</param>
        private IEnumerator MoveTo(GameObject target)
        {
            // Invoke the ActionStarted event with the "MoveTo" action and the target GameObject.
            ActionStarted?.Invoke("MoveTo", target);

            // Check if the target is null or inactive, and log an error if so.
            if (target == null || !target.activeInHierarchy)
            {
                // Log an error if the target is null or inactive.
                Logger.DebugLog("MoveTo target is null or inactive.", Logger.LogCategory.Actions);
                yield break; // Exit the coroutine.
            }

            // Log that the NPC is starting the movement towards the target.
            Logger.DebugLog($"Moving to Target: {target.name}", Logger.LogCategory.Actions);

            // Start the "Walking" animation.
            Animator animator = _currentNPC.GetComponent<Animator>();

            // Crossfade to the "Walking" animation state with a slight transition delay for smoother visual effect.
            animator.CrossFade(Animator.StringToHash("Walking"), 0.01f);

            // Disable root motion to prevent conflicts between AI navigation and the automatic application of root motion.
            // This helps avoid unexpected behaviors and ensures smoother control during AI navigation.
            animator.applyRootMotion = false;

            // Get the NavMeshAgent component from the NPC.
            NavMeshAgent navMeshAgent = _currentNPC.GetComponent<NavMeshAgent>();
            navMeshAgent.updateRotation = false;

            // Calculate the target destination, considering the target's forward direction or default offset.
            Vector3 targetDestination = target.transform.position;

            // Check if the target has a Renderer component.
            if (target.TryGetComponent(out Renderer renderer))
            {
                // If yes, calculate the offset based on the size of the renderer along the z-axis.
                float zOffset = renderer.bounds.size.z;
                targetDestination += zOffset * target.transform.forward;
            }
            else
            {
                // If no Renderer component is found, use a default offset of half the target's forward direction.
                // This is useful when the target object does not have a visual representation (Renderer).
                Vector3 standardOffset = 0.5f * target.transform.forward;
                targetDestination += standardOffset;
            }

            // Set the destination for the NavMeshAgent and yield for one frame.
            navMeshAgent.SetDestination(targetDestination);
            yield return null;

            // Set the rotation speed for the character's rotation towards the movement direction.
            float rotationSpeed = 5;

            // Loop until the character is within the stopping distance to the target.
            while (navMeshAgent.remainingDistance > navMeshAgent.stoppingDistance)
            {
                // Ensure the target is still active during the movement.
                if (!target.activeInHierarchy)
                {
                    // Log and break if the target has been deactivated during the movement.
                    Logger.DebugLog("Target deactivated during movement.", Logger.LogCategory.Actions);
                    yield break;
                }

                // Check if the NPC is not moving, and yield until the next frame.
                if (navMeshAgent.velocity.sqrMagnitude < Mathf.Epsilon) yield return null;

                // Calculate the rotation towards the movement direction.
                Quaternion rotation = Quaternion.LookRotation(navMeshAgent.velocity.normalized);
                rotation.x = 0;
                rotation.z = 0;

                // Smoothly rotate the NPC towards the calculated rotation.
                transform.rotation = Quaternion.Slerp(transform.rotation, rotation, rotationSpeed * Time.deltaTime);

                // Yield until the next frame.
                yield return null;
            }

            // Transition to the "Idle" animation once the NPC has reached the target.
            animator.CrossFade(Animator.StringToHash("Idle"), 0.1f);

            // If this is the only action in the queue, rotate the NPC to face the camera.
            if (_actions.Count == 1)
            {
                Vector3 direction = (Camera.main.transform.position - transform.position).normalized;
                Quaternion targetRotation = Quaternion.LookRotation(direction);
                float elapsedTime = 0f;
                float rotationTime = 2f;

                // Smoothly rotate the NPC towards the camera direction.
                while (elapsedTime < rotationTime)
                {
                    targetRotation.x = 0;
                    targetRotation.z = 0;
                    transform.rotation =
                        Quaternion.Slerp(transform.rotation, targetRotation, elapsedTime / rotationTime);

                    elapsedTime += Time.deltaTime;
                    yield return null;
                }
            }

            // Re-enabling root motion, which was disabled during AI navigation movement to avoid conflicts.
            animator.applyRootMotion = true;

            // Invoke the ActionEnded event with the "MoveTo" action and the target GameObject.
            ActionEnded?.Invoke("MoveTo", target);
        }

        /// <summary>
        ///     Coroutine to pick up a target GameObject, adjusting the NPC's rotation and playing animations.
        /// </summary>
        /// <param name="target">The target GameObject to pick up.</param>
        private IEnumerator PickUp(GameObject target)
        {
            // Invoke the ActionStarted event with the "PickUp" action and the target GameObject.
            ActionStarted?.Invoke("PickUp", target);

            // Check if the target GameObject is null. If it is, log an error and exit the coroutine.
            if (target == null)
            {
                Logger.DebugLog("Target is null! Exiting PickUp coroutine.", Logger.LogCategory.Actions);
                yield break;
            }

            // Check if the target GameObject is active. If not, log an error and exit the coroutine.
            if (!target.activeInHierarchy)
            {
                Logger.DebugLog($"Target: {target.name} is inactive! Exiting PickUp coroutine.",
                    Logger.LogCategory.Actions);
                yield break;
            }

            // Calculate the direction from the NPC to the target, ignoring the vertical (y) component.
            Vector3 direction = (target.transform.position - transform.position).normalized;
            direction.y = 0;

            // Calculate the target rotation to face the target direction.
            Quaternion targetRotation = Quaternion.LookRotation(direction);
            float elapsedTime = 0f;
            float rotationTime = 0.5f;

            // Smoothly rotate the NPC towards the target direction over a specified time.
            while (elapsedTime < rotationTime)
            {
                targetRotation.x = 0;
                targetRotation.z = 0;
                transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, elapsedTime / rotationTime);

                elapsedTime += Time.deltaTime;
                yield return null;
            }

            // Log the action of picking up the target along with its name.
            Logger.DebugLog($"Picking up Target: {target.name}", Logger.LogCategory.Actions);

            // Retrieve the Animator component from the current NPC.
            Animator animator = _currentNPC.GetComponent<Animator>();

            // Start the "Picking Up" animation with a cross-fade transition.
            animator.CrossFade(Animator.StringToHash("Picking Up"), 0.1f);

            // Wait for one second to ensure that the Animator has had time to transition to the "Picking Up" animation state.
            yield return new WaitForSeconds(1);

            // Define the time it takes for the hand to reach the object in the "Picking Up" animation.
            // This is a specific point in time during the animation that we are interested in.
            float timeToReachObject = 1f;

            // Wait for the time it takes for the hand to reach the object.
            yield return new WaitForSeconds(timeToReachObject);

            // Check again if the target is still active before attempting to pick it up.
            if (!target.activeInHierarchy)
            {
                Logger.DebugLog(
                    $"Target: {target.name} became inactive during the pick up animation! Exiting PickUp coroutine.",
                    Logger.LogCategory.Actions);
                yield break;
            }

            // Once the hand has reached the object, set the target's parent to the NPC's transform,
            // effectively "picking up" the object, and then deactivate the object.
            target.transform.parent = gameObject.transform;
            target.SetActive(false);

            // Transition back to the "Idle" animation.
            animator.CrossFade(Animator.StringToHash("Idle"), 0.4f);

            // Invoke the ActionEnded event with the "PickUp" action and the target GameObject.
            ActionEnded?.Invoke("PickUp", target);
        }

        private void Drop(GameObject target)
        {
            ActionStarted?.Invoke("Drop", target);

            if (target == null) return;

            Logger.DebugLog($"Dropping Target: {target.name}", Logger.LogCategory.Actions);
            target.transform.parent = null;
            target.SetActive(true);

            ActionEnded?.Invoke("Drop", target);
        }

        private void Jump()
        {
            ActionStarted?.Invoke("Jump", _currentNPC.gameObject);

            float jumpForce = 5f;
            GetComponent<Rigidbody>().AddForce(new Vector3(0f, jumpForce, 0f), ForceMode.Impulse);
            _currentNPC.GetComponent<Animator>().CrossFade(Animator.StringToHash("Dance"), 1);

            ActionEnded?.Invoke("Jump", _currentNPC.gameObject);
        }

        // STEP 3: Add the function for your action here.

        #endregion
    }
}