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

public class TestPeaceMaker : CrewScript
{

	[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 Vector2 m_Zoom;
	[SerializeField] private Transform m_LaunchPoint;

	public override Transform centre
	{
		get
		{
			return m_Centre;
		}
	}

	public override Vector2 aimDirection
	{
		get
		{
			return m_AimDirection;
		}
	}

	public override Transform arrow
	{
		get
		{
			return m_Arrow.transform;
		}
	}

	public override Transform launchPoint
	{
		get
		{
			return m_LaunchPoint;
		}
	}

	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 Vector3 m_PreMouse;

	private Vector2 m_AimDirection;
	private Vector2 m_MoveDirection;

	private Vector3 m_TargetZoom;

	// 锁定瞄准，以移动方向为准
	private bool m_LockAim
	{
		get
		{
			return PlayerManager.Instance.lockAim;
		}
		set
		{
			PlayerManager.Instance.lockAim = value;
			EventCenter.Instance.Publish(EventMsgType.ToggleLockAim);
		}
	}

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

	void Start()
	{
		PlayerManager.Instance.SetCrew(this);

		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()
	{
		LockAim();

		bool isMove = Move();

		SetAim();

		bool isFire = PlayerManager.Instance.isFire;

		CameraFollow();

		CameraZoom(isFire);
	}

	void LockAim()
	{
		if(Input.GetButtonDown("LockAim"))
		{
			m_LockAim = !m_LockAim;
		}
	}

	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;

			m_MoveDirection = direction;

			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()
	{
		Vector2 dir = Vector2.zero;
		Vector2 centrePos = m_Centre.position;

		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 (m_LockAim && !bJoytick && !bMouse)
		{
			dir = m_MoveDirection;
		}
		else
		{
			m_LockAim = false;

			if (bJoytick)
			{
				m_ControlMode = ControlMode.Joystick;
				dir = new Vector2(xAxis, -yAxis).normalized;
			}
			if (bMouse)
			{
				m_ControlMode = ControlMode.Mouse;
				Vector2 camPos = GetCameraPosition();
				dir = (camPos - centrePos).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;
	}

}