/******************************************************************************
 * Spine Runtimes License Agreement
 * Last updated January 1, 2020. Replaces all prior versions.
 *
 * Copyright (c) 2013-2020, 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_2020_1_OR_NEWER
#define UPGRADE_ALL_BLEND_MODE_MATERIALS
#endif

using UnityEngine;
using UnityEditor;
using System.Collections.Generic;
using System.IO;
using System;

namespace Spine.Unity.Editor {

	public class BlendModeMaterialsUtility {

		public const string MATERIAL_SUFFIX_MULTIPLY = "-Multiply";
		public const string MATERIAL_SUFFIX_SCREEN = "-Screen";
		public const string MATERIAL_SUFFIX_ADDITIVE = "-Additive";

#if UPGRADE_ALL_BLEND_MODE_MATERIALS
		public const bool ShallUpgradeBlendModeMaterials = true;
#else
		public const bool ShallUpgradeBlendModeMaterials = false;
#endif

		protected class TemplateMaterials {
			public Material multiplyTemplate;
			public Material screenTemplate;
			public Material additiveTemplate;
		};

		public static void UpgradeBlendModeMaterials (SkeletonDataAsset skeletonDataAsset) {
			var skeletonData = skeletonDataAsset.GetSkeletonData(true);
			if (skeletonData == null)
				return;
			UpdateBlendModeMaterials(skeletonDataAsset, ref skeletonData, true);
		}

		public static void UpdateBlendModeMaterials (SkeletonDataAsset skeletonDataAsset) {
			var skeletonData = skeletonDataAsset.GetSkeletonData(true);
			if (skeletonData == null)
				return;
			UpdateBlendModeMaterials(skeletonDataAsset, ref skeletonData, false);
		}

		public static void UpdateBlendModeMaterials (SkeletonDataAsset skeletonDataAsset, ref SkeletonData skeletonData,
			bool upgradeFromModifierAssets = ShallUpgradeBlendModeMaterials) {

			TemplateMaterials templateMaterials = new TemplateMaterials();
			bool anyMaterialsChanged = ClearUndesiredMaterialEntries(skeletonDataAsset);

			var blendModesModifierAsset = FindBlendModeMaterialsModifierAsset(skeletonDataAsset);
			if (blendModesModifierAsset) {
				if (upgradeFromModifierAssets) {
					TransferSettingsFromModifierAsset(blendModesModifierAsset,
					skeletonDataAsset, templateMaterials);
					UpdateBlendmodeMaterialsRequiredState(skeletonDataAsset, skeletonData);
				}
				else
					return;
			}
			else {
				if (!UpdateBlendmodeMaterialsRequiredState(skeletonDataAsset, skeletonData))
					return;
				AssignPreferencesTemplateMaterials(templateMaterials);
			}
			bool success = CreateAndAssignMaterials(skeletonDataAsset, templateMaterials, ref anyMaterialsChanged);
			if (success) {
				if (blendModesModifierAsset != null) {
					RemoveObsoleteModifierAsset(blendModesModifierAsset, skeletonDataAsset);
				}
			}

			skeletonDataAsset.Clear();
			skeletonData = skeletonDataAsset.GetSkeletonData(true);
			if (anyMaterialsChanged)
				ReloadSceneSkeletons(skeletonDataAsset);
			AssetDatabase.SaveAssets();
		}

		protected static bool ClearUndesiredMaterialEntries (SkeletonDataAsset skeletonDataAsset) {
			Predicate<BlendModeMaterials.ReplacementMaterial> ifMaterialMissing = r => r.material == null;

			bool anyMaterialsChanged = false;
			if (!skeletonDataAsset.blendModeMaterials.applyAdditiveMaterial) {
				anyMaterialsChanged |= skeletonDataAsset.blendModeMaterials.additiveMaterials.Count > 0;
				skeletonDataAsset.blendModeMaterials.additiveMaterials.Clear();
			}
			else
				anyMaterialsChanged |= skeletonDataAsset.blendModeMaterials.additiveMaterials.RemoveAll(ifMaterialMissing) != 0;
			anyMaterialsChanged |= skeletonDataAsset.blendModeMaterials.multiplyMaterials.RemoveAll(ifMaterialMissing) != 0;
			anyMaterialsChanged |= skeletonDataAsset.blendModeMaterials.screenMaterials.RemoveAll(ifMaterialMissing) != 0;
			return anyMaterialsChanged;
		}

		protected static BlendModeMaterialsAsset FindBlendModeMaterialsModifierAsset (SkeletonDataAsset skeletonDataAsset) {
			foreach (var modifierAsset in skeletonDataAsset.skeletonDataModifiers) {
				if (modifierAsset is BlendModeMaterialsAsset)
					return (BlendModeMaterialsAsset)modifierAsset;
			}
			return null;
		}

		protected static bool UpdateBlendmodeMaterialsRequiredState (SkeletonDataAsset skeletonDataAsset, SkeletonData skeletonData) {
			return skeletonDataAsset.blendModeMaterials.UpdateBlendmodeMaterialsRequiredState(skeletonData);
		}

		protected static void TransferSettingsFromModifierAsset (BlendModeMaterialsAsset modifierAsset,
			SkeletonDataAsset skeletonDataAsset, TemplateMaterials templateMaterials) {

			skeletonDataAsset.blendModeMaterials.TransferSettingsFrom(modifierAsset);

			templateMaterials.multiplyTemplate = modifierAsset.multiplyMaterialTemplate;
			templateMaterials.screenTemplate = modifierAsset.screenMaterialTemplate;
			templateMaterials.additiveTemplate = modifierAsset.additiveMaterialTemplate;
		}

		protected static void RemoveObsoleteModifierAsset (BlendModeMaterialsAsset modifierAsset,
			SkeletonDataAsset skeletonDataAsset) {

			skeletonDataAsset.skeletonDataModifiers.Remove(modifierAsset);
			Debug.Log(string.Format("BlendModeMaterialsAsset upgraded to built-in BlendModeMaterials at SkeletonDataAsset '{0}'.",
				skeletonDataAsset.name), skeletonDataAsset);
			EditorUtility.SetDirty(skeletonDataAsset);
		}

		protected static void AssignPreferencesTemplateMaterials (TemplateMaterials templateMaterials) {

			templateMaterials.multiplyTemplate = SpineEditorUtilities.Preferences.BlendModeMaterialMultiply;
			templateMaterials.screenTemplate = SpineEditorUtilities.Preferences.BlendModeMaterialScreen;
			templateMaterials.additiveTemplate = SpineEditorUtilities.Preferences.BlendModeMaterialAdditive;
		}

		protected static bool CreateAndAssignMaterials (SkeletonDataAsset skeletonDataAsset,
			TemplateMaterials templateMaterials, ref bool anyReplacementMaterialsChanged) {

			bool anyCreationFailed = false;
			var blendModeMaterials = skeletonDataAsset.blendModeMaterials;
			bool applyAdditiveMaterial = blendModeMaterials.applyAdditiveMaterial;

			var skinEntries = new List<Skin.SkinEntry>();

			skeletonDataAsset.Clear();
			skeletonDataAsset.isUpgradingBlendModeMaterials = true;
			SkeletonData skeletonData = skeletonDataAsset.GetSkeletonData(true);

			var slotsItems = skeletonData.Slots.Items;
			for (int slotIndex = 0, slotCount = skeletonData.Slots.Count; slotIndex < slotCount; slotIndex++) {
				var slot = slotsItems[slotIndex];
				if (slot.BlendMode == BlendMode.Normal) continue;
				if (!applyAdditiveMaterial && slot.BlendMode == BlendMode.Additive) continue;

				List<BlendModeMaterials.ReplacementMaterial> replacementMaterials = null;
				Material materialTemplate = null;
				string materialSuffix = null;
				switch (slot.BlendMode) {
					case BlendMode.Multiply:
						replacementMaterials = blendModeMaterials.multiplyMaterials;
						materialTemplate = templateMaterials.multiplyTemplate;
						materialSuffix = MATERIAL_SUFFIX_MULTIPLY;
						break;
					case BlendMode.Screen:
						replacementMaterials = blendModeMaterials.screenMaterials;
						materialTemplate = templateMaterials.screenTemplate;
						materialSuffix = MATERIAL_SUFFIX_SCREEN;
						break;
					case BlendMode.Additive:
						replacementMaterials = blendModeMaterials.additiveMaterials;
						materialTemplate = templateMaterials.additiveTemplate;
						materialSuffix = MATERIAL_SUFFIX_ADDITIVE;
						break;
				}

				skinEntries.Clear();
				foreach (var skin in skeletonData.Skins)
					skin.GetAttachments(slotIndex, skinEntries);

				foreach (var entry in skinEntries) {
					var renderableAttachment = entry.Attachment as IHasRendererObject;
					if (renderableAttachment != null) {
						var originalRegion = (AtlasRegion)renderableAttachment.RendererObject;
						bool replacementExists = replacementMaterials.Exists(
							replacement => replacement.pageName == originalRegion.page.name);
						if (!replacementExists) {
							bool createdNewMaterial;
							var replacement = CreateOrLoadReplacementMaterial(originalRegion, materialTemplate, materialSuffix, out createdNewMaterial);
							if (replacement != null) {
								replacementMaterials.Add(replacement);
								anyReplacementMaterialsChanged = true;
								if (createdNewMaterial) {
									Debug.Log(string.Format("Created blend mode Material '{0}' for SkeletonDataAsset '{1}'.",
										replacement.material.name, skeletonDataAsset), replacement.material);
								}
							}
							else {
								Debug.LogError(string.Format("Failed creating blend mode Material for SkeletonDataAsset '{0}',"+
									" atlas page '{1}', template '{2}'.",
									skeletonDataAsset.name, originalRegion.page.name, materialTemplate.name),
									skeletonDataAsset);
								anyCreationFailed = true;
							}
						}
					}
				}
			}

			skeletonDataAsset.isUpgradingBlendModeMaterials = false;
			EditorUtility.SetDirty(skeletonDataAsset);
			return !anyCreationFailed;
		}

		protected static string GetBlendModeMaterialPath(AtlasPage originalPage, string materialSuffix) {
			var originalMaterial = originalPage.rendererObject as Material;
			var originalPath = AssetDatabase.GetAssetPath(originalMaterial);
			return originalPath.Replace(".mat", materialSuffix + ".mat");
		}

		protected static BlendModeMaterials.ReplacementMaterial CreateOrLoadReplacementMaterial (
			AtlasRegion originalRegion, Material materialTemplate, string materialSuffix, out bool createdNewMaterial) {

			createdNewMaterial = false;
			var newReplacement = new BlendModeMaterials.ReplacementMaterial();
			var originalPage = originalRegion.page;
			var originalMaterial = originalPage.rendererObject as Material;
			var blendMaterialPath = GetBlendModeMaterialPath(originalPage, materialSuffix);

			newReplacement.pageName = originalPage.name;
			if (File.Exists(blendMaterialPath)) {
				newReplacement.material = AssetDatabase.LoadAssetAtPath<Material>(blendMaterialPath);
			}
			else {
				var blendModeMaterial = new Material(materialTemplate) {
					name = originalMaterial.name + " " + materialTemplate.name,
					mainTexture = originalMaterial.mainTexture
				};
				newReplacement.material = blendModeMaterial;

				AssetDatabase.CreateAsset(blendModeMaterial, blendMaterialPath);
				EditorUtility.SetDirty(blendModeMaterial);
				createdNewMaterial = true;
			}

			if (newReplacement.material)
				return newReplacement;
			else
				return null;
		}

		protected static void ReloadSceneSkeletons (SkeletonDataAsset skeletonDataAsset) {
			if (SpineEditorUtilities.Preferences.autoReloadSceneSkeletons)
				SpineEditorUtilities.DataReloadHandler.ReloadSceneSkeletonComponents(skeletonDataAsset);
		}
	}
}