using UnityEngine;
#if UNITY_EDITOR
using UnityEditor;
using UnityEditor.SceneManagement;
#if UNITY_2018_3_OR_NEWER
using PrefabStage = UnityEditor.SceneManagement.PrefabStage;
using PrefabStageUtility = UnityEditor.SceneManagement.PrefabStageUtility;
#endif
#endif

namespace BezierSolution
{
	[AddComponentMenu( "Bezier Solution/Bend Mesh Along Bezier" )]
	[HelpURL( "https://github.com/yasirkula/UnityBezierSolution" )]
	[RequireComponent( typeof( MeshFilter ) )]
	[ExecuteInEditMode]
	public class BendMeshAlongBezier : MonoBehaviour
	{
		public enum VectorMode { DontModify = 0, ModifyOriginals = 1, RecalculateFromScratch = 2 };
		public enum Axis { X = 0, Y = 1, Z = 2 };

#pragma warning disable 0649
		[SerializeField]
		private BezierSpline m_spline;
		public BezierSpline spline
		{
			get { return m_spline; }
			set
			{
				if( m_spline != value )
				{
					if( m_spline )
						m_spline.onSplineChanged -= OnSplineChanged;

					m_spline = value;

					if( m_spline && isActiveAndEnabled )
					{
						m_spline.onSplineChanged -= OnSplineChanged;
						m_spline.onSplineChanged += OnSplineChanged;

						OnSplineChanged( m_spline, DirtyFlags.All );
					}
				}
			}
		}

		[SerializeField]
		[MinMaxRange( 0f, 1f )]
		private Vector2 m_splineSampleRange = new Vector2( 0f, 1f );
		public Vector2 SplineSampleRange
		{
			get { return m_splineSampleRange; }
			set
			{
				value.x = Mathf.Clamp01( value.x );
				value.y = Mathf.Clamp01( value.y );

				if( m_splineSampleRange != value )
				{
					m_splineSampleRange = value;
					OnSplineChanged( m_spline, DirtyFlags.All );
				}
			}
		}

		[Header( "Bend Options" )]
		[SerializeField]
		private bool m_highQuality = false;
		public bool highQuality
		{
			get { return m_highQuality; }
			set
			{
				if( m_highQuality != value )
				{
					m_highQuality = value;
					OnSplineChanged( m_spline, DirtyFlags.All );
				}
			}
		}

		[SerializeField]
		private Axis m_bendAxis = Axis.Y;
		public Axis bendAxis
		{

			get { return m_bendAxis; }
			set
			{
				if( m_bendAxis != value )
				{
					m_bendAxis = value;

					RecalculateVertexRange();
					OnSplineChanged( m_spline, DirtyFlags.All );
				}
			}
		}

		[SerializeField]
		[Range( 0f, 360f )]
		private float m_extraRotation = 0f;
		public float extraRotation
		{
			get { return m_extraRotation; }
			set
			{
				value = Mathf.Clamp( value, 0f, 360f );

				if( m_extraRotation != value )
				{
					m_extraRotation = value;
					OnSplineChanged( m_spline, DirtyFlags.All );
				}
			}
		}

		[SerializeField]
		private bool m_invertDirection = false;
		public bool invertDirection
		{
			get { return m_invertDirection; }
			set
			{
				if( m_invertDirection != value )
				{
					m_invertDirection = value;
					OnSplineChanged( m_spline, DirtyFlags.All );
				}
			}
		}

		[SerializeField]
		private Vector2 m_thicknessMultiplier = Vector2.one;
		public Vector2 thicknessMultiplier
		{
			get { return m_thicknessMultiplier; }
			set
			{
				if( m_thicknessMultiplier != value )
				{
					m_thicknessMultiplier = value;
					OnSplineChanged( m_spline, DirtyFlags.All );
				}
			}
		}

		[Header( "Vertex Attributes" )]
		[SerializeField]
		private VectorMode m_normalsMode = VectorMode.ModifyOriginals;
		public VectorMode normalsMode
		{
			get { return m_normalsMode; }
			set
			{
				if( m_normalsMode != value )
				{
					m_normalsMode = value;

					if( mesh )
					{
						if( m_normalsMode == VectorMode.DontModify && originalNormals != null )
						{
							mesh.normals = originalNormals;
							originalNormals = null;
						}

						if( m_normalsMode != VectorMode.ModifyOriginals )
							normals = null;
					}

					OnSplineChanged( m_spline, DirtyFlags.All );
				}
			}
		}

		[SerializeField]
		private VectorMode m_tangentsMode = VectorMode.ModifyOriginals;
		public VectorMode tangentsMode
		{
			get { return m_tangentsMode; }
			set
			{
				if( m_tangentsMode != value )
				{
					m_tangentsMode = value;

					if( mesh )
					{
						if( m_tangentsMode == VectorMode.DontModify && originalTangents != null )
						{
							mesh.tangents = originalTangents;
							originalTangents = null;
						}

						if( m_tangentsMode != VectorMode.ModifyOriginals )
							tangents = null;
					}

					OnSplineChanged( m_spline, DirtyFlags.All );
				}
			}
		}

		[Header( "Other Settings" )]
		[SerializeField]
		private bool m_autoRefresh = true;
		public bool autoRefresh
		{
			get { return m_autoRefresh; }
			set
			{
				if( m_autoRefresh != value )
				{
					m_autoRefresh = value;
					OnSplineChanged( m_spline, DirtyFlags.All );
				}
			}
		}

#if UNITY_EDITOR
		[SerializeField]
		private bool executeInEditMode = false;

		[SerializeField, HideInInspector]
		private BezierSpline prevSpline;
		[SerializeField, HideInInspector]
		private VectorMode prevNormalsMode, prevTangentsMode;
		[SerializeField, HideInInspector]
		private bool prevHighQuality;
#endif

		[SerializeField, HideInInspector]
		private Mesh originalMesh; // If this isn't serialized, then sometimes exceptions occur on undo/redo
#pragma warning restore 0649

		private MeshFilter meshFilter;

		private Mesh mesh;
		private Vector3[] vertices, originalVertices;
		private Vector3[] normals, originalNormals;
		private Vector4[] tangents, originalTangents;

		private float minVertex, _1OverVertexRange;

		private void OnEnable()
		{
#if UNITY_EDITOR
			// Restore normals and tangents after assembly reload if they are set to DontModify because otherwise they become null automatically (i.e. information gets lost)
			if( mesh && originalMesh )
			{
				if( m_normalsMode == VectorMode.DontModify )
					mesh.normals = originalMesh.normals;
				if( m_tangentsMode == VectorMode.DontModify )
					mesh.tangents = originalMesh.tangents;
			}

			EditorSceneManager.sceneSaving -= OnSceneSaving;
			EditorSceneManager.sceneSaving += OnSceneSaving;
			EditorSceneManager.sceneSaved -= OnSceneSaved;
			EditorSceneManager.sceneSaved += OnSceneSaved;
#endif

			if( m_spline )
			{
				m_spline.onSplineChanged -= OnSplineChanged;
				m_spline.onSplineChanged += OnSplineChanged;

				OnSplineChanged( m_spline, DirtyFlags.All );
			}
		}

		private void OnDisable()
		{
			if( m_spline )
				m_spline.onSplineChanged -= OnSplineChanged;

#if UNITY_EDITOR
			EditorSceneManager.sceneSaving -= OnSceneSaving;
			EditorSceneManager.sceneSaved -= OnSceneSaved;

			if( !EditorApplication.isPlaying )
				OnDestroy();
#endif
		}

		private void OnDestroy()
		{
			MeshFilter _meshFilter = meshFilter;
			meshFilter = null;

			if( _meshFilter && originalMesh )
				_meshFilter.sharedMesh = originalMesh;

			if( mesh )
				DestroyImmediate( mesh );

#if UNITY_EDITOR && UNITY_2018_3_OR_NEWER
			// This allows removing the 'modified' flag of Mesh Filter's Mesh property but these sorts of things
			// may cause new problems in edge cases so it is commented out
			//if( !EditorApplication.isPlaying && _meshFilter && originalMesh )
			//{
			//	// Revert modified status of the prefab instance's MeshFilter Mesh if possible
			//	MeshFilter prefabMeshFilter = null;
			//	if( PrefabUtility.GetPrefabInstanceStatus( _meshFilter ) == PrefabInstanceStatus.Connected )
			//		prefabMeshFilter = PrefabUtility.GetCorrespondingObjectFromSource( _meshFilter ) as MeshFilter;

			//	if( prefabMeshFilter && prefabMeshFilter.sharedMesh == originalMesh )
			//		PrefabUtility.RevertPropertyOverride( new SerializedObject( _meshFilter ).FindProperty( "m_Mesh" ), InteractionMode.AutomatedAction );
			//}
#endif
		}

		public void Activate()
		{
			enabled = true;
		}

		public void Deactivate()
		{
			OnDestroy();
			enabled = false;
		}

#if UNITY_EDITOR
		private void OnValidate()
		{
			EditorApplication.update -= OnValidateImplementation;
			EditorApplication.update += OnValidateImplementation;
		}

		// Calling this code inside OnValidate throws "SendMessage cannot be called during Awake, CheckConsistency, or OnValidate" warnings
		private void OnValidateImplementation()
		{
			EditorApplication.update -= OnValidateImplementation;

			if( !this )
				return;

			BezierSpline _spline = m_spline;
			m_spline = prevSpline;
			spline = prevSpline = _spline;

			bool _highQuality = m_highQuality;
			m_highQuality = prevHighQuality;
			highQuality = prevHighQuality = _highQuality;

			VectorMode _normalsMode = m_normalsMode;
			m_normalsMode = prevNormalsMode;
			normalsMode = prevNormalsMode = _normalsMode;

			VectorMode _tangentsMode = m_tangentsMode;
			m_tangentsMode = prevTangentsMode;
			tangentsMode = prevTangentsMode = _tangentsMode;

			RecalculateVertexRange();

			if( !executeInEditMode && !EditorApplication.isPlaying )
				OnDestroy();
			else if( isActiveAndEnabled )
				OnSplineChanged( m_spline, DirtyFlags.All );

			SceneView.RepaintAll();
		}

		private void OnSceneSaving( UnityEngine.SceneManagement.Scene scene, string path )
		{
			// Restore original mesh before saving the scene
			if( scene == gameObject.scene )
				OnDestroy();
		}

		private void OnSceneSaved( UnityEngine.SceneManagement.Scene scene )
		{
			// Restore modified mesh after saving the scene
			if( scene == gameObject.scene && isActiveAndEnabled )
				OnSplineChanged( m_spline, DirtyFlags.All );
		}
#endif

		private void OnSplineChanged( BezierSpline spline, DirtyFlags dirtyFlags )
		{
#if UNITY_EDITOR
			if( !executeInEditMode && !EditorApplication.isPlaying )
				return;

			if( BuildPipeline.isBuildingPlayer )
				return;

#if UNITY_2018_3_OR_NEWER
			// Don't execute the script in prefab mode
			UnityEditor.SceneManagement.PrefabStage openPrefabStage = UnityEditor.SceneManagement.PrefabStageUtility.GetCurrentPrefabStage();
			if( openPrefabStage != null && openPrefabStage.IsPartOfPrefabContents( gameObject ) )
				return;
#endif
#endif

			if( m_autoRefresh && ( dirtyFlags & ( DirtyFlags.SplineShapeChanged | DirtyFlags.NormalsChanged ) ) != DirtyFlags.None )
				Refresh();
		}

		private void Initialize()
		{
			meshFilter = GetComponent<MeshFilter>();
			if( meshFilter.sharedMesh ) // It can sometimes be null during undo&redo which causes issues
				originalMesh = meshFilter.sharedMesh;

			if( !originalMesh )
				return;

			if( mesh )
				DestroyImmediate( mesh );

			mesh = Instantiate( originalMesh );
			meshFilter.sharedMesh = mesh;

#if UNITY_EDITOR
			if( !EditorApplication.isPlaying )
				mesh.hideFlags = HideFlags.DontSave;
#endif

			originalVertices = mesh.vertices;
			originalNormals = null;
			originalTangents = null;

			RecalculateVertexRange();
		}

		private void RecalculateVertexRange()
		{
			if( originalVertices == null )
				return;

			minVertex = float.PositiveInfinity;
			float maxVertex = float.NegativeInfinity;

			switch( m_bendAxis )
			{
				case Axis.X:
					for( int i = 0; i < originalVertices.Length; i++ )
					{
						float vertex = originalVertices[i].x;
						if( vertex < minVertex )
							minVertex = originalVertices[i].x;
						if( vertex > maxVertex )
							maxVertex = originalVertices[i].x;
					}
					break;
				case Axis.Y:
					for( int i = 0; i < originalVertices.Length; i++ )
					{
						float vertex = originalVertices[i].y;
						if( vertex < minVertex )
							minVertex = originalVertices[i].y;
						if( vertex > maxVertex )
							maxVertex = originalVertices[i].y;
					}
					break;
				case Axis.Z:
					for( int i = 0; i < originalVertices.Length; i++ )
					{
						float vertex = originalVertices[i].z;
						if( vertex < minVertex )
							minVertex = originalVertices[i].z;
						if( vertex > maxVertex )
							maxVertex = originalVertices[i].z;
					}
					break;
			}

			_1OverVertexRange = 1f / ( maxVertex - minVertex );
		}

		public void Refresh()
		{
			if( !m_spline )
				return;

			if( !meshFilter || ( meshFilter.sharedMesh && meshFilter.sharedMesh != mesh && meshFilter.sharedMesh != originalMesh ) )
				Initialize();

			if( !originalMesh )
				return;

			if( vertices == null || vertices.Length != originalVertices.Length )
				vertices = new Vector3[originalVertices.Length];

			if( m_normalsMode == VectorMode.ModifyOriginals )
			{
				if( originalNormals == null )
					originalNormals = originalMesh.normals;

				if( originalNormals == null || originalNormals.Length < originalVertices.Length ) // If somehow above statement returned null
					normals = null;
				else if( normals == null || normals.Length != originalNormals.Length )
					normals = new Vector3[originalNormals.Length];
			}
			else
				normals = null;

			if( m_tangentsMode == VectorMode.ModifyOriginals )
			{
				if( originalTangents == null )
					originalTangents = originalMesh.tangents;

				if( originalTangents == null || originalTangents.Length < originalVertices.Length ) // If somehow above statement returned null
					tangents = null;
				else if( tangents == null || tangents.Length != originalTangents.Length )
					tangents = new Vector4[originalTangents.Length];
			}
			else
				tangents = null;

			Vector2 _splineSampleRange = m_splineSampleRange;
			if( m_invertDirection )
			{
				float temp = _splineSampleRange.x;
				_splineSampleRange.x = _splineSampleRange.y;
				_splineSampleRange.y = temp;
			}

			bool isSampleRangeForwards = _splineSampleRange.x <= _splineSampleRange.y;
			float splineSampleLength = _splineSampleRange.y - _splineSampleRange.x;
			bool dontInvertModifiedVertexAttributes = ( m_thicknessMultiplier.x > 0f && m_thicknessMultiplier.y > 0f );

			BezierSpline.EvenlySpacedPointsHolder evenlySpacedPoints = m_highQuality ? m_spline.evenlySpacedPoints : null;

			Vector3 initialPoint = m_spline.GetPoint( 0f );
			for( int i = 0; i < originalVertices.Length; i++ )
			{
				Vector3 vertex = originalVertices[i];

				float vertexPosition;
				Vector3 vertexOffset;
				switch( m_bendAxis )
				{
					case Axis.X:
						vertexPosition = vertex.x;
						vertexOffset = new Vector3( vertex.z * m_thicknessMultiplier.x, 0f, vertex.y * m_thicknessMultiplier.y );
						break;
					case Axis.Y:
					default:
						vertexPosition = vertex.y;
						vertexOffset = new Vector3( vertex.x * m_thicknessMultiplier.x, 0f, vertex.z * m_thicknessMultiplier.y );
						break;
					case Axis.Z:
						vertexPosition = vertex.z;
						vertexOffset = new Vector3( vertex.y * m_thicknessMultiplier.x, 0f, vertex.x * m_thicknessMultiplier.y );
						break;
				}

				float normalizedT = _splineSampleRange.x + ( vertexPosition - minVertex ) * _1OverVertexRange * splineSampleLength; // Remap from [minVertex,maxVertex] to _splineSampleRange
				if( m_highQuality )
					normalizedT = evenlySpacedPoints.GetNormalizedTAtPercentage( normalizedT );

				BezierSpline.Segment segment = m_spline.GetSegmentAt( normalizedT );

				Vector3 point = segment.GetPoint() - initialPoint;
				Vector3 tangent = isSampleRangeForwards ? segment.GetTangent() : -segment.GetTangent();
				Quaternion rotation = Quaternion.AngleAxis( m_extraRotation, tangent ) * Quaternion.LookRotation( segment.GetNormal(), tangent );

				Vector3 direction = rotation * vertexOffset;
				vertices[i] = point + direction;

				if( normals != null ) // The only case this happens is when Normals Mode is ModifyOriginals and the original mesh has normals
					normals[i] = rotation * ( dontInvertModifiedVertexAttributes ? originalNormals[i] : -originalNormals[i] );
				if( tangents != null ) // The only case this happens is when Tangents Mode is ModifyOriginals and the original mesh has tangents
				{
					float tangentW = originalTangents[i].w;
					tangents[i] = rotation * ( dontInvertModifiedVertexAttributes ? originalTangents[i] : -originalTangents[i] );
					tangents[i].w = tangentW;
				}
			}

			mesh.vertices = vertices;
			if( m_normalsMode == VectorMode.ModifyOriginals )
				mesh.normals = normals;
			if( m_tangentsMode == VectorMode.ModifyOriginals )
				mesh.tangents = tangents;

			if( m_normalsMode == VectorMode.RecalculateFromScratch )
			{
				mesh.RecalculateNormals();

#if UNITY_EDITOR
				// Cache original normals so that we can reset normals in OnValidate when normals are reset back to DontModify
				if( originalNormals == null )
					originalNormals = originalMesh.normals;
#endif
			}

			if( m_tangentsMode == VectorMode.RecalculateFromScratch )
			{
				mesh.RecalculateTangents();

#if UNITY_EDITOR
				// Cache original tangents so that we can reset tangents in OnValidate when tangents are reset back to DontModify
				if( originalTangents == null )
					originalTangents = originalMesh.tangents;
#endif
			}

			mesh.RecalculateBounds();
		}
	}
}