using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.Localization;
using UnityEngine.Localization.Settings;

namespace InfallibleCode
{
    public class DoorBehaviour : MonoBehaviour, /*IDraggable*/IInteractable
    {
        public Transform door;
        //public Rigidbody doorRb;
        public bool DoorRequiresKey;
        public bool DoorIsOpen;
        public float RotationSpeed = 2;

        [Range(0, -90)]
        public float DoorStartAngle = -90f;

        [Header("!DEBUGGING!")]
        [HideInInspector] public bool CanOpenDoor = true;
        //[SerializeField] public Transform _player;
        public int doorSide;
        private float doorLerp;
        [HideInInspector] public float _doorLerpOpenAngle = 0f;
        [HideInInspector] public float _doorLerpSpeed = 0.5f;
        //[HideInInspector] public float _doorLerpCloseAngle;
        private Quaternion _OpenPos;
        private Quaternion _ClosedPos;
        private Quaternion _OpenPos90Degrees;

        public bool doorIsOpeningOrClosing;
        public AudioClip doorOpenSoundEffect;
        public AudioClip doorCloseSoundEffect;
        public AudioSource doorAudioSource;
        public AudioMixer audioMixer;
        private bool doorCloseAudioPlayed;

        [HideInInspector] public bool enemyIsTryingToOpenDoor;

        public EventDelegateTrigger eventDelegateTriggerOnDoorClosed;

        public delegate void OnActionHappened();
        public event OnActionHappened onDoorClosed;

        public LocalizedString localizedLockedMessage;

        DoorAnimationableExtension doorAnimationableExtension;


        void Awake()
        {
            if (door == null)
            {
                door = GetComponent<Transform>();
            }

            if (gameObject.GetComponent<AudioSource>() == null)
            {
                doorAudioSource = gameObject.AddComponent(typeof(AudioSource)) as AudioSource;
                // Assign the Audio Mixer to the AudioSource
                doorAudioSource.outputAudioMixerGroup = audioMixer.FindMatchingGroups("SFX")[0];
            }

            doorOpenSoundEffect = Resources.Load<AudioClip>("DoorSounds/DoorOpenSoundEffect");
            doorCloseSoundEffect = Resources.Load("DoorSounds/DoorCloseSoundEffect") as AudioClip;

            if (TryGetComponent<DoorAnimationableExtension>(out DoorAnimationableExtension doorAnimationableExtension))
            {
                this.doorAnimationableExtension = doorAnimationableExtension;
            }
        }

        void Start()
        {
            if (DoorRequiresKey)
            {
                CanOpenDoor = false;
            }

            if (doorAnimationableExtension == null)
            {
                door.transform.localRotation = Quaternion.Euler(door.localEulerAngles.x, DoorStartAngle, door.localEulerAngles.z);

                _OpenPos = Quaternion.Euler(door.localEulerAngles.x, -90f, door.localEulerAngles.z);
                _OpenPos90Degrees = Quaternion.Euler(door.localEulerAngles.x, 90f, door.localEulerAngles.z);
                _ClosedPos = Quaternion.Euler(door.localEulerAngles.x, 0f, door.localEulerAngles.z);
                if (DoorStartAngle >= 0f)
                {
                    DoorIsOpen = false;
                }
                if (DoorStartAngle <= -90f)
                {
                    DoorIsOpen = true;
                }
            }

            doorAudioSource = GetComponent<AudioSource>();
            doorAudioSource.loop = false;
            doorAudioSource.spatialBlend = 1f;
            doorAudioSource.maxDistance = 100f;
        }

        public void StopDoorCoroutines()
        {
            StopAllCoroutines();
        }

        public void DragDoor()
        {
            #region Door Drag
            if (CanOpenDoor && !doorIsOpeningOrClosing)
            {
                if (DoorIsOpen)
                {
                    if (doorAnimationableExtension == null)
                    {
                        CloseDoor(0.5f);
                    }
                    else 
                    {
                        doorAnimationableExtension.DoorClose();
                        DoorIsOpen = false;
                    }


                    StartCoroutine(DoorOpenFalse());
                    doorIsOpeningOrClosing = true;
                }
                else
                {
                    if (doorAnimationableExtension == null)
                    {
                        OpenDoor(0.5f);
                    }
                    else 
                    {
                        doorAnimationableExtension.DoorOpen();
                        DoorIsOpen = true;
                    }

                    StartCoroutine(DoorOpenTrue());
                    doorIsOpeningOrClosing = true;
                }


            }
            else if (DoorRequiresKey)
            {
                RandomSoundsManager.GetInstance().PlayLockDoorSound(doorAudioSource);
                string localizedText = LocalizationSettings.StringDatabase.GetLocalizedString("Messages", "lockedMessage");
                UIManager.GetInstance().StartCoroutine(UIManager.GetInstance().DisplayMessage(localizedLockedMessage));
                Debug.Log("Door is locked");
            }
            else
            {
                //UIManager.GetInstance().StartCoroutine(UIManager.GetInstance().DisplayMessage("Jammed"));
                Debug.Log("Door is jammed");
            }
        }
        #endregion

        IEnumerator DoorOpenFalse()
        {
            while (doorLerp >= 1f)
            {
                DoorIsOpen = false;
                yield return null;
            }
        }

        IEnumerator DoorOpenTrue()
        {
            while (doorLerp >= 1f)
            {
                DoorIsOpen = true;
                yield return null;
            }
        }

        IEnumerator DoorAnglesUpdate()
        {
            while (doorLerp <= 1f)
            {
                float DoorAngle = door.transform.localEulerAngles.y;
                DoorAngle = (DoorAngle > 180) ? DoorAngle - 360 : DoorAngle;
                if (DoorAngle <= -90f)
                {
                    print("Door Rotation.Y is -90f (Door Angle -90f)");
                    DoorIsOpen = true;
                    doorLerp = 0f;
                }
                if (DoorAngle < -0.01f)
                {
                    //CloseDoor(1f);
                    print("Door Rotation.Y is -90f (Door Angle -0.01f)");
                    DoorIsOpen = true;
                    doorLerp = 0f;
                }
                if (DoorAngle >= 0f)
                {
                    print("Door Rotation.Y is 0f (Door Angle 0f)");
                    DoorIsOpen = false;
                    doorLerp = 0f;
                }
                yield return null;
            }
        }


        public void Interact()
        {
            if (!enemyIsTryingToOpenDoor)
            {
                DragDoor();
            }
        }


        public void LockDoor()
        {
            DoorRequiresKey = true;
            CanOpenDoor = false;
        }

        public void UnlockDoor()
        {
            DoorRequiresKey = false;
            CanOpenDoor = true;
        }

        #region Open Door
        public void OpenDoor(float doorLerpSpeed)
        {
            doorLerp = 0f;
            DoorIsOpen = true;
            //doorAudioSource.PlayOneShot(doorOpenSoundEffect);
            //doorAudioSource.PlayOneShot()
            RandomSoundsManager.GetInstance().PlayRandromOpenSound(doorAudioSource);
            StartCoroutine(OpenDoorCoroutine(doorLerpSpeed));
            doorCloseAudioPlayed = false;
        }

        public void OpenDoor90Degrees(float doorLerpSpeed) 
        {
            doorLerp = 0f;
            DoorIsOpen = true;
            //doorAudioSource.PlayOneShot(doorOpenSoundEffect);
            RandomSoundsManager.GetInstance().PlayRandromOpenSound(doorAudioSource);
            StartCoroutine(OpenDoor90DegreesCoroutine(doorLerpSpeed));
            doorCloseAudioPlayed = false;
        }

        IEnumerator OpenDoorCoroutine(float doorLerpSpeed)
        {
            float transitionTime = 1;
            while (doorLerp <= transitionTime) /*(door.localEulerAngles.y <= -90f)*/
            {
                if (Time.timeScale > 0f) // Check if time is not paused
                {
                    doorLerp += doorLerpSpeed * Time.deltaTime;
                    float normalizedTime = Mathf.Clamp01(doorLerp / transitionTime);
                    door.localRotation = Quaternion.Slerp(door.localRotation, _OpenPos, normalizedTime);
                    print("Door opens");

                    float DoorAngle = door.transform.localEulerAngles.y;
                    DoorAngle = (DoorAngle > 180) ? DoorAngle - 360 : DoorAngle;
                    if (DoorAngle <= -90f)
                    {
                        if (doorIsOpeningOrClosing)
                        {
                            doorIsOpeningOrClosing = false;
                        }
                        StopAllCoroutines();
                    }
                }
                yield return null;
            }
            if (doorIsOpeningOrClosing)
            {
                doorIsOpeningOrClosing = false;
            }
        }

        IEnumerator OpenDoor90DegreesCoroutine(float doorLerpSpeed)
        {
            float transitionTime = 1;
            while (doorLerp <= transitionTime) /*(door.localEulerAngles.y <= -90f)*/
            {
                if (Time.timeScale > 0f) // Check if time is not paused
                {
                    doorLerp += doorLerpSpeed * Time.deltaTime;
                    float normalizedTime = Mathf.Clamp01(doorLerp / transitionTime);
                    door.localRotation = Quaternion.Slerp(door.localRotation, _OpenPos90Degrees, normalizedTime);
                    print("Door opens");

                    float DoorAngle = door.transform.localEulerAngles.y;
                    DoorAngle = (DoorAngle > 180) ? DoorAngle - 360 : DoorAngle;
                    if (DoorAngle >= 90f)
                    {
                        if (doorIsOpeningOrClosing)
                        {
                            doorIsOpeningOrClosing = false;
                        }
                        StopAllCoroutines();
                    }
                }
                yield return null;
            }
            if (doorIsOpeningOrClosing)
            {
                doorIsOpeningOrClosing = false;
            }
        }

        #endregion

        #region Close Door
        public void CloseDoor(float doorLerpSpeed)
        {
            doorLerp = 0f;
            DoorIsOpen = false;
            StartCoroutine(CloseDoorCoroutine(doorLerpSpeed));
        }


        IEnumerator CloseDoorCoroutine(float doorLerpSpeed)
        {
            float transitionTime = 1;
            while (doorLerp <= transitionTime)/*(door.localEulerAngles.y >= 0f)*/
            {
                if (Time.timeScale > 0f) // Check if time is not paused
                {
                    doorLerp += doorLerpSpeed * Time.deltaTime;
                    float normalizedTime = Mathf.Clamp01(doorLerp / transitionTime);
                    door.localRotation = Quaternion.Slerp(door.localRotation, _ClosedPos, normalizedTime);
                    print("Door closes");

                    float DoorAngle = door.transform.localEulerAngles.y;
                    DoorAngle = (DoorAngle > 180) ? DoorAngle - 360 : DoorAngle;
                    if (DoorAngle >= -0.001f)
                    {
                        if (doorIsOpeningOrClosing)
                        {
                            doorIsOpeningOrClosing = false;
                        }

                        print("stop");
                        if (eventDelegateTriggerOnDoorClosed != null)
                        {
                            eventDelegateTriggerOnDoorClosed?.OnEventInvoke();
                        }
                        onDoorClosed?.Invoke();
                        StopAllCoroutines();
                        yield break; // exit the coroutine here
                    }
                    if (DoorAngle >= -10f && !doorCloseAudioPlayed)
                    {
                        //doorAudioSource.PlayOneShot(doorCloseSoundEffect);
                        RandomSoundsManager.GetInstance().PlayRandomCloseSound(doorAudioSource);
                        doorCloseAudioPlayed = true;
                    }
                }
                yield return null;
            }
            if (doorIsOpeningOrClosing)
            {
                ForceDoorToClosePosition();
                doorIsOpeningOrClosing = false;
            }
            if (eventDelegateTriggerOnDoorClosed != null)
            {
                eventDelegateTriggerOnDoorClosed?.OnEventInvoke();
            }
            onDoorClosed?.Invoke();
        }
        #endregion

        public void ForceDoorToClosePosition()
        {
            DoorIsOpen = false;
            door.localRotation = _ClosedPos;
            doorLerp = 0f;
        }

        public void DoorIsNoLongerOpeningOrClosing() 
        {
            doorIsOpeningOrClosing = false;
        }
    }
}

#region OLD DraggableCode
//        #region Layers of fear
//        //[Header("Door are close?")]
//        //public bool C_AreClosed;

//        //[Header("Curent hinde joint angle")]
//        //public float C_CurrentAngle;

//        //[Header("Event sent every time door is closed fast")]
//        //public string E_FastCloseEvent = string.Empty;

//        //[Header("Fast closing, force threshold ")]
//        //public float E_FastCloseThreshold = 0.65f;

//        //[Header("Handle used to position hud")]
//        //public GameObject E_HudForwardDirHandle;

//        //[Header("Handle used to position hud")]

//        //public GameObject E_HudInverseForwardDirHandle;

//        //public float E_StopTutorialHudAngle = 45f;

//        //public Sprite E_LockedDoorIcon;

//        //public Sprite E_LoadingDoorIcon;

//        //private bool _AreClosed;

//        //private bool m_IsInteractedWith;

//        //private bool m_IsPickupSelected;

//        //private bool m_FreezeDoor = true;

//        //private float m_StartMaxLimit = 45f;

//        //private float m_StartMinLimit = -45f;

//        //private bool m_CanFreeze = true;

//        //private HingeJoint m_HingeJoint;

//        //private GameObject m_CloseDoorSound;

//        //private GameObject m_OpenSound;

//        //private GameObject m_ClosingSound;

//        //private GameObject m_FastClosingSound;

//        //private bool m_StopCloseAndLockerSounds;

//        //private bool m_AreCloseLate = true;

//        //private bool m_IsOpenDoorCoroutineRunning;
//        #endregion

//        void Awake() 
//        {
//            #region Layers Of Fear
//            //m_HingeJoint = GetComponent<HingeJoint>();
//            //if (m_HingeJoint)
//            //{
//            //    JointLimits limits = m_HingeJoint.limits;
//            //    m_StartMaxLimit = limits.max;
//            //    m_StartMinLimit = limits.min;
//            //} 
//            #endregion

//            if(door == null) 
//            {
//                door = GetComponent<Transform>();
//            }
//        }

//        void Start()
//        {
//            if (DoorRequiresKey)
//            {
//                CanOpenDoor = false;
//            }

//            door.transform.localRotation = Quaternion.Euler(door.localEulerAngles.x, DoorStartAngle, door.localEulerAngles.z);

//            _OpenPos =  Quaternion.Euler(door.localEulerAngles.x, _doorLerpOpenAngle, door.localEulerAngles.z);
//            _ClosedPos = Quaternion.Euler(door.localEulerAngles.x, 0f, door.localEulerAngles.z);
//        }

//        private float GetAngleBetweenPlayerAndDoor()
//        {
//            if (door != null)
//            {
//                return Vector3.Angle(door.forward,PlayerManager.GetInstance().playerGameObj.transform.forward);
//            }
//            return 0f;
//        }

//        private void MouseVectorUpdate()
//        {
//            if (DraggablesManager.GetInstance().IsDragging)
//            {
//                float angleBetweenPlayerAndDoor = GetAngleBetweenPlayerAndDoor();
//                if (angleBetweenPlayerAndDoor > 90f)
//                {
//                    doorSide = -1;

//                }
//                else if( angleBetweenPlayerAndDoor < 90f)
//                {
//                    doorSide = 1;
//                    //if (angleBetweenPlayerAndDoor == 90f)
//                    //{
//                    //    doorSide = 1;
//                    //}
//                }
//                //else if (angleBetweenPlayerAndDoor == 90f)
//                //{
//                //    doorSide = 0;
//                //}
//                print(doorSide);
//            }
//        }

//        #region Layers Of Fear
//        //public override void UpdateInternal(Vector2 inputVector, Vector3 playerForward)
//        //{
//        //    float d = Vector3.Dot(inputVector, this.E_MouseMovementVector) * -1f;
//        //    Vector3 force = (!this.E_SetMoveDirection) ? (playerForward * d) : (base.GetMoveDirection() * d);
//        //    if (this.IsDragged && this.m_Rigidbody)
//        //    {
//        //        if (!this.E_OnlyRotation && this.m_Rigidbody.velocity.magnitude < this.E_MaxForce && force.magnitude > this.E_MinForce)
//        //        {
//        //            base.AddForce(force);
//        //            if (this.E_UniqueID != 0)
//        //            {
//        //                GameStatistics.Instance.OpenableMoved(base.OwnerRoom.Owner.Scene.UniqueID, this.E_OpenableType, this.E_UniqueID);
//        //            }
//        //        }
//        //        if (this.E_SetRotationDirection)
//        //        {
//        //            this.m_Rigidbody.transform.Rotate(this.E_RotationDirection, force.magnitude * this.E_ForceMultiplier, this.E_Space);
//        //        }
//        //    }
//        //    this.PlaySounds(inputVector);
//        //    this.UpdateMoveSounds();
//        //}
//        #endregion


//        //private void OnTriggerStay(Collider col)
//        //{
//        //    //if(col.gameObject.tag == "Player") 
//        //    //{
//        //    //    if (Input.GetKeyDown(KeyCode.Mouse0))           
//        //    //    {
//        //    //        if (CanOpenDoor)
//        //    //        {
//        //    //            if (!DoorIsOpen)
//        //    //            {
//        //    //                DoorOpen();
//        //    //            }
//        //    //            else
//        //    //            {
//        //    //                DoorClose();
//        //    //            }
//        //    //        }
//        //    //        else if(DoorRequiresKey)
//        //    //        {
//        //    //            Debug.Log("Door is locked");
//        //    //        }
//        //    //        else 
//        //    //        {
//        //    //            Debug.Log("Door is jammed");
//        //    //        }
//        //    //    }
//        //    //}

//        //}
//        public void DragDoor()
//        {
//            #region Door Drag
//            if (CanOpenDoor)
//            {
//                DraggablesManager.GetInstance().IsDragging = true;
//                //#region Player Camera
//                //CameraMovement.GetInstance()._mouseSensitivity = 0.5f;
//                //#endregion

//                float rotX = Input.GetAxis("Mouse X") * RotationSpeed * Mathf.Deg2Rad;

//                //float rotY = Input.GetAxis("Mouse Y") * RotationSpeed * Mathf.Deg2Rad;

//                //if (Input.GetMouseButton(0)) //While you are holding down the left mouse:
//                //{
//                #region fml
//                //if (Mathf.Approximately(door.rotation.z, _player.rotation.z))
//                //{
//                //    door.RotateAroundLocal(Vector3.up, -rotX);
//                //    print("I work normmaly");
//                //}
//                //else
//                //{
//                //    door.RotateAroundLocal(Vector3.down, -rotXReverse);
//                //    print("I work gay");
//                //} 
//                #endregion
//                GetAngleBetweenPlayerAndDoor();
//                MouseVectorUpdate();
//                if (doorSide == 1f)
//                {
//                    door.RotateAroundLocal(Vector3.up, -rotX);

//                }
//                else if( doorSide == -1)
//                {
//                    door.RotateAroundLocal(Vector3.up, rotX);

//                }
//                //else if (doorSide == 0)
//                //{

//                //}

//                //door.RotateAroundLocal(Vector3.up, -rotX);
//                //door.RotateAroundLocal(Vector3.right, rotY);
//                float DoorAngle = door.transform.localEulerAngles.y;
//                DoorAngle = (DoorAngle > 180) ? DoorAngle - 360 : DoorAngle;
//                if (DoorAngle <= -90f)
//                {
//                    print("Door Rotation.Y is -90f");
//                    door.localEulerAngles = new Vector3(0f, -90f, 0f);
//                    DoorIsOpen = true;
//                }
//                if (DoorAngle < -0.01f)
//                {
//                    print("Door Rotation.Y is -90f");
//                    DoorIsOpen = true;
//                }
//                if (door.localRotation.y >= 0f)
//                {
//                    print("Door Rotation.Y is 0f");
//                    door.localEulerAngles = new Vector3(0f, 0f, 0f);
//                    DoorIsOpen = false;
//                }
//                //}
//            }
//            else if (DoorRequiresKey)
//            {
//                Debug.Log("Door is locked");
//            }
//            else
//            {
//                Debug.Log("Door is jammed");
//            }
//        }
//        #endregion

//        public void Drag() 
//        {
//            DragDoor();
//        }


//        public void LockDoor()
//        {
//            DoorRequiresKey = true;
//            CanOpenDoor = false;
//        }

//        public void UnlockDoor()
//        {
//            DoorRequiresKey = false;
//            CanOpenDoor = true;
//        }

//        #region Open Door
//        public void OpenDoor(float doorLerpSpeed) 
//        {
//            doorLerp = 0f;
//            StartCoroutine(OpenDoorCoroutine(doorLerpSpeed));
//        }

//        IEnumerator OpenDoorCoroutine(float doorLerpSpeed) 
//        {
//            while(doorLerp <= 1f) 
//            {
//                doorLerp += doorLerpSpeed * Time.deltaTime;
//                door.localRotation = Quaternion.Slerp(door.localRotation, _OpenPos, doorLerp);
//                //transform.localEulerAngles = Quaternion.Lerp(door.transform.localRotation, _OpenPos, doorLerp);

//                yield return null;
//            }
//        }
//        #endregion

//        #region Close Door
//        public void CloseDoor(float doorLerpSpeed) 
//        {
//            doorLerp = 0f;
//            StartCoroutine(CloseDoorCoroutine(doorLerpSpeed));
//        }


//        IEnumerator CloseDoorCoroutine(float doorLerpSpeed)
//        {
//            while (doorLerp <= 1f)
//            {
//                doorLerp += doorLerpSpeed * Time.deltaTime;
//                door.localRotation = Quaternion.Slerp(door.localRotation, _ClosedPos, doorLerp);
//                yield return null;
//            }
//        }
//        #endregion
//    }
//}
#endregion