using System;
using System.Collections;
using System.Collections.Generic;
using Animancer;
using BITFALL.Player.Movement;
using BITKit;
using BITKit.Entities;
using BITKit.StateMachine;
using Cysharp.Threading.Tasks;
using UnityEngine;

namespace BITFALL.Player.Animation.States
{
	[Serializable]
	public class Climb : PlayerAnimateStates
	{
		[SerializeField] private AnimationClip clip;
		private IPlayerClimbState _climbState;
		public override async void OnStateEntry(IState old)
		{
			//animationController.animator.Play("Climb");
			await self.AnimancerComponent.Play(clip);
			if (!Enabled) return;
			_climbState.ManualCancel();
		}
		public override void OnMovementStateChanged(IEntityMovementState oldState, IEntityMovementState newState)
		{
			if (newState is IPlayerClimbState or IPlayerLinkState { LinkArea: 4 })
			{
				self.TransitionState<Climb>();
				if (newState is IPlayerClimbState x)
				{
					_climbState = x;
				}
			}
			else if(Enabled)
			{
				Exit();
			}
		}
	}

	[Serializable]
	public class Vault : PlayerAnimateStates
	{
		[SerializeField] private AnimationClip vaultClip;
		private IPlayerVaultState _vaultState;
		public override async void OnStateEntry(IState old)
		{
			base.OnStateEntry(old);
			await self.AnimancerComponent.Play(vaultClip);
			if(!Enabled)return;
			_vaultState.ManualCancel();
		}
		public override void OnMovementStateChanged(IEntityMovementState oldState, IEntityMovementState newState)
		{
			if (newState is IPlayerVaultState _state)
			{
				_vaultState = _state;
				self.TransitionState<Vault>();
			}
			else if (Enabled)
			{
				Exit();
			}
		}
	}

	[Serializable]
	public class Crawl:PlayerAnimateStates,IPlayerCrawlState
	{
		[SerializeField] private MixerTransition2D mixer;
		[SerializeField] private AnimationClip entryClip;
		[SerializeField] private AnimationClip clip;
		[SerializeField] private AnimationClip exitClip;
		private MixerState<Vector2> state;
		private bool entry;

		[Inject] private IEntityOverride _entityOverride;
		[Inject] private IPlayerMovement _playerMovement;
		public override async void OnStateEntry(IState old)
		{
			base.OnStateEntry(old);
			entry = false;
			await self.AnimancerComponent.Play(entryClip, 0.25f);
			if (!Enabled) return;
			entry = true;
		}
		public override async void OnStateExit(IState old, IState newState)
		{
			base.OnStateExit(old, newState);
			state = null;
			_entityOverride.AddOverride(this);
			var x = self.AnimancerComponent.Layers[1].Play(exitClip);
			await x;
			_entityOverride.RemoveOverride(this);
			x.Stop();
		}
		public override void OnStateUpdate(float deltaTime)
		{
			base.OnStateUpdate(deltaTime);
			if (!entry) return;
			if (self.Movement.Velocity.magnitude >= 0.1f && ((Vector2)_playerMovement.InputVector).magnitude>0)
			{
				state = self.AnimancerComponent.Play(mixer,0.2f).As<MixerState<Vector2>>();
				var velocity = self.Movement.LocomotionBasedVelocity;
				state.Parameter = new Vector2(velocity.x,velocity.z >=0 ?  Mathf.Max( velocity.z,Mathf.Abs(velocity.x)) : velocity.z);
			}
			else
			{
				self.AnimancerComponent.Play(clip,0.4f);
			}
		}

		public override void OnMovementStateChanged(IEntityMovementState oldState, IEntityMovementState newState)
		{
			base.OnMovementStateChanged(oldState, newState);
			if(newState is IPlayerCrawlState && self.CurrentState is not Crawl)
				self.TransitionState<Crawl>();
			else if(newState is not IPlayerCrawlState && Enabled)
				Exit();
		}
	}
	[Serializable]
	public class EdgeClimb : PlayerAnimateStates
	{
		[SerializeField] private AnimationClip edgeClimbClip;
		[SerializeField] private AnimationClip idleClip;
		[SerializeField] private AnimationClip climbUpClip;
		[SerializeField] private LinearMixerTransition moveMixer;
		[SerializeField] private AnimationClip leftClip;
		[SerializeField] private AnimationClip rightClip;
		[SerializeField] private AnimationClip changeClip;
		private int _phase;
		private AnimancerState state;

		[Inject] private IPlayerMovement _playerMovement;
		public override void OnStateEntry(IState old)
		{
			base.OnStateEntry(old);
			_phase = -1;
		}
		public override void OnStateExit(IState old, IState newState)
		{
			base.OnStateExit(old, newState);
			//state.Stop();
			state = null;
		}

		public override async void OnStateUpdate(float deltaTime)
		{
			if (self.Movement.CurrentState is not IPlayerEdgeClimbState edgeClimbState) return;
            
			if (_phase != edgeClimbState.Phase)
			{
				_phase = edgeClimbState.Phase;
				switch (edgeClimbState.Phase)
				{
					case 0:
						
						state?.Stop();
						state = self.AnimancerComponent.Play(edgeClimbClip, 0.2f);
						break;
					case 1:
						state?.Stop();
						state = self.AnimancerComponent.Play(changeClip, 0.2f);
						break;
					case 4:
					case 6:
						var mixState = self.AnimancerComponent.Play(moveMixer, 0.2f).As<MixerState<float>>();
						mixState.Parameter = _playerMovement.InputVector.x;
						break;
					case 5:
						self.AnimancerComponent.Play(idleClip, 0.2f);
						
						break;
					case 8:
						state?.Stop();
						state = self.AnimancerComponent.Play(climbUpClip, 0.2f);
						await state;
						if (!Enabled) return;
						edgeClimbState.ManualCancel();
						break;
					case 7:
						state?.Stop();
						await self.AnimancerComponent.Play(leftClip, 0.2f);
						edgeClimbState.Phase = 5;
						break;
					case 9:
						state?.Stop();
						await self.AnimancerComponent.Play(rightClip, 0.2f);
						edgeClimbState.Phase = 5;
						break;
				}
			}

		}

		public override void OnMovementStateChanged(IEntityMovementState oldState, IEntityMovementState newState)
		{
			switch (newState,Enabled)
			{
				case (IPlayerEdgeClimbState, false):
					self.TransitionState<EdgeClimb>();
					break;
				case (not IPlayerEdgeClimbState, true):
					Exit();
					break;
			}
		}
	}

	[Serializable]
	public sealed class Dodge: PlayerAnimateStates
	{
		[SerializeField] private MixerTransition2D mixer;
		[Inject] private IPlayerMovement _playerMovement;
		
		public override async void OnStateEntry(IState old)
		{
			base.OnStateEntry(old);
			var state =self.AnimancerComponent.Play(mixer).As<MixerState<Vector2>>();
			state.Parameter = _playerMovement.InputVector;
			await state;
			if (!Enabled) return;
			if (self.Movement.CurrentState is IPlayerDodgeState dodgeState)
			{
				dodgeState.ManualCancel();
			}
		}
		public override void OnMovementStateChanged(IEntityMovementState oldState, IEntityMovementState newState)
		{
			if (newState is IPlayerDodgeState)
			{
				self.TransitionState<Dodge>();
			}
			else if(Enabled)
			{
				Exit();
			}
		}
	}
}