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

public class PlayerController : MonoBehaviour {

	private MathsFTW maths;

	public Rigidbody2D rB;
	public SpriteRenderer sR;
	public CapsuleCollider2D coll;
	public Animator anim;
	public GameObject hitEffect;
	public GameObject flash;

	private Database database;
	private GameManager manager;

	public List<Tool> tools;
	private int currentTool;

	public GameObject bullet;

	public enum PlayerState { Standing, Hanging, Boosting, Climbing };
	private PlayerState state;

	private bool isInvincible;
	private bool canUseTool;
	private bool canJump;
	private bool canBoost;
	private bool isJumping;
	private bool canMove;
	private bool canHang;
	private bool facingRight;
	public float health;
	private float fullHealth;
	public float jumpPower;
	public float slidePower;
    public float climbSpeed;
	private bool canHit;
	private float vertKnockback;
	private float horizKnockback;
	private float knockbackPower;
	private Vector3 ledgePos;
	public float attackKnockback;
	private bool controlEnabled;
	private bool isHealing;

	private GameObject groundTransform;
	private GameObject rightTransform;
	private GameObject leftTransform;
	private GameObject leftWalk;
	private GameObject rightWalk;
	private GameObject attack;
	private GameObject attackPoint;
	private GameObject attackPoint2;
	private GameObject attackPoint3;
	private Animator attackAnim;
	private GameObject downGrabTransform;

    private Ladder activeLadder;

	public float baseSpeed;
	public float baseDamage;
	public float baseAttackSpeed;
	public float baseJump;
	public float baseMaxHealth;

	private float statSpeed;
	private float statDamage;
	private float statAttackSpeed;
	private float statJump;
	private float statMaxHealth;
	private float statDefence;


	// Use this for initialization
	void Start () {
		database = GameObject.FindGameObjectWithTag ("Database").GetComponent<Database> ();
		maths = GetComponent<MathsFTW> ();
		rB = GetComponent<Rigidbody2D> ();
		sR = transform.Find ("BodySprite").GetComponent<SpriteRenderer> ();
		coll = GetComponent<CapsuleCollider2D> ();
		manager = GameObject.FindGameObjectWithTag ("GameManager").GetComponent<GameManager> ();
		anim = transform.Find ("BodySprite").GetComponent<Animator>();

		database.GetPlayerStats (ref statSpeed, ref statDamage, ref statAttackSpeed, ref statJump, ref statMaxHealth, ref statDefence);

		groundTransform = transform.Find ("FloorTransform").gameObject;
		rightTransform = transform.Find ("RightTransform").gameObject;
		leftTransform = transform.Find ("LeftTransform").gameObject;
		leftWalk = transform.Find ("LeftWalk").gameObject;
		rightWalk = transform.Find ("RightWalk").gameObject;
		attack = transform.Find ("Attack").gameObject;
		attackPoint = attack.transform.Find ("AttackPoint").gameObject;
		attackPoint2 = attack.transform.Find ("AttackPoint2").gameObject;
		attackPoint3 = attack.transform.Find ("AttackPoint3").gameObject;
		attackAnim = attack.transform.Find ("Sprite").gameObject.GetComponent<Animator>();
		downGrabTransform = transform.Find ("DownGrabTransform").gameObject;

        FillTools();

        rB.freezeRotation = true;

		state = PlayerState.Standing;
		isInvincible = false;
		canUseTool = true;
		isJumping = false;
		canMove = true;
		canHang = true;
        canBoost = true;
		facingRight = true;
		canHit = true;
		fullHealth = (baseMaxHealth + ((baseMaxHealth * statMaxHealth) * 1.5f));
		health = fullHealth;
		vertKnockback = 10.0f;
		horizKnockback = 50.0f;
		controlEnabled = true;
		currentTool = 0;
		isHealing = false;



		manager.SetToolName (tools[currentTool].ToolName.ToString());
		manager.SetPlayerHealth (health);
	}
	
	// Update is called once per frame
	void Update () {

		database.GetPlayerStats (ref statSpeed, ref statDamage, ref statAttackSpeed, ref statJump, ref statMaxHealth, ref statDefence);

		if (state == PlayerState.Standing) {
			rB.gravityScale = 3;
		} else if (state == PlayerState.Hanging || state == PlayerState.Boosting || state == PlayerState.Climbing) {
			rB.gravityScale = 0;
		}

		if (state == PlayerState.Boosting) {
			sR.color = new Color (1.0f, 1.0f, 0.5f);
		} else {
			if (isInvincible) {
				if (sR.color.g < Color.gray.g) {
					sR.color = new Color (sR.color.r + 0.02f, sR.color.g + 0.02f, sR.color.b + 0.02f);
				}
			} else {
				if (sR.color != Color.white) {
					sR.color = new Color (sR.color.r + 0.02f, sR.color.g + 0.02f, sR.color.b + 0.02f);
				}
			}
		}

		if (GetCanJump() && state != PlayerState.Boosting)
        {
			canBoost = true;
        }

		if (isHealing) {
			if (health < fullHealth) {
				if (health + 1.0f >= fullHealth) {
					health = fullHealth;

				} else {
					health += 2.0f;
				}
			} else {
				isHealing = false;
				controlEnabled = true;
			}
			manager.SetPlayerHealth (health);
		}

		if (controlEnabled) {
			if (health <= 0) {
				Die ();
			} else {
				float horizontalAxis = Input.GetAxis ("Horizontal");

				if (horizontalAxis > 0.0f && state == PlayerState.Standing) {
					facingRight = true;
					
					anim.SetBool("PlayerMoving", true);
				} else if (horizontalAxis < 0.0f && state == PlayerState.Standing) {
					facingRight = false;
					
					anim.SetBool("PlayerMoving", true);
				} else {
					anim.SetBool("PlayerMoving", false);
				}

				if (Input.GetKeyDown (KeyCode.Q)) {
					if (currentTool + 1 >= tools.Count) {
						currentTool = 0;
					} else {
						currentTool++;
					}
					manager.SetToolName (tools[currentTool].ToolName.ToString());
				}

				if (state == PlayerState.Hanging) {
					Hanging ();
					EnableAttackUI (false);
				} else if (state == PlayerState.Climbing) {
                    Climbing();
					EnableAttackUI (false);
                } else {
					MovePlayer (horizontalAxis);
					EnableAttackUI (true);

					Vector2 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
					float angle = Mathf.Atan2 (mousePos.y - transform.position.y, mousePos.x - transform.position.x) * Mathf.Rad2Deg;
					attack.transform.rotation = Quaternion.AngleAxis (angle, transform.forward);

					if (Input.GetMouseButton(0) && canHit) {
						Attack ();
						canHit = false;
					}

					if (Input.GetMouseButtonDown(1) && canUseTool) {
						UseTool ();
						canUseTool = false;
						StartCoroutine (ToolTimer());
					}
				}
			}
		}

		UpdateAnimation();
	}

	void UpdateAnimation() {
		if (facingRight) {
			sR.transform.localScale = new Vector3(0.3f, 0.3f, 1.0f);
			sR.transform.localPosition = new Vector3(0.127f, 0.04f, 0.0f);

			if (anim.GetCurrentAnimatorClipInfo(0)[0].clip.name == "HumpHit") {
				
			
			} 


		} else {
			sR.transform.localScale = new Vector3(-0.3f, 0.3f, 1.0f);
			sR.transform.localPosition = new Vector3(-0.127f, 0.04f, 0.0f);

			if (anim.GetCurrentAnimatorClipInfo(0)[0].clip.name == "HumpHit") {
				
			
			} 
		}

		if (GetIsHanging()) {
			anim.SetBool("PlayerHanging", true);
		} else {
			anim.SetBool("PlayerHanging", false);
		}

		if (!GetCanJump()) {
			anim.SetBool("PlayerJumping", true);
		} else if (GetCanJump()) {
			anim.SetBool("PlayerJumping", false);
		}

		
	}

	void EnableAttackUI(bool newEnabled)
	{
		attackPoint.GetComponent<SpriteRenderer> ().enabled = newEnabled;
		attackPoint2.GetComponent<SpriteRenderer> ().enabled = newEnabled;
		attackPoint3.GetComponent<SpriteRenderer> ().enabled = newEnabled;
	}

	void UseTool()
	{
		if (tools [currentTool].GetToolName() == Tool.ToolNames.Gun) {
			Instantiate (bullet, attackPoint.transform.position, attack.transform.rotation);
		}

	}

    
    public void SetClimbingLadder(bool newIsClimbing, Ladder newLadder)
    {
		if (newIsClimbing) {
			state = PlayerState.Climbing;
			activeLadder = newLadder;
			rB.gravityScale = 0;

			//Vector2 newPosition = new Vector2(activeLadder.gameObject.transform.position.x, transform.position.y);
			Vector3 newPos = Vector3.zero;

			newPos = maths.ClosestPointOnLine (activeLadder.GetBottomLimit (), activeLadder.GetTopLimit (), transform.position);
				
			transform.position = newPos;

		} else {
			state = PlayerState.Standing;
		}
        
    }

	public void SetEnableControl(bool newEnabled)
	{
		controlEnabled = newEnabled;
		if (!newEnabled) {
			rB.velocity = Vector3.zero;
		}
	}

	public void Die()
	{
		manager.PlayerDead ();
		Destroy (this.gameObject);
	}

	public void FillHealth()
	{
		controlEnabled = false;
		isHealing = true;
	}

    public void FillTools()
    {
        tools = GameObject.FindGameObjectWithTag("Database").GetComponent<Database>().GetUnlockedTools();
    }

	void Attack()
	{
		attackAnim.SetTrigger("Attack");
		anim.SetTrigger("Hit");

		List<GameObject> hitObjects = new List<GameObject> ();

		AttackCheck (transform.position, attackPoint.transform.position, ref hitObjects);
		AttackCheck (transform.position, attackPoint2.transform.position, ref hitObjects);
		AttackCheck (transform.position, attackPoint3.transform.position, ref hitObjects);


        if (hitObjects.Count > 0)
        {
            rB.simulated = false;
            StartCoroutine(FreezeTimer());
        }
        else
        {
            StartCoroutine(HitTimer());
        }
    }

	void AttackCheck(Vector2 startPos, Vector2 endPos, ref List<GameObject> hitObjects)
	{
		float distance = Vector2.Distance(startPos, endPos);
		foreach (RaycastHit2D hit in Physics2D.RaycastAll(startPos, endPos - startPos, distance)) {

			if (hit.collider.isTrigger == false && hit.collider.gameObject != this.gameObject) {
				break;
			}

			Enemy enemy = hit.collider.gameObject.GetComponent<Enemy> ();
			Button button = hit.collider.gameObject.GetComponent<Button> ();

			if (enemy && hit.collider.isTrigger == true && !hitObjects.Contains(hit.collider.gameObject)) {
				Instantiate(hitEffect, hit.transform.position, Quaternion.AngleAxis(Random.Range(0.0f, 360.0f), transform.forward));
				Instantiate(hitEffect, hit.transform.position, Quaternion.AngleAxis(Random.Range(0.0f, 360.0f), transform.forward));
				Instantiate(hitEffect, hit.transform.position, Quaternion.AngleAxis(Random.Range(0.0f, 360.0f), transform.forward));
				enemy.Damage((baseDamage + ((baseDamage * statDamage) * 2.0f)), hit.point, attackKnockback);
				hitObjects.Add (hit.collider.gameObject);
				
			}

			if (button && !button.GetIsPressed()) {
				button.Press ();
			}
		}
	}

    void Climbing()
    {
        rB.velocity = Vector3.zero;

        if (Input.GetKeyDown(KeyCode.D))
        {
			state = PlayerState.Standing;
            rB.gravityScale = 3;
            activeLadder.SetClimbing(false);
			rB.velocity = new Vector2((baseSpeed + (baseSpeed * statSpeed * 0.5f)), jumpPower);
            return;
        }

        if (Input.GetKeyDown(KeyCode.A))
        {
			state = PlayerState.Standing;
            rB.gravityScale = 3;
            activeLadder.SetClimbing(false);
			rB.velocity = new Vector2(-(baseSpeed + (baseSpeed * statSpeed * 0.5f)), jumpPower);
            return;
        }

		Vector3 newPosition = transform.position;

        if (Input.GetKey(KeyCode.W) && transform.position.y + climbSpeed + 0.6f < activeLadder.GetTopLimit().y) {
			newPosition = newPosition + Vector3.Normalize (activeLadder.GetTopLimit () - transform.position) * climbSpeed;
        } else if (Input.GetKey(KeyCode.S) && transform.position.y - climbSpeed - 0.6f > activeLadder.GetBottomLimit().y) {
			newPosition = newPosition + Vector3.Normalize (activeLadder.GetBottomLimit() - transform.position) * climbSpeed;
        }

        transform.position = newPosition;
    }

	void Hanging()
	{
		rB.velocity = Vector3.zero;
		transform.position = Vector3.Lerp(transform.position, ledgePos, 0.3f);

		if (Input.GetKeyDown(KeyCode.S))
		{
			state = PlayerState.Standing;
			rB.gravityScale = 3;
			StartCoroutine (HangTimer());
		}

		if (Input.GetKeyDown (KeyCode.W)) {
			state = PlayerState.Standing;
			rB.gravityScale = 3;
			StartCoroutine (HangTimer());
			rB.velocity = new Vector2 (rB.velocity.x, jumpPower);
		}
	}

	void MovePlayer(float hor)
	{
		Vector2 newMovement = rB.velocity;

		if (canMove && state == PlayerState.Standing) {
			if (hor > 0.0f && GetCanMove (rightWalk) || hor < 0.0f && GetCanMove (leftWalk)) {
				newMovement = new Vector2 (hor * (baseSpeed + (baseSpeed * statSpeed * 0.5f)), rB.velocity.y);
			} 
		}

		if (GetCanJump () && Input.GetKeyDown (KeyCode.W) && !isJumping && state == PlayerState.Standing) {
			newMovement = new Vector2 (newMovement.x, jumpPower);
			isJumping = true;
			
			StartCoroutine (JumpTimer ());
			
		} else if (isJumping) {
			if (Input.GetKeyUp (KeyCode.W)) {
				isJumping = false;
				
				StopCoroutine (JumpTimer ());
			} else {
				newMovement = new Vector2 (newMovement.x, jumpPower);
			}
		}

		if (Input.GetKeyDown (KeyCode.S) && canBoost && state == PlayerState.Standing && !isJumping) {
			state = PlayerState.Boosting;
			canBoost = false;
			StartCoroutine (SlideTimer());
		} else if (state == PlayerState.Boosting) {
			if (facingRight) {
				newMovement = new Vector2 (slidePower, 0.0f);
			} else {
				newMovement = new Vector2 (-slidePower, 0.0f);
			}
		}

		rB.velocity = newMovement;

		ledgePos = new Vector3(0.0f, 0.0f, 0.0f);
		if (!GetCanJump() && canHang && state == PlayerState.Standing) {
			if (GetCanGrab (leftTransform, ref ledgePos, leftWalk)) {
				state = PlayerState.Hanging;
				canHang = false;
				facingRight = false;
				rB.velocity = Vector3.zero;
				rB.gravityScale = 0;
				StopCoroutine (SlideTimer());
			}
			else if (GetCanGrab (rightTransform, ref ledgePos, rightWalk))
			{
				state = PlayerState.Hanging;
				canHang = false;
				facingRight = true;
				rB.velocity = Vector3.zero;
				rB.gravityScale = 0;
				StopCoroutine (SlideTimer());
			}
		}
	}

	bool GetCanGrab(GameObject side, ref Vector3 ledgePos, GameObject grab)
	{
		bool bottomHit = false;
		bool topHit = false;
		bool downHit = false;

		CheckForSolidHit (transform.position + new Vector3(0.0f, 0.3f, 0.0f), side.transform.position + new Vector3(0.0f, 0.3f, 0.0f), ref topHit, false, true);

		float ledgeX = 0;
		ledgeX = CheckForSolidHit (transform.position - new Vector3(0.0f, 0.0f, 0.0f), side.transform.position - new Vector3(0.0f, 0.0f, 0.0f), 
									ref bottomHit, false, true).x - (grab.transform.position - transform.position).x;

		CheckForSolidHit (transform.position, downGrabTransform.transform.position, ref downHit, false, true);

		if (!topHit && bottomHit && !downHit) {
			float ledgeY = 0;

			ledgeY = CheckForSolidHit (side.transform.position + new Vector3(0.0f, 0.5f, 0.0f), side.transform.position - new Vector3(0.0f, 0.5f, 0.0f),
										ref bottomHit, false, true).y - (grab.transform.position - transform.position).y;
			
			ledgePos = new Vector3 (ledgeX, ledgeY, 0.0f);

			return true;
		}
		return false;
	}

	bool GetCanMove(GameObject side)
	{
		bool output = false;

		Vector2 sideCheck = new Vector2 (side.transform.position.x, transform.position.y);

		CheckForSolidHit (transform.position, sideCheck, ref output, false, false);
		CheckForSolidHit (transform.position, sideCheck + new Vector2(0.0f, 0.5f), ref output, false, false);
		CheckForSolidHit (transform.position, sideCheck + new Vector2(0.0f, -0.5f), ref output, true, false);

		return !output;
	}

	bool GetCanJump()
	{
		bool output = false;

		CheckForSolidHit (transform.position, groundTransform.transform.position, ref output, false, false);
		CheckForSolidHit (transform.position + new Vector3(0.25f, 0.0f, 0.0f), groundTransform.transform.position + new Vector3(0.25f, 0.0f, 0.0f), ref output, false, false);
		CheckForSolidHit (transform.position - new Vector3(0.25f, 0.0f, 0.0f), groundTransform.transform.position - new Vector3(0.25f, 0.0f, 0.0f), ref output, false, false);

		return output;
	}

	Vector2 CheckForSolidHit(Vector2 startPos, Vector2 endPos, ref bool output, bool ignoreSlope, bool ignoreMoveable)
	{
		float distance = Vector2.Distance(startPos, endPos);

		foreach (RaycastHit2D hit in Physics2D.RaycastAll(startPos, endPos - startPos, distance)) {
			if (hit.collider.gameObject != this.gameObject && hit.collider.isTrigger == false && !(ignoreSlope && hit.collider.gameObject.tag == "Slope") && !(ignoreMoveable && hit.collider.gameObject.tag == "Moveable")) {
				output = true;
				return hit.point;
			}
		}

		return Vector2.zero;
	}

    public bool GetIsHanging()
    {
		if (state == PlayerState.Hanging) {
			return true;
		}
        return false;
    }

	public void GetHit(int damage, Vector3 enemyPos, float knockback)
	{
		if (!isInvincible) {
			Instantiate(hitEffect, transform.position, Quaternion.AngleAxis(Random.Range(0.0f, 360.0f), transform.forward));
			Instantiate(hitEffect, transform.position, Quaternion.AngleAxis(Random.Range(0.0f, 360.0f), transform.forward));
			Instantiate(hitEffect, transform.position, Quaternion.AngleAxis(Random.Range(0.0f, 360.0f), transform.forward));
			Instantiate(flash, transform.position, Quaternion.identity);
			health -= (damage * (1.21f - statDefence));
			manager.SetPlayerHealth (health);
			sR.color = new Color (1.0f, 0.5f, 0.5f);
			if (state == PlayerState.Hanging) {
				StartCoroutine (HangTimer());
			}
			rB.gravityScale = 3;
			rB.velocity = Vector3.Normalize(new Vector3 (-(enemyPos.x - transform.position.x) * horizKnockback, -(enemyPos.y - transform.position.y) * vertKnockback, 0.0f)) * knockback;
			canMove = false;
			StartCoroutine (MoveTimer ());
			state = PlayerState.Standing;
			StopCoroutine (SlideTimer());
		}
	}

	public void Heal(float amountToHeal)
	{
		health += amountToHeal;
		manager.SetPlayerHealth(health);
	}

	// Timers
	IEnumerator InvincibleTimer()
	{
		yield return new WaitForSeconds (0.6f);
		isInvincible = false;
	}

    IEnumerator FreezeTimer()
    {
        yield return new WaitForSeconds(0.15f);
        rB.simulated = true;
        StartCoroutine(HitTimer());
    }

	IEnumerator SlideTimer()
	{
		yield return new WaitForSeconds (0.3f);
		state = PlayerState.Standing;
		rB.velocity = rB.velocity / 3.0f;
	}

	IEnumerator JumpTimer()
	{
		yield return new WaitForSeconds (baseJump + (baseJump * statJump));
		isJumping = false;
		
	}

	IEnumerator MoveTimer()
	{
		yield return new WaitForSeconds (0.3f);
		canMove = true;
	}

	IEnumerator HangTimer()
	{
		yield return new WaitForSeconds (0.3f);
		canHang = true;
	}

	IEnumerator HitTimer()
	{
		yield return new WaitForSeconds (baseAttackSpeed - (baseAttackSpeed * statAttackSpeed) + 0.05f);
		canHit = true;
	}

	IEnumerator ToolTimer()
	{
		yield return new WaitForSeconds (tools [currentTool].UseRate);
		canUseTool = true;
	}
}