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

public class TestPeaceMaker : MonoBehaviour
{

	[SerializeField] private Transform m_Camera;
	[SerializeField] private float m_Speed;
	[SerializeField] private Transform m_Centre;
	[SerializeField] private SpriteRenderer m_Arrow;
	[SerializeField] private float m_ArrowRadius;
	[SerializeField] private TestPeaceMakerBullet m_Bullet;
	[SerializeField] private TestPeaceMakerGrenade m_Grenade;
	[SerializeField] private Vector2 m_Zoom;
	[SerializeField] private GameObject m_LaunchVfx;
	[SerializeField] private Transform m_LaunchPoint;
	[SerializeField] private TestB2 m_B2;
	[SerializeField] private TestSpaceBeam m_SpaceBeam;

	private Vector3 zoomIn
	{
		get
		{
			Vector3 zin = new Vector3(m_Zoom.x, m_Zoom.x, 1);
			return zin;
		}
	}
	private Vector3 zoomOut
	{
		get
		{
			Vector3 zout = new Vector3(m_Zoom.y, m_Zoom.y, 1);
			return zout;
		}
	}

	private TopDownShadowCaster m_Shadow;

	private SpriteRenderer m_SpriteRenderer;
	private TopDownTransform m_Coord;
	private Coroutine m_CoFire;
	private Coroutine m_CoLaunchGrenade;

	private Vector3 m_PreMouse;

	private Vector2 m_AimDirection;

	private Vector3 m_TargetZoom;

	private enum ControlMode
	{
		Mouse, 
		Joystick,
	}
	private ControlMode m_ControlMode;

	void Start()
	{
		m_SpriteRenderer = GetComponent<SpriteRenderer>();
		m_Coord = GetComponent<TopDownTransform>();

		m_ControlMode = ControlMode.Mouse;
		m_AimDirection = Vector2.zero;

		m_TargetZoom = new Vector3(m_Zoom.x, m_Zoom.x, 1);

		m_Shadow = GetComponent<TopDownShadowCaster>();
	}

	void Update()
	{
		bool isMove = Move();

		SetAim();

		bool isFire = Fire();
		bool isGrenade = LaunchGrenade();
		bool isBeam = SpaceBeam();

		CallB2();

		CameraFollow();

		CameraZoom(/*isMove ||*/ isFire || isGrenade /*|| isBeam*/);
	}

	void CameraZoom(bool zout)
	{
		if(zout)
		{
			m_TargetZoom = zoomOut;
			m_Camera.localScale = Vector3.Lerp(m_Camera.localScale, m_TargetZoom, 0.25f);
		}
		else
		{
			m_TargetZoom = zoomIn;
			m_Camera.localScale = Vector3.Lerp(m_Camera.localScale, m_TargetZoom, /*Time.deltaTime * 2f*/0.25f);
		}
	}

	void CameraFollow()
	{
		Vector3 pos = m_Camera.position;
		pos.x = m_Coord.x;
		pos.y = m_Coord.y;

		if (Vector3.Distance(pos, m_Camera.position) > 0.1f)
		{
			m_Camera.position = Vector3.Lerp(m_Camera.position, pos, 3 * Time.deltaTime);
		}
	}

	bool Move()
	{
		float x = Input.GetAxisRaw("Horizontal");
		float y = Input.GetAxisRaw("Vertical");

		bool isMove = x != 0 || y != 0;

		if (isMove)
		{
			Vector2 direction = new Vector2(x, y).normalized;

			Vector3 position = m_Coord.position;
			position.x += direction.x * m_Speed * Time.deltaTime;
			position.y += direction.y * m_Speed * Time.deltaTime;

			m_Coord.position = position;

			if (x > 0)
			{
				m_SpriteRenderer.flipX = false;
				m_Shadow.Flip(false);
			}
			else if (x < 0)
			{
				m_SpriteRenderer.flipX = true;
				m_Shadow.Flip(true);
			}
		}

		return isMove;
	}

	void SetAim()
	{
		float xAxis = Input.GetAxisRaw("AimHorizontal");
		float yAxis = Input.GetAxisRaw("AimVertical");

		bool bJoytick = xAxis != 0 || yAxis != 0;

		bool bMouse = (Input.mousePosition - m_PreMouse).magnitude > 0.01f;
		m_PreMouse = Input.mousePosition;

		if(bJoytick)
		{
			m_ControlMode = ControlMode.Joystick;
		}
		if(bMouse)
		{
			m_ControlMode = ControlMode.Mouse;
		}

		Vector2 centrePos = m_Centre.position;
		Vector2 dir = Vector2.zero;
		if (m_ControlMode == ControlMode.Mouse)
		{
			Vector2 camPos = GetCameraPosition();
			dir = (camPos - centrePos).normalized;
		}
		else
		{
			dir = new Vector2(xAxis, -yAxis).normalized;
		}

		if(dir.magnitude > 0)
		{
			m_AimDirection = dir;
			Vector2 arrowPos = centrePos + m_ArrowRadius * m_AimDirection;
			m_Arrow.transform.position = new Vector3(arrowPos.x, arrowPos.y, m_Arrow.transform.position.z);
			m_Arrow.transform.rotation = Quaternion.Euler(0, 0, Mathf.Atan2(m_AimDirection.y, m_AimDirection.x) * Mathf.Rad2Deg);
		}
	}

	Vector2 GetCameraPosition()
	{
		Vector3 screenPos = Input.mousePosition;
		Vector2 target = Camera.main.ScreenToWorldPoint(screenPos);
		return target;
	}

	bool Fire()
	{
		if (Input.GetButtonDown("Fire1") || (Input.GetAxis("GunTrigger") == 1))
		{
			if (m_CoFire == null)
			{
				m_CoFire = StartCoroutine(coFire(0.1f));
			}
		}
		if (!Input.GetButton("Fire1") && (Input.GetAxis("GunTrigger") == 0))
		{
			if(m_CoFire != null)
			{
				StopCoroutine(m_CoFire);
				m_CoFire = null;
			}
			return false;
		}
		return true;
	}

	bool LaunchGrenade()
	{
		if (Input.GetButtonDown("Fire2") || (Input.GetAxis("BombTrigger") == 1))
		{
			if (m_CoLaunchGrenade == null)
			{
				m_CoLaunchGrenade = StartCoroutine(coLaunchGrenade(0.2f));
			}
		}
		if (!Input.GetButton("Fire2") && (Input.GetAxis("BombTrigger") == 0))
		{
			if (m_CoLaunchGrenade != null)
			{
				StopCoroutine(m_CoLaunchGrenade);
				m_CoLaunchGrenade = null;
			}
			return false;
		}
		return true;
	}

	IEnumerator coFire(float interval)
	{
		while (true)
		{
			CreateBullet(m_AimDirection, 12f, 2f);
			//CreateBullet(TestMathHelper.Rotate(m_AimDirection, 10 * Mathf.Deg2Rad), 12f, 2f);
			//CreateBullet(TestMathHelper.Rotate(m_AimDirection, -10 * Mathf.Deg2Rad), 12f, 2f);

			yield return new WaitForSeconds(interval);
		}
	}

	TestPeaceMakerBullet CreateBullet(Vector2 dir, float speed, float lifeTime)
	{
		TestPeaceMakerBullet bullet = Instantiate<TestPeaceMakerBullet>(m_Bullet);

		bullet.transform.position = m_Arrow.transform.position + new Vector3(m_AimDirection.x, m_AimDirection.y, 0) * -0.3f;

		bullet.Set(dir, speed, lifeTime);
		bullet.gameObject.SetActive(true);

		return bullet;
	}


	Vector3 GetRandomLaunchGrenadeDirection()
	{
		Vector3 dirOnPlane = Quaternion.Euler(0, 0, Random.Range(-15f, 15f)) * new Vector3(m_AimDirection.x, m_AimDirection.y, 0);
		dirOnPlane = dirOnPlane.normalized;
		Vector3 dir = new Vector3(dirOnPlane.x, dirOnPlane.y, Random.Range(0f, 1f)).normalized;
		return dir.normalized;
	}

	IEnumerator coLaunchGrenade(float interval)
	{
		while (true)
		{
			// grenade 
			TestPeaceMakerGrenade grenade = Instantiate<TestPeaceMakerGrenade>(m_Grenade);
			Vector3 position = m_Coord.position + new Vector3(0, 0, 1.8f);
			grenade.Set(position, GetRandomLaunchGrenadeDirection(), Random.Range(8f, 10f));
			grenade.gameObject.SetActive(true);

			// vfx
			GameObject eff = Instantiate<GameObject>(m_LaunchVfx, this.transform);
			eff.transform.position = m_LaunchPoint.transform.position;
			eff.SetActive(true);

			yield return new WaitForSeconds(interval);
		}
	}

	void CallB2()
	{
		if(Input.GetButtonDown("Fire3"))
		{
			TestB2 b2 = Instantiate<TestB2>(m_B2);

			Vector3 pos3D = m_Coord.GetProjectedPosition();
			b2.Set(pos3D + new Vector3(-15, 0,0 ), pos3D + new Vector3(15, 0,0 ), 20f, 3f);
		}
	}

	bool SpaceBeam()
	{
		if (Input.GetButtonDown("SpaceBeam"))
		{
			TestSpaceBeam beam = Instantiate<TestSpaceBeam>(m_SpaceBeam);

			Vector3 pos3D = m_Coord.position;
			beam.Set(pos3D + new Vector3(3, 0, 0));

			TinyCountDown.Instance.Set("SpaceBeam", 0.1f);
			return true;
		}
		return TinyCountDown.Instance.Get("SpaceBeam") > 0;
	}

}