/******************************************************************************
 * Spine Runtimes License Agreement
 * Last updated July 28, 2023. Replaces all prior versions.
 *
 * Copyright (c) 2013-2023, Esoteric Software LLC
 *
 * Integration of the Spine Runtimes into software or otherwise creating
 * derivative works of the Spine Runtimes is permitted under the terms and
 * conditions of Section 2 of the Spine Editor License Agreement:
 * http://esotericsoftware.com/spine-editor-license
 *
 * Otherwise, it is permitted to integrate the Spine Runtimes into software or
 * otherwise create derivative works of the Spine Runtimes (collectively,
 * "Products"), provided that each user of the Products must obtain their own
 * Spine Editor license and redistribution of the Products in any form must
 * include this license and copyright notice.
 *
 * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
 * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/

#if UNITY_2018_3 || UNITY_2019 || UNITY_2018_3_OR_NEWER
#define NEW_PREFAB_SYSTEM
#endif

#if UNITY_2019_3_OR_NEWER
#define SET_VERTICES_HAS_LENGTH_PARAMETER
#endif

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

namespace Spine.Unity.Examples {

#if NEW_PREFAB_SYSTEM
	[ExecuteAlways]
#else
	[ExecuteInEditMode]
#endif
	public class RenderCombinedMesh : MonoBehaviour {
		public SkeletonRenderer skeletonRenderer;
		public SkeletonRenderSeparator renderSeparator;
		public MeshRenderer[] referenceRenderers;

		bool updateViaSkeletonCallback = false;
		MeshFilter[] referenceMeshFilters;
		MeshRenderer ownRenderer;
		MeshFilter ownMeshFilter;

		protected DoubleBuffered<Mesh> doubleBufferedMesh;
		protected ExposedList<Vector3> positionBuffer;
		protected ExposedList<Color32> colorBuffer;
		protected ExposedList<Vector2> uvBuffer;
		protected ExposedList<int> indexBuffer;

#if UNITY_EDITOR
		private void Reset () {
			if (skeletonRenderer == null)
				skeletonRenderer = this.GetComponentInParent<SkeletonRenderer>();
			GatherRenderers();

			Awake();
			if (referenceRenderers.Length > 0)
				ownRenderer.sharedMaterial = referenceRenderers[0].sharedMaterial;

			LateUpdate();
		}
#endif
		protected void GatherRenderers () {
			referenceRenderers = this.GetComponentsInChildren<MeshRenderer>();
			if (referenceRenderers.Length == 0 ||
				(referenceRenderers.Length == 1 && referenceRenderers[0].gameObject == this.gameObject)) {
				Transform parent = this.transform.parent;
				if (parent)
					referenceRenderers = parent.GetComponentsInChildren<MeshRenderer>();
			}
			referenceRenderers = referenceRenderers.Where(
				(val, idx) => val.gameObject != this.gameObject && val.enabled).ToArray();
		}

		void Awake () {
			if (skeletonRenderer == null)
				skeletonRenderer = this.GetComponentInParent<SkeletonRenderer>();
			if (referenceRenderers == null || referenceRenderers.Length == 0) {
				GatherRenderers();
			}

			if (renderSeparator == null) {
				if (skeletonRenderer)
					renderSeparator = skeletonRenderer.GetComponent<SkeletonRenderSeparator>();
				else
					renderSeparator = this.GetComponentInParent<SkeletonRenderSeparator>();
			}

			int count = referenceRenderers.Length;
			referenceMeshFilters = new MeshFilter[count];
			for (int i = 0; i < count; ++i) {
				referenceMeshFilters[i] = referenceRenderers[i].GetComponent<MeshFilter>();
			}

			ownRenderer = this.GetComponent<MeshRenderer>();
			if (ownRenderer == null)
				ownRenderer = this.gameObject.AddComponent<MeshRenderer>();
			ownMeshFilter = this.GetComponent<MeshFilter>();
			if (ownMeshFilter == null)
				ownMeshFilter = this.gameObject.AddComponent<MeshFilter>();
		}

		void OnEnable () {
#if UNITY_EDITOR
			if (Application.isPlaying)
				Awake();
#endif
			if (skeletonRenderer) {
				skeletonRenderer.OnMeshAndMaterialsUpdated -= UpdateOnCallback;
				skeletonRenderer.OnMeshAndMaterialsUpdated += UpdateOnCallback;
				updateViaSkeletonCallback = true;
			}
			if (renderSeparator) {
				renderSeparator.OnMeshAndMaterialsUpdated -= UpdateOnCallback;
				renderSeparator.OnMeshAndMaterialsUpdated += UpdateOnCallback;
				updateViaSkeletonCallback = true;
			}
		}

		void OnDisable () {
			if (skeletonRenderer)
				skeletonRenderer.OnMeshAndMaterialsUpdated -= UpdateOnCallback;
			if (renderSeparator)
				renderSeparator.OnMeshAndMaterialsUpdated -= UpdateOnCallback;
		}

		void OnDestroy () {
			for (int i = 0; i < 2; ++i) {
				Mesh mesh = doubleBufferedMesh.GetNext();
#if UNITY_EDITOR
				if (Application.isEditor && !Application.isPlaying)
					UnityEngine.Object.DestroyImmediate(mesh);
				else
					UnityEngine.Object.Destroy(mesh);
#else
				UnityEngine.Object.Destroy(mesh);
#endif
			}
		}

		void LateUpdate () {
#if UNITY_EDITOR
			if (!Application.isPlaying) {
				UpdateMesh();
				return;
			}
#endif

			if (updateViaSkeletonCallback)
				return;
			UpdateMesh();
		}

		void UpdateOnCallback (SkeletonRenderer r) {
			UpdateMesh();
		}

		protected void EnsureBufferSizes (int combinedVertexCount, int combinedIndexCount) {
			if (positionBuffer == null) {
				positionBuffer = new ExposedList<Vector3>(combinedVertexCount);
				uvBuffer = new ExposedList<Vector2>(combinedVertexCount);
				colorBuffer = new ExposedList<Color32>(combinedVertexCount);
				indexBuffer = new ExposedList<int>(combinedIndexCount);
			}

			if (positionBuffer.Count != combinedVertexCount) {
				positionBuffer.Resize(combinedVertexCount);
				uvBuffer.Resize(combinedVertexCount);
				colorBuffer.Resize(combinedVertexCount);
			}
			if (indexBuffer.Count != combinedIndexCount) {
				indexBuffer.Resize(combinedIndexCount);
			}
		}

		void InitMesh () {
			if (doubleBufferedMesh == null) {
				doubleBufferedMesh = new DoubleBuffered<Mesh>();
				for (int i = 0; i < 2; ++i) {
					Mesh combinedMesh = doubleBufferedMesh.GetNext();
					combinedMesh.MarkDynamic();
					combinedMesh.name = "RenderCombinedMesh" + i;
					combinedMesh.subMeshCount = 1;
				}
			}
		}

		void UpdateMesh () {
			InitMesh();
			int combinedVertexCount = 0;
			int combinedIndexCount = 0;
			GetCombinedMeshInfo(ref combinedVertexCount, ref combinedIndexCount);

			EnsureBufferSizes(combinedVertexCount, combinedIndexCount);

			int combinedV = 0;
			int combinedI = 0;
			for (int r = 0, rendererCount = referenceMeshFilters.Length; r < rendererCount; ++r) {
				MeshFilter meshFilter = referenceMeshFilters[r];
				Mesh mesh = meshFilter.sharedMesh;
				if (mesh == null) continue;

				int vertexCount = mesh.vertexCount;
				Vector3[] positions = mesh.vertices;
				Vector2[] uvs = mesh.uv;
				Color32[] colors = mesh.colors32;

				System.Array.Copy(positions, 0, this.positionBuffer.Items, combinedV, vertexCount);
				System.Array.Copy(uvs, 0, this.uvBuffer.Items, combinedV, vertexCount);
				System.Array.Copy(colors, 0, this.colorBuffer.Items, combinedV, vertexCount);

				for (int s = 0, submeshCount = mesh.subMeshCount; s < submeshCount; ++s) {
					int submeshIndexCount = (int)mesh.GetIndexCount(s);
					int[] submeshIndices = mesh.GetIndices(s);
					int[] dstIndices = this.indexBuffer.Items;
					for (int i = 0; i < submeshIndexCount; ++i)
						dstIndices[i + combinedI] = submeshIndices[i] + combinedV;
					combinedI += submeshIndexCount;
				}
				combinedV += vertexCount;
			}

			Mesh combinedMesh = doubleBufferedMesh.GetNext();
			combinedMesh.Clear();
#if SET_VERTICES_HAS_LENGTH_PARAMETER
			combinedMesh.SetVertices(this.positionBuffer.Items, 0, this.positionBuffer.Count);
			combinedMesh.SetUVs(0, this.uvBuffer.Items, 0, this.uvBuffer.Count);
			combinedMesh.SetColors(this.colorBuffer.Items, 0, this.colorBuffer.Count);
			combinedMesh.SetTriangles(this.indexBuffer.Items, 0, this.indexBuffer.Count, 0);
#else
			// Note: excess already contains zero positions and indices after ExposedList.Resize().
			combinedMesh.vertices = this.positionBuffer.Items;
			combinedMesh.uv = this.uvBuffer.Items;
			combinedMesh.colors32 = this.colorBuffer.Items;
			combinedMesh.triangles = this.indexBuffer.Items;
#endif
			ownMeshFilter.sharedMesh = combinedMesh;
		}

		void GetCombinedMeshInfo (ref int vertexCount, ref int indexCount) {
			for (int r = 0, rendererCount = referenceMeshFilters.Length; r < rendererCount; ++r) {
				MeshFilter meshFilter = referenceMeshFilters[r];
				Mesh mesh = meshFilter.sharedMesh;
				if (mesh == null) continue;

				vertexCount += mesh.vertexCount;
				for (int s = 0, submeshCount = mesh.subMeshCount; s < submeshCount; ++s) {
					indexCount += (int)mesh.GetIndexCount(s);
				}
			}
		}
	}
}