using Core.Input;
using UnityEngine;

namespace Core.Camera
{
	/// <summary>
	/// Class to control the camera's behaviour. Camera rig currently operates best on terrain that is mostly on
	/// a single plane
	/// ÔÚÕâ¸öÀàÀïÃ棬»á¸ù¾Ý
	/// </summary>
	public class CameraRig : MonoBehaviour
	{
		/// <summary>
		/// Look dampening factor
		/// </summary>
		public float lookDampFactor;

		/// <summary>
		/// Movement dampening factor
		/// </summary>
		public float movementDampFactor;

		/// <summary>
		/// Nearest zoom level - can go a bit further than this on touch, for springiness
		/// </summary>
		public float nearestZoom = 15;

		/// <summary>
		/// Furthest zoom level - can go a bit further than this on touch, for springiness
		/// </summary>
		public float furthestZoom = 40;

		/// <summary>
		/// True maximum zoom level
		/// </summary>
		public float maxZoom = 60;

		/// <summary>
		/// Logarithm used to decay zoom beyond furthest
		/// </summary>
		public float zoomLogFactor = 10;

		/// <summary>
		/// How fast zoom recovers to normal
		/// </summary>
		public float zoomRecoverSpeed = 20;

		/// <summary>
		/// Y-height of the floor the camera is assuming
		/// </summary>
		public float floorY;

		/// <summary>
		/// Camera angle when fully zoomed in
		/// </summary>
		public Transform zoomedCamAngle;

		/// <summary>
		/// Map size, edited through the CameraRigEditor script in edit mode
		/// </summary>
		[HideInInspector]
		public Rect mapSize = new Rect(-10, -10, 20, 20);

		/// <summary>
		/// Is the zoom able to exceed its normal zoom extents with a rubber banding effect
		/// </summary>
		public bool springyZoom = true;

		/// <summary>
		/// Current look velocity of camera
		/// </summary>
		Vector3 m_CurrentLookVelocity;

		/// <summary>
		/// Rotations of camera at various zoom levels
		/// </summary>
		Quaternion m_MinZoomRotation;
		Quaternion m_MaxZoomRotation;

		/// <summary>
		/// Current camera velocity
		/// </summary>
		Vector3 m_CurrentCamVelocity;

		/// <summary>
		/// Current reusable floor plane
		/// </summary>
		Plane m_FloorPlane;

		public Plane floorPlane
		{
			get { return m_FloorPlane; }
		}

		/// <summary>
		/// Target position on the grid that we're looking at
		/// </summary>
		public Vector3 lookPosition { get; private set; }

		/// <summary>
		/// Current look position of camera
		/// </summary>
		public Vector3 currentLookPosition { get; private set; }

		/// <summary>
		/// Target position of the camera
		/// </summary>
		public Vector3 cameraPosition { get; private set; }

		/// <summary>
		/// Bounds of our look area, related to map size, zoom level and aspect ratio/screen size
		/// </summary>
		public Rect lookBounds { get; private set; }

		/// <summary>
		/// Gets our current zoom distance
		/// </summary>
		public float zoomDist { get; private set; }

		/// <summary>
		/// Gets our current internal zoom distance, before clamping and scaling is applied
		/// </summary>
		public float rawZoomDist { get; private set; }

		/// <summary>
		/// Gets the unit we're tracking if any
		/// </summary>
		public GameObject trackingObject { get; private set; }

		/// <summary>
		/// Cached camera component
		/// </summary>
		public UnityEngine.Camera cachedCamera { get; private set; }

		/// <summary>
		/// Initialize references and floor plane
		/// </summary>
		protected virtual void Awake()
		{
			cachedCamera = GetComponent<UnityEngine.Camera>();
			m_FloorPlane = new Plane(Vector3.up, new Vector3(0.0f, floorY, 0.0f));
			
			// Set initial values
			var lookRay = new Ray(cachedCamera.transform.position, cachedCamera.transform.forward);

			float dist;
			if (m_FloorPlane.Raycast(lookRay, out dist))
			{
				currentLookPosition = lookPosition = lookRay.GetPoint(dist);
			}
			cameraPosition = cachedCamera.transform.position;

			m_MinZoomRotation = Quaternion.FromToRotation(Vector3.up, -cachedCamera.transform.forward);
			m_MaxZoomRotation = Quaternion.FromToRotation(Vector3.up, -zoomedCamAngle.transform.forward);
			rawZoomDist = zoomDist = (currentLookPosition - cameraPosition).magnitude;
		}

		/// <summary>
		/// Setup initial zoom level and camera bounds
		/// </summary>
		protected virtual void Start()
		{
			RecalculateBoundingRect();
		}

		/// <summary>
		/// Handle camera behaviour
		/// </summary>
		protected virtual void Update()
		{
			RecalculateBoundingRect();

			// Tracking?
			if (trackingObject != null)
			{
				PanTo(trackingObject.transform.position);

				if (!trackingObject.activeInHierarchy)
				{
					StopTracking();
				}
			}

			// Approach look position
			currentLookPosition = Vector3.SmoothDamp(currentLookPosition, lookPosition, ref m_CurrentLookVelocity,
			                                         lookDampFactor);

			Vector3 worldPos = transform.position;
			worldPos = Vector3.SmoothDamp(worldPos, cameraPosition, ref m_CurrentCamVelocity,
			                              movementDampFactor);

			transform.position = worldPos;
			transform.LookAt(currentLookPosition);
		}

#if UNITY_EDITOR
		/// <summary>
		/// Debug bounds area gizmo
		/// </summary>
		void OnDrawGizmosSelected()
		{
			// We dont want to display this in edit mode
			if (!Application.isPlaying)
			{
				return;
			}
			if (cachedCamera == null)
			{
				cachedCamera = GetComponent<UnityEngine.Camera>();
			}
			RecalculateBoundingRect();

			Gizmos.color = Color.red;

			Gizmos.DrawLine(
				new Vector3(lookBounds.xMin, 0.0f, lookBounds.yMin),
				new Vector3(lookBounds.xMax, 0.0f, lookBounds.yMin));
			Gizmos.DrawLine(
				new Vector3(lookBounds.xMin, 0.0f, lookBounds.yMin),
				new Vector3(lookBounds.xMin, 0.0f, lookBounds.yMax));
			Gizmos.DrawLine(
				new Vector3(lookBounds.xMax, 0.0f, lookBounds.yMax),
				new Vector3(lookBounds.xMin, 0.0f, lookBounds.yMax));
			Gizmos.DrawLine(
				new Vector3(lookBounds.xMax, 0.0f, lookBounds.yMax),
				new Vector3(lookBounds.xMax, 0.0f, lookBounds.yMin));

			Gizmos.color = Color.yellow;

			Gizmos.DrawLine(transform.position, currentLookPosition);
		}
#endif

		/// <summary>
		/// Pans the camera to a specific position
		/// </summary>
		/// <param name="position">The look target</param>
		public void PanTo(Vector3 position)
		{
			Vector3 pos = position;

			// Look position is floor height
			pos.y = floorY;

			// Clamp to look bounds
			pos.x = Mathf.Clamp(pos.x, lookBounds.xMin, lookBounds.xMax);
			pos.z = Mathf.Clamp(pos.z, lookBounds.yMin, lookBounds.yMax);
			lookPosition = pos;

			// Camera position calculated from look position with view vector and zoom dist
			cameraPosition = lookPosition + (GetToCamVector() * zoomDist);
		}

		/// <summary>
		/// Cause the camera to follow a unit
		/// </summary>
		/// <param name="objectToTrack"></param>
		public void TrackObject(GameObject objectToTrack)
		{
			trackingObject = objectToTrack;
			PanTo(trackingObject.transform.position);
		}

		/// <summary>
		/// Stop tracking a unit
		/// </summary>
		public void StopTracking()
		{
			trackingObject = null;
		}

		/// <summary>
		/// Pan the camera
		/// </summary>
		/// <param name="panDelta">How far to pan the camera, in world space units</param>
		public void PanCamera(Vector3 panDelta)
		{
			// River mod: ÓÃÓÚÏÞÖÆÊó±êÒƶ¯µ½ÆÁÄ»±ßÔµºóÏà»úµÄÒƶ¯¡£
			return;
			/*
			Vector3 pos = lookPosition;
			pos += panDelta;

			// Clamp to look bounds
			pos.x = Mathf.Clamp(pos.x, lookBounds.xMin, lookBounds.xMax);
			pos.z = Mathf.Clamp(pos.z, lookBounds.yMin, lookBounds.yMax);
			lookPosition = pos;

			// Camera position calculated from look position with view vector and zoom dist
			cameraPosition = lookPosition + (GetToCamVector() * zoomDist);
			*/
		}

		/// <summary>
		/// Zoom the camera by a specified value
		/// </summary>
		/// <param name="zoomDelta">How far to zoom the camera</param>
		public void ZoomCameraRelative(float zoomDelta)
		{
			SetZoom(rawZoomDist + zoomDelta);
		}

		/// <summary>
		/// Zoom the camera to a specified value
		/// </summary>
		/// <param name="newZoom">The absolute zoom value</param>
		public void SetZoom(float newZoom)
		{
			if (springyZoom)
			{
				rawZoomDist = newZoom;

				if (newZoom > furthestZoom)
				{
					zoomDist = furthestZoom;
					zoomDist += Mathf.Log((Mathf.Min(rawZoomDist, maxZoom) - furthestZoom) + 1, zoomLogFactor);
				}
				else if (rawZoomDist < nearestZoom)
				{
					zoomDist = nearestZoom;
					zoomDist -= Mathf.Log((nearestZoom - rawZoomDist) + 1, zoomLogFactor);
				}
				else
				{
					zoomDist = rawZoomDist;
				}
			}
			else
			{
				zoomDist = rawZoomDist = Mathf.Clamp(newZoom, nearestZoom, furthestZoom);
			}

			// Update bounding rectangle, which is based on our zoom level
			RecalculateBoundingRect();

			// Force recalculated CameraPosition
			PanCamera(Vector3.zero);
		}

		/// <summary>
		/// Calculates the ray for a specified pointer in 3d space
		/// </summary>
		/// <param name="pointer">The pointer info</param>
		/// <returns>The ray representing a screen-space pointer in 3D space</returns>
		public Ray GetRayForPointer(PointerInfo pointer)
		{
			return cachedCamera.ScreenPointToRay(pointer.currentPosition);
		}

		/// <summary>
		/// Gets the screen position of a given world position
		/// </summary>
		/// <param name="worldPos">The world position</param>
		/// <returns>The screen position of that point</returns>
		public Vector3 GetScreenPos(Vector3 worldPos)
		{
			return cachedCamera.WorldToScreenPoint(worldPos);
		}

		/// <summary>
		/// Decay the zoom if it's beyond its zoom limits, for springiness
		/// </summary>
		public void ZoomDecay()
		{
			if (springyZoom)
			{
				if (rawZoomDist > furthestZoom)
				{
					float recover = rawZoomDist - furthestZoom;
					SetZoom(Mathf.Max(furthestZoom, rawZoomDist - (recover * zoomRecoverSpeed * Time.deltaTime)));
				}
				else if (rawZoomDist < nearestZoom)
				{
					float recover = nearestZoom - rawZoomDist;
					SetZoom(Mathf.Min(nearestZoom, rawZoomDist + (recover * zoomRecoverSpeed * Time.deltaTime)));
				}
			}
		}

		/// <summary>
		/// Returns our normalized zoom ratio
		/// </summary>
		public float CalculateZoomRatio()
		{
			return Mathf.Clamp01(Mathf.InverseLerp(nearestZoom, furthestZoom, zoomDist));
		}

		/// <summary>
		/// Gets the to camera vector based on our current zoom level
		/// </summary>
		Vector3 GetToCamVector()
		{
			float t = Mathf.Clamp01((zoomDist - nearestZoom) / (furthestZoom - nearestZoom));
			t = 1 - ((1 - t) * (1 - t));
			Quaternion interpolatedRotation = Quaternion.Slerp(
				m_MaxZoomRotation, m_MinZoomRotation,
				t);
			return interpolatedRotation * Vector3.up;
		}

		/// <summary>
		/// Update the size of our camera's bounding rectangle
		/// </summary>
		void RecalculateBoundingRect()
		{
			Rect mapsize = mapSize;

			// Get some world space projections at this zoom level
			// Temporarily move camera to final look position
			Vector3 prevCameraPos = transform.position;
			transform.position = cameraPosition;
			transform.LookAt(lookPosition);

			// Project screen corners and center
			var bottomLeftScreen = new Vector3(0, 0);
			var topLeftScreen = new Vector3(0, Screen.height);
			var centerScreen = new Vector3(Screen.width * 0.5f, Screen.height * 0.5f);

			Vector3 bottomLeftWorld = Vector3.zero;
			Vector3 topLeftWorld = Vector3.zero;
			Vector3 centerWorld = Vector3.zero;
			float dist;

			Ray ray = cachedCamera.ScreenPointToRay(bottomLeftScreen);
			if (m_FloorPlane.Raycast(ray, out dist))
			{
				bottomLeftWorld = ray.GetPoint(dist);
			}

			ray = cachedCamera.ScreenPointToRay(topLeftScreen);
			if (m_FloorPlane.Raycast(ray, out dist))
			{
				topLeftWorld = ray.GetPoint(dist);
			}

			ray = cachedCamera.ScreenPointToRay(centerScreen);
			if (m_FloorPlane.Raycast(ray, out dist))
			{
				centerWorld = ray.GetPoint(dist);
			}

			Vector3 toTopLeft = topLeftWorld - centerWorld;
			Vector3 toBottomLeft = bottomLeftWorld - centerWorld;

			lookBounds = new Rect(
				mapsize.xMin - toBottomLeft.x,
				mapsize.yMin - toBottomLeft.z,
				Mathf.Max(mapsize.width + (toBottomLeft.x * 2), 0),
				Mathf.Max((mapsize.height - toTopLeft.z) + toBottomLeft.z, 0));

			// Restore camera position
			transform.position = prevCameraPos;
			transform.LookAt(currentLookPosition);

			// River: ¶¯Ì¬µÄ´¦ÀíViewPortRect.
			float vpscale = 1920f / Screen.height;
			Rect vpRect = new Rect();
			vpRect.x = 0.0f;
			vpRect.y = (1.0f-vpscale)/2.0f;
			vpRect.width = 1f;
			vpRect.height = vpscale;
			cachedCamera.rect = vpRect;
		}
	}
}