/******************************************************************************
 * Spine Runtimes Software License v2.5
 *
 * Copyright (c) 2013-2016, Esoteric Software
 * All rights reserved.
 *
 * You are granted a perpetual, non-exclusive, non-sublicensable, and
 * non-transferable license to use, install, execute, and perform the Spine
 * Runtimes software and derivative works solely for personal or internal
 * use. Without the written permission of Esoteric Software (see Section 2 of
 * the Spine Software License Agreement), you may not (a) modify, translate,
 * adapt, or develop new applications using the Spine Runtimes or otherwise
 * create derivative works or improvements of the Spine Runtimes or (b) remove,
 * delete, alter, or obscure any trademarks or any copyright, trademark, patent,
 * or other intellectual property or proprietary rights notices on or in the
 * Software, including any copy thereof. Redistributions in binary or source
 * form must include this license and terms.
 *
 * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 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 THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/

using UnityEngine;
using System.Collections.Generic;

namespace Spine.Unity.MeshGeneration {
	/// <summary>
	/// Arrays submeshed mesh generator.
	/// </summary>
	public class ArraysSubmeshedMeshGenerator : ArraysMeshGenerator, ISubmeshedMeshGenerator {

		readonly List<Slot> separators = new List<Slot>();
		public List<Slot> Separators { get { return this.separators; } }

		#region Settings
		// ArraysMeshGenerator.PremultiplyAlpha
		public float ZSpacing { get; set; }
		#endregion

		readonly DoubleBuffered<SmartMesh> doubleBufferedSmartMesh = new DoubleBuffered<SmartMesh>();
		readonly SubmeshedMeshInstruction currentInstructions = new SubmeshedMeshInstruction();
		readonly ExposedList<SubmeshTriangleBuffer> submeshBuffers = new ExposedList<SubmeshTriangleBuffer>();
		Material[] sharedMaterials = new Material[0];

		public SubmeshedMeshInstruction GenerateInstruction (Skeleton skeleton) {
			if (skeleton == null) throw new System.ArgumentNullException("skeleton");

			// Count vertices and submesh triangles.
			int runningVertexCount = 0;

			int submeshTriangleCount = 0;
			int submeshFirstVertex = 0;
			int submeshVertexCount = 0;
			int submeshStartSlotIndex = 0;
			Material lastMaterial = null;

			var drawOrder = skeleton.drawOrder;
			var drawOrderItems = drawOrder.Items;
			int drawOrderCount = drawOrder.Count;
			int separatorCount = separators.Count;

			var instructionList = this.currentInstructions.submeshInstructions;
			instructionList.Clear(false);

			currentInstructions.attachmentList.Clear(false);

			for (int i = 0; i < drawOrderCount; i++) {
				var slot = drawOrderItems[i];
				var attachment = slot.attachment;

				object rendererObject; // An AtlasRegion in plain Spine-Unity. eventual source of Material object.
				int attachmentVertexCount, attachmentTriangleCount;

				var regionAttachment = attachment as RegionAttachment;
				if (regionAttachment != null) {
					rendererObject = regionAttachment.RendererObject;
					attachmentVertexCount = 4;
					attachmentTriangleCount = 6;
				} else {
					var meshAttachment = attachment as MeshAttachment;
					if (meshAttachment != null) {
						rendererObject = meshAttachment.RendererObject;
						attachmentVertexCount = meshAttachment.worldVerticesLength >> 1;
						attachmentTriangleCount = meshAttachment.triangles.Length;
					} else {
						continue;
					}
				}

				var attachmentMaterial = (Material)((AtlasRegion)rendererObject).page.rendererObject;

				// Populate submesh when material changes. (or when forced to separate by a submeshSeparator)
				bool separatedBySlot  = ( separatorCount > 0 && separators.Contains(slot) );
				if (( runningVertexCount > 0 && lastMaterial.GetInstanceID() != attachmentMaterial.GetInstanceID() ) ||	separatedBySlot) {

					instructionList.Add(
						new SubmeshInstruction {
							skeleton = skeleton,
							material = lastMaterial,
							triangleCount = submeshTriangleCount,
							vertexCount = submeshVertexCount,
							startSlot = submeshStartSlotIndex,
							endSlot = i,
							firstVertexIndex = submeshFirstVertex,
							forceSeparate = separatedBySlot
						}
					);

					// Prepare for next submesh
					submeshTriangleCount = 0;
					submeshVertexCount = 0;
					submeshFirstVertex = runningVertexCount;
					submeshStartSlotIndex = i;
				}
				lastMaterial = attachmentMaterial;

				submeshTriangleCount += attachmentTriangleCount;
				submeshVertexCount += attachmentVertexCount;
				runningVertexCount += attachmentVertexCount;

				currentInstructions.attachmentList.Add(attachment);
			}

			instructionList.Add(
				new SubmeshInstruction {
					skeleton = skeleton,
					material = lastMaterial,
					triangleCount = submeshTriangleCount,
					vertexCount = submeshVertexCount,
					startSlot = submeshStartSlotIndex,
					endSlot = drawOrderCount,
					firstVertexIndex = submeshFirstVertex,
					forceSeparate = false
				}
			);

			currentInstructions.vertexCount = runningVertexCount;
			return currentInstructions;
		}

		// ISubmeshedMeshGenerator.GenerateMesh
		/// <summary>Generates a mesh based on SubmeshedMeshInstructions</summary>
		public MeshAndMaterials GenerateMesh (SubmeshedMeshInstruction meshInstructions) {
			var smartMesh = doubleBufferedSmartMesh.GetNext();
			var mesh = smartMesh.mesh;
			int submeshCount = meshInstructions.submeshInstructions.Count;
			var instructionList = meshInstructions.submeshInstructions;

			// STEP 1: Ensure correct buffer sizes.
			int vertexCount = meshInstructions.vertexCount;
			bool submeshBuffersResized = ArraysMeshGenerator.EnsureTriangleBuffersSize(submeshBuffers, submeshCount, instructionList.Items);
			bool vertBufferResized = ArraysMeshGenerator.EnsureSize(vertexCount, ref this.meshVertices, ref this.meshUVs, ref this.meshColors32);
			Vector3[] vertices = this.meshVertices;

			// STEP 2: Update buffers based on Skeleton.
			float zSpacing = this.ZSpacing;
			Vector3 meshBoundsMin;
			Vector3 meshBoundsMax;
			int attachmentCount = meshInstructions.attachmentList.Count;
			if (attachmentCount <= 0) {
				meshBoundsMin = new Vector3(0, 0, 0);
				meshBoundsMax = new Vector3(0, 0, 0);
			} else {
				meshBoundsMin.x = int.MaxValue;
				meshBoundsMin.y = int.MaxValue;
				meshBoundsMax.x = int.MinValue;
				meshBoundsMax.y = int.MinValue;

				if (zSpacing > 0f) {
					meshBoundsMin.z = 0f;
					meshBoundsMax.z = zSpacing * (attachmentCount - 1);
				} else {
					meshBoundsMin.z = zSpacing * (attachmentCount - 1);
					meshBoundsMax.z = 0f;
				}
			}
			bool structureDoesntMatch = vertBufferResized || submeshBuffersResized || smartMesh.StructureDoesntMatch(meshInstructions);
			// For each submesh, add vertex data from attachments. Also triangles, but only if needed.
			int vertexIndex = 0; // modified by FillVerts
			for (int submeshIndex = 0; submeshIndex < submeshCount; submeshIndex++) {
				var submeshInstruction = instructionList.Items[submeshIndex];
				int start = submeshInstruction.startSlot;
				int end = submeshInstruction.endSlot;
				var skeleton = submeshInstruction.skeleton;
				ArraysMeshGenerator.FillVerts(skeleton, start, end, zSpacing, this.PremultiplyVertexColors, vertices, this.meshUVs, this.meshColors32, ref vertexIndex, ref this.attachmentVertexBuffer, ref meshBoundsMin, ref meshBoundsMax);
				if (structureDoesntMatch) {
					var currentBuffer = submeshBuffers.Items[submeshIndex];
					bool isLastSubmesh = (submeshIndex == submeshCount - 1);
					ArraysMeshGenerator.FillTriangles(ref currentBuffer.triangles, skeleton, submeshInstruction.triangleCount, submeshInstruction.firstVertexIndex, start, end, isLastSubmesh);
					currentBuffer.triangleCount = submeshInstruction.triangleCount;
					currentBuffer.firstVertex = submeshInstruction.firstVertexIndex;
				}
			}

			if (structureDoesntMatch) {
				mesh.Clear();
				this.sharedMaterials = meshInstructions.GetUpdatedMaterialArray(this.sharedMaterials);
			}

			// STEP 3: Assign the buffers into the Mesh.
			smartMesh.Set(this.meshVertices, this.meshUVs, this.meshColors32, meshInstructions);
			mesh.bounds = ArraysMeshGenerator.ToBounds(meshBoundsMin, meshBoundsMax);

			if (structureDoesntMatch) {
				// Push new triangles if doesn't match.
				mesh.subMeshCount = submeshCount;
				for (int i = 0; i < submeshCount; i++)
					mesh.SetTriangles(submeshBuffers.Items[i].triangles, i);			

				TryAddNormalsTo(mesh, vertexCount);
			}

			if (addTangents) { 
				SolveTangents2DEnsureSize(ref this.meshTangents, ref this.tempTanBuffer, vertexCount);
				for (int i = 0, n = submeshCount; i < n; i++) {
					var submesh = submeshBuffers.Items[i];
					SolveTangents2DTriangles(this.tempTanBuffer, submesh.triangles, submesh.triangleCount, meshVertices, meshUVs, vertexCount);
				}
				SolveTangents2DBuffer(this.meshTangents, this.tempTanBuffer, vertexCount);
			}
				
			return new MeshAndMaterials(smartMesh.mesh, sharedMaterials);
		}

		#region Types
		// A SmartMesh is a Mesh (with submeshes) that knows what attachments and instructions were used to generate it.
		class SmartMesh {
			public readonly Mesh mesh = SpineMesh.NewMesh();
			readonly ExposedList<Attachment> attachmentsUsed = new ExposedList<Attachment>();
			readonly ExposedList<SubmeshInstruction> instructionsUsed = new ExposedList<SubmeshInstruction>();

			public void Set (Vector3[] verts, Vector2[] uvs, Color32[] colors, SubmeshedMeshInstruction instruction) {
				mesh.vertices = verts;
				mesh.uv = uvs;
				mesh.colors32 = colors;

				attachmentsUsed.Clear(false);
				attachmentsUsed.GrowIfNeeded(instruction.attachmentList.Capacity);
				attachmentsUsed.Count = instruction.attachmentList.Count;
				instruction.attachmentList.CopyTo(attachmentsUsed.Items);

				instructionsUsed.Clear(false);
				instructionsUsed.GrowIfNeeded(instruction.submeshInstructions.Capacity);
				instructionsUsed.Count = instruction.submeshInstructions.Count;
				instruction.submeshInstructions.CopyTo(instructionsUsed.Items);
			}

			public bool StructureDoesntMatch (SubmeshedMeshInstruction instructions) {
				// Check count inequality.
				if (instructions.attachmentList.Count != this.attachmentsUsed.Count) return true;
				if (instructions.submeshInstructions.Count != this.instructionsUsed.Count) return true;

				// Check each attachment.
				var attachmentsPassed = instructions.attachmentList.Items;
				var myAttachments = this.attachmentsUsed.Items;
				for (int i = 0, n = attachmentsUsed.Count; i < n; i++)
					if (attachmentsPassed[i] != myAttachments[i]) return true;

				// Check each submesh for equal arrangement.
				var instructionListItems = instructions.submeshInstructions.Items;
				var myInstructions = this.instructionsUsed.Items;
				for (int i = 0, n = this.instructionsUsed.Count; i < n; i++) {
					var lhs = instructionListItems[i];
					var rhs = myInstructions[i];
					if (
						lhs.material.GetInstanceID() != rhs.material.GetInstanceID() ||
						lhs.startSlot != rhs.startSlot ||
						lhs.endSlot != rhs.endSlot ||
						lhs.triangleCount != rhs.triangleCount ||
						lhs.vertexCount != rhs.vertexCount ||
						lhs.firstVertexIndex != rhs.firstVertexIndex
					) return true;
				}

				//Debug.Log("structure matched");
				return false;
			}
		}
		#endregion
	}

}
