using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;

namespace RimWorldAnimationStudio
{
    public class InputManager : Singleton<InputManager>
    {
        public Transform dialogBoxes;

        private float lastUpdate = -1f;
        private float timeBetweenUpdates = 0.15f;
        private float largeStep = 0.1f;
        private float smallStep = 0.03f;

        public bool CanRepeatThisUpdate()
        {
            if (Time.unscaledTime > lastUpdate + timeBetweenUpdates)
            {
                lastUpdate = Time.unscaledTime;
                return true;
            }

            return false;
        }

        public bool IsModifierKeyHeld()
        {
            if (Input.GetKey(KeyCode.LeftShift)) return true;
            if (Input.GetKey(KeyCode.LeftControl)) return true;
            if (Input.GetKey(KeyCode.LeftAlt)) return true;
            if (Input.GetKey(KeyCode.LeftCommand)) return true;
            if (Input.GetKey(KeyCode.RightShift)) return true;
            if (Input.GetKey(KeyCode.RightControl)) return true;
            if (Input.GetKey(KeyCode.RightAlt)) return true;
            if (Input.GetKey(KeyCode.RightCommand)) return true;

            return false;
        }

        public bool IsDialogBoxIsActive()
        {
            foreach (Transform child in dialogBoxes)
            { if (child.gameObject.activeSelf) return true; }

            return false;
        }

        public void Update()
        {
            if (IsDialogBoxIsActive()) return;

            bool canRepeatThisUpdate = CanRepeatThisUpdate();

            foreach (Keybind keybind in KeybindConfig.Instance.GetAllKeybinds())
            {
                if (IsModifierKeyHeld() && keybind.keyModifiers.NullOrEmpty()) goto nextKeybind;

                foreach (KeyCode modKeyCode in keybind.keyModifiers)
                { if (Input.GetKey(modKeyCode) == false) goto nextKeybind; }

                if (keybind.repeatable && canRepeatThisUpdate)
                { if (Input.GetKey(keybind.keyCode) == false) goto nextKeybind; }

                else
                { if (Input.GetKeyDown(keybind.keyCode) == false) goto nextKeybind; }

                //Debug.Log(keybind.command);
                Invoke(keybind.command, 0f); return;

                nextKeybind:;
            }
        }

        public void QuitApplication()
        {
            ApplicationManager.Instance.TryToCloseApplication();
        }

        public void NewAnimation()
        {
            ApplicationManager.Instance.TryToMakeNewAnimation();
        }

        public void SaveAnimation()
        {
            ApplicationManager.Instance.TryToSaveAnimation();
        }

        public void SaveAnimationAs()
        {
            ApplicationManager.Instance.TryToSaveAnimationAs();
        }

        public void LoadAnimation()
        {
            ApplicationManager.Instance.TryToLoadAnimation();
        }

        public void UndoAction()
        {
            if (Workspace.animationDef == null) return;
            Workspace.Instance.Undo();
        }

        public void RedoAction()
        {
            if (Workspace.animationDef == null) return;
            Workspace.Instance.Redo();
        }

        public void ToggleAnimationPreview()
        {
            if (Workspace.animationDef == null) return;
            AnimationController.Instance.ToggleAnimation();
        }

        public void CopyKeyframes()
        {
            if (Workspace.animationDef == null) return;
            AnimationController.Instance.CopyPawnKeyframes();
        }

        public void PasteKeyframes()
        {
            if (Workspace.animationDef == null) return;
            AnimationController.Instance.PastePawnKeyframes();
        }

        public void DeleteKeyframes()
        {
            if (Workspace.animationDef == null) return;
            AnimationController.Instance.RemovePawnKeyframe();
        }

        public void ActorMovementMode()
        {
            //if (Workspace.animationDef == null) return;
            AnimationController.Instance.ToggleActorManipulationMode(0);
        }

        public void ActorRotateMode()
        {
            //if (Workspace.animationDef == null) return;
            AnimationController.Instance.ToggleActorManipulationMode(1);
        }

        public void ActorFacingMode()
        {
            //if (Workspace.animationDef == null) return;
            AnimationController.Instance.ToggleActorManipulationMode(2);
        }

        public void AdjustActorUpward()
        {
            if (Workspace.animationDef == null) return;
            ActorKeyframeCard.Instance.AdjustActor(Vector2.up * largeStep);
        }

        public void AdjustActorDownward()
        {
            if (Workspace.animationDef == null) return;
            ActorKeyframeCard.Instance.AdjustActor(Vector2.down * largeStep);
        }

        public void AdjustActorLeftward()
        {
            if (Workspace.animationDef == null) return;
            ActorKeyframeCard.Instance.AdjustActor(Vector2.left * largeStep);
        }

        public void AdjustActorRightward()
        {
            if (Workspace.animationDef == null) return;
            ActorKeyframeCard.Instance.AdjustActor(Vector2.right * largeStep);
        }

        public void AdjustActorUpwardSmall()
        {
            if (Workspace.animationDef == null) return;
            ActorKeyframeCard.Instance.AdjustActor(Vector2.up * smallStep);
        }

        public void AdjustActorDownwardSmall()
        {
            if (Workspace.animationDef == null) return;
            ActorKeyframeCard.Instance.AdjustActor(Vector2.down * smallStep);
        }

        public void AdjustActorLeftwardSmall()
        {
            if (Workspace.animationDef == null) return;
            ActorKeyframeCard.Instance.AdjustActor(Vector2.left * smallStep);
        }

        public void AdjustActorRightwardSmall()
        {
            if (Workspace.animationDef == null) return;
            ActorKeyframeCard.Instance.AdjustActor(Vector2.right * smallStep);
        }

        public void CycleActorBodyPartSelecion()
        {
            if (Workspace.animationDef == null) return;

            ActorBody actorBody = AnimationController.Instance.actorBodies.GetChild(Workspace.actorID).GetComponent<ActorBody>();
            List<ActorBodyPart> actorBodyParts = actorBody.GetComponentsInChildren<ActorBodyPart>().Where(x => x.gameObject.activeInHierarchy)?.ToList();

            if (actorBodyParts.NullOrEmpty()) return;

            if (Workspace.selectedBodyPart == null)
            { actorBodyParts[0].Activate(); return; }

            else
            {
                for (int i = 0; i < actorBodyParts.Count; i++)
                {
                    ActorBodyPart part = actorBodyParts[i];

                    if (part == Workspace.selectedBodyPart)
                    {
                        if (i < actorBodyParts.Count - 1)
                        { actorBodyParts[i + 1].Activate(); return; }

                        else
                        { actorBody.Activate(); return; }
                    }
                }
            }
        }

        public void ToPreviousActor()
        {
            if (Workspace.animationDef == null) return;

            Workspace.selectedBodyPart = null;
            Workspace.actorID = Mathf.Clamp(Workspace.actorID - 1, 0, Workspace.animationDef.actors.Count - 1);
        }

        public void ToNextActor()
        {
            if (Workspace.animationDef == null) return;

            Workspace.selectedBodyPart = null;
            Workspace.actorID = Mathf.Clamp(Workspace.actorID + 1, 0, Workspace.animationDef.actors.Count - 1);
        }

        public void ToPreviousTick()
        {
            if (Workspace.animationDef == null) return;
            AnimationController.Instance.stageTick = Mathf.Clamp(AnimationController.Instance.stageTick - 1, 1, Workspace.StageWindowSize);
        }

        public void ToNextTick()
        {
            if (Workspace.animationDef == null) return;
            AnimationController.Instance.stageTick = Mathf.Clamp(AnimationController.Instance.stageTick + 1, 1, Workspace.StageWindowSize);
        }

        public void ToFirstTick()
        {
            if (Workspace.animationDef == null) return;
            AnimationController.Instance.stageTick = 1;
        }

        public void ToLastTick()
        {
            if (Workspace.animationDef == null) return;
            AnimationController.Instance.stageTick = Workspace.StageWindowSize;
        }

        public void ToPreviousKey()
        {
            if (Workspace.animationDef == null) return;
            PawnKeyframe keyframe = Workspace.Instance.GetPreviousKeyframe(Workspace.actorID);
            if (keyframe != null) AnimationController.Instance.stageTick = keyframe.atTick.Value;
        }

        public void ToNextKey()
        {
            if (Workspace.animationDef == null) return;
            PawnKeyframe keyframe = Workspace.Instance.GetNextKeyframe(Workspace.actorID);
            if (keyframe != null) AnimationController.Instance.stageTick = keyframe.atTick.Value;
        }

        public void ToPreviousStage()
        {
            if (Workspace.animationDef == null) return;

            int prevStageID = Workspace.stageID;
            Workspace.stageID = Mathf.Clamp(Workspace.stageID - 1, 0, Workspace.animationDef.animationStages.Count - 1);

            if (Workspace.stageID != prevStageID)
            { Workspace.Instance.RecordEvent("Stage selected"); }
        }

        public void ToNextStage()
        {
            if (Workspace.animationDef == null) return;

            int prevStageID = Workspace.stageID;
            Workspace.stageID = Mathf.Clamp(Workspace.stageID + 1, 0, Workspace.animationDef.animationStages.Count - 1);

            if (Workspace.stageID != prevStageID)
            { Workspace.Instance.RecordEvent("Stage selected"); }
        }

        public void CenterView()
        {
            Camera.main.GetComponent<CameraController>().ResetCamera();
        }
    }
}