using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using UnityEngine.Events;

public class paragliderSystem : externalControllerBehavior
{
	[Header ("Main Settings")]
	[Space]

	public bool paragliderModeEnabled = true;

	public float gravityForce = -9.8f;
	public float gravityMultiplier;

	public float minWaitTimeToActivateParaglider = 0.6f;

	public float airSpeed = 25;
	public float airControl = 10;

	[Space]
	[Header ("Extra Force Settings")]
	[Space]

	public bool addExtraUpForce;
	public float extraUpForceAmount = 5;

	public bool removeExtraUpForceAfterDelay;
	public float delayToRemoveExtraUpForce;

	[Space]
	[Header ("Animation Settings")]
	[Space]

	public int regularAirID = -1;
	public int paragliderID = 1;

	[Space]
	[Header ("Debug")]
	[Space]

	public bool showDebugPrint;

	public bool paragliderModePaused;

	public bool paragliderModeActive;

	public bool playerIsMoving;

	public bool externalForceActive;

	public Vector3 externaForceDirection;

	public float externalForceAmount;

	public bool checkingToActivateParaglider;

	public int externalForcesCounter;

	public bool useLastTimeParagliderPauseActive;

	public float previousGravityForce = -1000;

	public float previousGravityMultiplier = -1000;

	[Space]
	[Header ("Events Settings")]
	[Space]

	public UnityEvent eventOnStateEnabled;
	public UnityEvent eventOnStateDisabled;

	[Space]
	[Header ("Components")]
	[Space]

	public playerController mainPlayerController;
	public playerCamera mainPlayerCamera;
	public Rigidbody mainRigidbody;
	public Transform playerTransform;

	float lastTimeParagliderPauseActive;
	float useLastTimeParagliderPauseActiveDuration;

	Coroutine checkingToActivateCoroutine;

	bool originalParagliderModeEnabled;

	float lastTimeParagliderActive;


	void Start ()
	{
		originalParagliderModeEnabled = paragliderModeEnabled;
	}

	public override void updateControllerBehavior ()
	{
		if (paragliderModeActive) {
			if ((!mainPlayerController.isPlayerOnFirstPerson () && mainPlayerController.isPlayerAiming ()) ||
			    mainPlayerController.isPlayerOnGround () ||
			    mainPlayerController.isSwimModeActive () ||
			    mainPlayerController.isWallRunningActive () ||
			    mainPlayerController.isExternalControlBehaviorForAirTypeActive ()) {

				enableOrDisableParagliderMode (false);
			}
				
			mainPlayerController.setLastTimeFalling ();

			Vector3 movementDirection = airSpeed * mainPlayerController.getMoveInputDirection ();

			movementDirection += playerTransform.InverseTransformDirection (mainRigidbody.linearVelocity).y * playerTransform.up;

			if (addExtraUpForce) {
				bool addExtraUpResult = true;

				if (removeExtraUpForceAfterDelay) {
					if (Time.time > delayToRemoveExtraUpForce + lastTimeParagliderActive) {
						addExtraUpResult = false;
					}

				}
				if (addExtraUpResult) {
					movementDirection += extraUpForceAmount * playerTransform.up;
				}
			}

			if (externalForceActive) {
				movementDirection += externalForceAmount * externaForceDirection;
			}

			mainPlayerController.setExternalForceOnAir (movementDirection, airControl);
		}
	}

	public override bool isCharacterOnGround ()
	{
		if (paragliderModeActive) {
			return mainPlayerController.isPlayerOnGround ();
		}

		return true;
	}

	public override bool isBehaviorActive ()
	{
		return paragliderModeActive;
	}

	public void enableOrDisableParagliderMode (bool state)
	{
		if (showDebugPrint) {
			print ("paraglider " + state);
		}

		if (!paragliderModeEnabled) {
			return;
		}

		if (mainPlayerController.isUseExternalControllerBehaviorPaused ()) {
			return;
		}

		if (paragliderModePaused && state) {
			return;
		}

		if (paragliderModeActive == state) {
			return;
		}

		if (state) {
			externalControllerBehavior currentExternalControllerBehavior = mainPlayerController.getCurrentExternalControllerBehavior ();

			if (currentExternalControllerBehavior != null && currentExternalControllerBehavior != this) {
				if (canBeActivatedIfOthersBehaviorsActive && checkIfCanEnableBehavior (currentExternalControllerBehavior.behaviorName)) {
					currentExternalControllerBehavior.disableExternalControllerState ();
				} else {
					return;
				}
			}
		}
			
		bool paragliderModeActivePrevioulsy = paragliderModeActive;

		paragliderModeActive = state;

		bool usingDifferentExternalControllerBehavior = false;

		if (showDebugPrint) {
			print ("setting state");
		}

		setBehaviorCurrentlyActiveState (state);

		setCurrentPlayerActionSystemCustomActionCategoryID ();

		if (paragliderModeActive) {
			mainPlayerController.setExternalControllerBehavior (this);
		} else {
			if (paragliderModeActivePrevioulsy) {
				externalControllerBehavior currentExternalControllerBehavior = mainPlayerController.getCurrentExternalControllerBehavior ();

				if (currentExternalControllerBehavior == null || currentExternalControllerBehavior == this) {
					mainPlayerController.setExternalControllerBehavior (null);
				} else {
					usingDifferentExternalControllerBehavior = true;
				}
			}
		}

		if (!state) {
			if (!usingDifferentExternalControllerBehavior) {
				mainPlayerController.setLastTimeFalling ();
			}
		}

		if (state) {
			mainPlayerController.setCurrentAirIDValue (paragliderID);
		} else {
			if (!usingDifferentExternalControllerBehavior) {
				mainPlayerController.setCurrentAirIDValue (regularAirID);
			}
		}

		if (paragliderModeActive) {
			eventOnStateEnabled.Invoke ();
		} else {
			eventOnStateDisabled.Invoke ();
		}

		mainPlayerController.setSlowFallExternallyActiveState (paragliderModeActive);

		if (paragliderModeActive) {
			if (previousGravityForce == -1000) {
				previousGravityForce = mainPlayerController.getGravityForce ();

				previousGravityMultiplier = mainPlayerController.getGravityMultiplier ();

				if (previousGravityMultiplier > gravityMultiplier) {
					mainPlayerController.setGravityMultiplierValue (false, gravityMultiplier); 
				}

				if (previousGravityForce > gravityForce) {
					mainPlayerController.setGravityForceValue (false, gravityForce);
				}
			}
		} else {
			if (previousGravityForce != -1000) {
				mainPlayerController.setGravityMultiplierValue (false, previousGravityMultiplier);

				mainPlayerController.setGravityForceValue (false, previousGravityForce);

				previousGravityForce = -1000;

				previousGravityMultiplier = -1000;
			}
		}

		mainPlayerCamera.stopShakeCamera ();

		mainPlayerController.resetOtherInputFields ();

		mainPlayerController.disableExternalForceOnAirActive ();

		if (!paragliderModeActive) {
			if (mainPlayerController.checkIfPlayerOnGroundWithRaycast () || mainPlayerController.isPlayerOnGround ()) {
				mainPlayerController.setCheckOnGroungPausedState (false);

				mainPlayerController.setPlayerOnGroundState (false);

				mainPlayerController.setPlayerOnGroundAnimatorStateOnOverrideOnGroundWithTime (true);

				mainPlayerController.disableOverrideOnGroundAnimatorValue ();

				mainPlayerController.setPauseResetAnimatorStateFOrGroundAnimatorState (true);


				mainPlayerController.setJumpAnimatorIDValue (-9);

				mainPlayerController.setPlayerOnGroundState (true);

				mainPlayerController.setOnGroundAnimatorIDValue (true);
			}
		}

		lastTimeParagliderActive = Time.time;
	}

	public override void updateExternalForceActiveState (Vector3 forceDirection, float forceAmount)
	{
		if (!paragliderModeEnabled) {
			return;
		}

		externaForceDirection = forceDirection;

		externalForceAmount = forceAmount;
	}

	public override void setExternalForceActiveState (bool state)
	{
		if (!paragliderModeEnabled) {
			return;
		}

		externalForceActive = state;

		if (state) {
			externalForcesCounter++;
		} else {
			externalForcesCounter--;
		}

		if (externalForcesCounter < 0) {
			externalForcesCounter = 0;
		}

		if (externalForcesCounter > 0) {
			externalForceActive = true;
		} else if (externalForcesCounter == 0) {
			externalForceActive = false;
		}
	}

	public void inputToggletParagliderActiveState ()
	{
		if (paragliderModeActive) {
			enableOrDisableParagliderMode (false);
		} else {
			inputSetParagliderActiveState (!checkingToActivateParaglider);
		}
	}

	public void inputSetParagliderActiveState (bool state)
	{
		if (!paragliderModeEnabled) {
			return;
		}

		if (mainPlayerController.isPlayerOnGround () ||
		    mainPlayerController.isPlayerOnFFOrZeroGravityModeOn () ||
		    mainPlayerController.isWallRunningActive () ||
		    mainPlayerController.isSwimModeActive () ||
		    mainPlayerController.isPlayerDriving () ||
		    mainPlayerController.isExternalControlBehaviorForAirTypeActive ()) {

			if (checkingToActivateParaglider) {

				stopCheckingToActivateParagliderCoroutine ();

				checkingToActivateParaglider = false;
			}

			return;
		}

		if (useLastTimeParagliderPauseActive) {
			if (Time.time < lastTimeParagliderPauseActive + useLastTimeParagliderPauseActiveDuration) {
				return;
			} else {
				useLastTimeParagliderPauseActive = false;
			}
		}

		checkingToActivateParaglider = state;

		if (checkingToActivateParaglider) {
			stopCheckingToActivateParagliderCoroutine ();

			checkingToActivateCoroutine = StartCoroutine (checkingToActivateParagliderCoroutine ());
		} else {
			if (paragliderModeActive) {
				enableOrDisableParagliderMode (false);
			}

			stopCheckingToActivateParagliderCoroutine ();
		}
	}

	public void stopCheckingToActivateParagliderCoroutine ()
	{
		if (checkingToActivateCoroutine != null) {
			StopCoroutine (checkingToActivateCoroutine);
		}
	}

	IEnumerator checkingToActivateParagliderCoroutine ()
	{
		WaitForSeconds delay = new WaitForSeconds (minWaitTimeToActivateParaglider);

		yield return delay;

		if (checkingToActivateParaglider) {
			
			enableOrDisableParagliderMode (true);

			checkingToActivateParaglider = false;
		}
	}

	public void setParagliderModePausedState (bool state)
	{
		if (state) {
			if (paragliderModeActive) {
				enableOrDisableParagliderMode (false);
			}
		}

		paragliderModePaused = state;
	}

	public void setUseLastTimeParagliderPauseActive (float newDuration)
	{
		useLastTimeParagliderPauseActive = true;

		lastTimeParagliderPauseActive = Time.time;

		useLastTimeParagliderPauseActiveDuration = newDuration;
	}

	public void setParagliderModeEnabledState (bool state)
	{
		if (paragliderModeActive) {
			enableOrDisableParagliderMode (false);
		}

		paragliderModeEnabled = state;
	}

	public void setOriginalParagliderModeEnabledState ()
	{
		setParagliderModeEnabledState (originalParagliderModeEnabled);
	}

	public override void disableExternalControllerState ()
	{
		if (paragliderModeActive) {
			enableOrDisableParagliderMode (false);
		}
	}

	public override void setCurrentPlayerActionSystemCustomActionCategoryID ()
	{
		if (behaviorCurrentlyActive) {
			if (customActionCategoryID > -1) {
				mainPlayerController.setCurrentCustomActionCategoryID (customActionCategoryID);
			}
		} else {
			if (regularActionCategoryID > -1) {
				mainPlayerController.setCurrentCustomActionCategoryID (regularActionCategoryID);
			}
		}
	}

	public void setParagliderModeEnabledStateFromEditor (bool state)
	{
		setParagliderModeEnabledState (state);

		updateComponent ();
	}

	void updateComponent ()
	{
		GKC_Utils.updateComponent (this);

		GKC_Utils.updateDirtyScene ("Update Paraglider System", gameObject);
	}
}