using SLSFramework.General;
using UnityEngine;

namespace Cielonos.MainGame
{
    public partial class TransformSubmodule : AttackAreaSubmoduleBase
    {
        public Transform targetTransform;
        public float delay;
        public float timer;
        
        public bool applyPosition;
        public float positionMoveDuration;
        public EaseType positionEaseType;
        public Vector3 startPosition;
        public Vector3 endPosition;
        private AnimationCurve positionCurve;
        
        public bool applyRotation;
        public float rotationMoveDuration;
        public EaseType rotationEaseType;
        public Vector3 startEulerAngles;
        public Vector3 endEulerAngles;
        private AnimationCurve rotationCurve;
        
        public bool applyScale;
        public float scaleMoveDuration;
        public EaseType scaleEaseType;
        public Vector3 startScale;
        public Vector3 endScale;
        private AnimationCurve scaleCurve;
        
        public TransformSubmodule(AttackAreaBase attackArea, Transform targetTransform = null, float delay = 0f) : base(attackArea)
        {
            this.targetTransform = targetTransform ?? attackArea.topParent.transform;
            this.delay = delay;
        }
        
        public AttackAreaBase ApplyPositionMove(Vector3 startPosition, Vector3 endPosition, float duration, EaseType easeType = EaseType.Linear)
        {
            this.applyPosition = true;
            this.startPosition = startPosition;
            this.endPosition = endPosition;
            this.positionMoveDuration = duration;
            this.positionEaseType = easeType;
            this.positionCurve = Ease.GetCurve(easeType);
            return attackArea;
        }
        
        public AttackAreaBase ApplyRotationMove(Vector3 startEulerAngles, Vector3 endEulerAngles, float duration, EaseType easeType = EaseType.Linear)
        {
            this.applyRotation = true;
            this.startEulerAngles = startEulerAngles;
            this.endEulerAngles = endEulerAngles;
            this.rotationMoveDuration = duration;
            this.rotationEaseType = easeType;
            this.rotationCurve = Ease.GetCurve(easeType);
            return attackArea;
        }
        
        public AttackAreaBase ApplyScaleMove(Vector3 startScale, Vector3 endScale, float duration, EaseType easeType = EaseType.Linear)
        {
            this.applyScale = true;
            this.startScale = startScale;
            this.endScale = endScale;
            this.scaleMoveDuration = duration;
            this.scaleEaseType = easeType;
            this.scaleCurve = Ease.GetCurve(easeType);
            return attackArea;
        }
    }

    public partial class TransformSubmodule
    {
        public virtual void Update()
        {
            if(timer > Mathf.Max(positionMoveDuration, rotationMoveDuration, scaleMoveDuration))
            {
                return;
            }
            
            float deltaTime = attackArea.creator != null ? attackArea.creator.selfTimeSm.DeltaTime : Time.deltaTime;
            if (delay > 0f)
            {
                delay -= deltaTime;
                return;
            }
            
            timer += deltaTime;

            if (applyPosition)
            {
                float t = Mathf.Clamp01(timer / positionMoveDuration);
                t = positionCurve.Evaluate(t);
                attackArea.topParent.transform.localPosition = Vector3.LerpUnclamped(startPosition, endPosition, t);
            }
            
            if (applyRotation)
            {
                float t = Mathf.Clamp01(timer / rotationMoveDuration);
                t = rotationCurve.Evaluate(t);
                Vector3 currentEulerAngles = Vector3.LerpUnclamped(startEulerAngles, endEulerAngles, t);
                attackArea.topParent.transform.localRotation = Quaternion.Euler(currentEulerAngles);
            }
            
            if (applyScale)
            {
                float t = Mathf.Clamp01(timer / scaleMoveDuration);
                t = scaleCurve.Evaluate(t);
                attackArea.topParent.transform.localScale = Vector3.LerpUnclamped(startScale, endScale, t);
            }
        }
    }
}