/******************************************************************************
 * 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 System;
using UnityEngine;
using UnityEditor;

using SpineInspectorUtility = Spine.Unity.Editor.SpineInspectorUtility;

public class SpineSpriteShaderGUI : ShaderGUI {
	
	#region Constants
	const string ShaderVertexLit = "Spine/Sprite/Vertex Lit";
	const string ShaderPixelLit = "Spine/Sprite/Pixel Lit";
	const string ShaderUnlit = "Spine/Sprite/Unlit";

	const int SolidQueue = 2000;
	const int AlphaTestQueue = 2450;
	const int TransparentQueue = 3000;

	const string PremultipledAlpha = "_ALPHAPREMULTIPLY_ON";
	const string Multiply = "_MULTIPLYBLEND";
	const string Multiply2x = "_MULTIPLYBLEND_X2";
	const string Additive = "_ADDITIVEBLEND";
	const string SoftAdditive = "_ADDITIVEBLEND_SOFT";

	const string _FIXED_NORMALS = "_FIXED_NORMALS";
	const string _FIXED_NORMALS_BACK_RENDERING = "_FIXED_NORMALS_BACK_RENDERING";

	const string _SPHERICAL_HARMONICS = "_SPHERICAL_HARMONICS";

	enum eBlendMode {
		PreMultipliedAlpha,
		StandardAlpha,
		Solid,
		Additive,
		SoftAdditive,
		Multiply,
		Multiplyx2,
	}

	enum eLightMode { VertexLit, PixelLit, Unlit, }

	enum eCulling {
		Off = 0,
		Back = 2,
		Front = 1,
	}
	#endregion

	MaterialProperty _mainTexture = null;
	MaterialProperty _color = null;

	MaterialProperty _emissionMap = null;
	MaterialProperty _emissionColor = null;
	MaterialProperty _emissionPower = null;

	MaterialProperty _writeToDepth = null;
	MaterialProperty _depthAlphaCutoff = null;
	MaterialProperty _shadowAlphaCutoff = null;
	MaterialProperty _renderQueue = null;
	MaterialProperty _culling = null;

	MaterialProperty _overlayColor = null;
	MaterialProperty _hue = null;
	MaterialProperty _saturation = null;
	MaterialProperty _brightness = null;

	MaterialProperty _rimPower = null;
	MaterialProperty _rimColor = null;

	MaterialEditor _materialEditor;

	//Normals
	MaterialProperty _bumpMap = null;
	MaterialProperty _diffuseRamp = null;
	MaterialProperty _fixedNormal = null;

	//Blend texture
	MaterialProperty _blendTexture = null;
	MaterialProperty _blendTextureLerp = null;

	bool _firstTimeApply = true;
	eLightMode _lightMode;
	static bool showAdvanced = false;

	#region ShaderGUI
	public override void OnGUI (MaterialEditor materialEditor, MaterialProperty[] properties)	{
		FindProperties(properties); // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly
		_materialEditor = materialEditor;
		Material material = materialEditor.target as Material;

		ShaderPropertiesGUI(material);

		// Make sure that needed keywords are set up if we're switching some existing
		// material to a standard shader.
		if (_firstTimeApply) {
			SetMaterialKeywords(material);
			SetLightModeFromShader(material);
			_firstTimeApply = false;
		}
	}

	public override void AssignNewShaderToMaterial (Material material, Shader oldShader, Shader newShader) {
		base.AssignNewShaderToMaterial(material, oldShader, newShader);

		if (!(oldShader == Shader.Find(ShaderPixelLit) || oldShader == Shader.Find(ShaderVertexLit) || oldShader == Shader.Find(ShaderUnlit)))
			SetDefaultSpriteKeywords(material, newShader);

		SetMaterialKeywords(material);
		SetLightModeFromShader(material);
	}


	#endregion

	#region Virtual Interface
	protected virtual void FindProperties (MaterialProperty[] props) {
		_mainTexture = FindProperty("_MainTex", props);
		_color = FindProperty("_Color", props);

		_emissionMap = FindProperty("_EmissionMap", props, false);
		_emissionColor = FindProperty("_EmissionColor", props, false);
		_emissionPower = FindProperty("_EmissionPower", props, false);

		_writeToDepth = FindProperty("_ZWrite", props);
		_depthAlphaCutoff = FindProperty("_Cutoff", props);
		_shadowAlphaCutoff = FindProperty("_ShadowAlphaCutoff", props);
		_renderQueue = FindProperty("_RenderQueue", props);
		_culling = FindProperty("_Cull", props);

		_bumpMap = FindProperty("_BumpMap", props, false);
		_diffuseRamp = FindProperty("_DiffuseRamp", props, false);
		_fixedNormal = FindProperty("_FixedNormal", props, false);
		_blendTexture = FindProperty("_BlendTex", props, false);
		_blendTextureLerp = FindProperty("_BlendAmount", props, false);

		_overlayColor = FindProperty("_OverlayColor", props, false);
		_hue = FindProperty("_Hue", props, false);
		_saturation = FindProperty("_Saturation", props, false);
		_brightness = FindProperty("_Brightness", props, false);

		_rimPower = FindProperty("_RimPower", props, false);
		_rimColor = FindProperty("_RimColor", props, false);
	}

	protected virtual void ShaderPropertiesGUI (Material material) {
		using (new EditorGUILayout.HorizontalScope()) {
			GUILayout.FlexibleSpace();
			var showAdvancedLabel = new GUIContent("Show Advanced", "Show extra options under all sections. This only affects the inspector. The Material's resulting shader is still compiled/optimized based on what features you actually use and don't use.");
			float lw = GUI.skin.toggle.CalcSize(showAdvancedLabel).x;

			EditorGUIUtility.labelWidth = lw;
			showAdvanced = EditorGUILayout.Toggle(showAdvancedLabel, showAdvanced);
			EditorGUIUtility.labelWidth = 0f;
		}

		EditorGUILayout.Space();

		EditorGUI.BeginChangeCheck();
		{
			LightingModePopup();
			BlendModePopup();

			if (showAdvanced) {
				EditorGUILayout.Space();
				EditorGUI.BeginChangeCheck();
				int renderQueue = EditorGUILayout.IntSlider("Renderer Queue Offset", (int)_renderQueue.floatValue, 0, 49);
				if (EditorGUI.EndChangeCheck()) material.SetInt("_RenderQueue", renderQueue);

				EditorGUI.BeginChangeCheck();
				eCulling culling = (eCulling)Mathf.RoundToInt(_culling.floatValue);
				culling = (eCulling)EditorGUILayout.EnumPopup("Culling", culling);
				if (EditorGUI.EndChangeCheck()) material.SetInt("_Cull", (int)culling);

				EditorGUI.BeginChangeCheck();
				bool fog = EditorGUILayout.Toggle("Use fog", material.IsKeywordEnabled("_FOG"));
				if (EditorGUI.EndChangeCheck()) SetKeyword(material, "_FOG", fog);

				EditorGUI.BeginChangeCheck();
				bool enabled = EditorGUILayout.Toggle(
					new GUIContent(
						"Use Spherical Harmonics",
						"Enable to use spherical harmonics to calculate ambient light / light probes. In vertex-lit mode this will be approximated from scenes ambient trilight settings."),
					material.IsKeywordEnabled(_SPHERICAL_HARMONICS)
				);
				if (EditorGUI.EndChangeCheck())
					SetKeyword(material, _SPHERICAL_HARMONICS, enabled);
			}

			using (new SpineInspectorUtility.BoxScope())
				RenderTextureProperties("Main Maps", material);

			if (showAdvanced) {
				using (new SpineInspectorUtility.BoxScope()) {
					Heading("Depth and Cast Shadow");
					EditorGUI.BeginChangeCheck();
					bool writeTodepth = EditorGUILayout.Toggle(new GUIContent("Write to Depth", "Write to Depth Buffer by clipping alpha."), _writeToDepth.floatValue != 0.0f);
					if (EditorGUI.EndChangeCheck())
						material.SetInt("_ZWrite", writeTodepth ? 1 : 0);

					if (writeTodepth)
						_materialEditor.RangeProperty(_depthAlphaCutoff, "Depth Alpha Cutoff");

					EditorGUILayout.Space();

					_materialEditor.RangeProperty(_shadowAlphaCutoff, "Shadow Alpha Cutoff");
				}

				if (_fixedNormal != null) {
					using (new SpineInspectorUtility.BoxScope()) {
						Heading("Normals");
						bool meshNormals = UseMeshNormalsCheckbox(material);
						if (!meshNormals) {
							Vector3 normal;
							EditorGUI.BeginChangeCheck();
							normal = showAdvanced ? EditorGUILayout.Vector3Field(new GUIContent("Fixed Normal", "Defined in Camera Space. Should normally be (0,0,-1)."), _fixedNormal.vectorValue) : (Vector3)_fixedNormal.vectorValue;
							if (EditorGUI.EndChangeCheck())
								_fixedNormal.vectorValue = new Vector4(normal.x, normal.y, normal.z, 1.0f);

							bool backRendering;
							EditorGUI.BeginChangeCheck();
							if (showAdvanced) {
								backRendering = EditorGUILayout.Toggle(new GUIContent("Fixed Normal Back Rendering", "Tick only if you are going to rotate the sprite to face away from the camera, the fixed normal will be flipped to compensate."), 
									material.IsKeywordEnabled(_FIXED_NORMALS_BACK_RENDERING));
							} else {
								backRendering = material.IsKeywordEnabled(_FIXED_NORMALS_BACK_RENDERING);
							}
							if (EditorGUI.EndChangeCheck()) {
								SetKeyword(material, _FIXED_NORMALS_BACK_RENDERING, backRendering);
								SetKeyword(material, _FIXED_NORMALS, !backRendering);
							}
						}
					}
				}
			} else {
				using (new SpineInspectorUtility.BoxScope()) {
					EditorGUI.BeginChangeCheck();
					bool writeTodepth = EditorGUILayout.Toggle(new GUIContent("Write to Depth", "Write to Depth Buffer by clipping alpha."), _writeToDepth.floatValue != 0.0f);
					if (EditorGUI.EndChangeCheck())
						material.SetInt("_ZWrite", writeTodepth ? 1 : 0);

					if (_fixedNormal != null)
						UseMeshNormalsCheckbox(material);
				}
			}

			using (new SpineInspectorUtility.BoxScope())
				RenderColorProperties("Color Adjustment", material);

			if (_emissionMap != null && _emissionColor != null && _rimColor != null) {
				Heading("Extra Lighting");

				if (_emissionMap != null && _emissionColor != null)
					using (new SpineInspectorUtility.BoxScope())
						RenderEmissionProperties(material);

				if (_rimColor != null)
					using (new SpineInspectorUtility.BoxScope())
						RenderRimLightingProperties(material);
			}
		}
		if (EditorGUI.EndChangeCheck())	{
			MaterialChanged(material);
		}
	}

	protected virtual void RenderTextureProperties (string label, Material material) {
		if (showAdvanced)
			Heading(label);

		_materialEditor.TexturePropertySingleLine(new GUIContent(showAdvanced ? "Albedo" : "Main Texture"), _mainTexture, _color);

		if (_bumpMap != null)
			_materialEditor.TexturePropertySingleLine(new GUIContent("Normal Map"), _bumpMap);

		if (showAdvanced) {
			if (_blendTexture != null) {
				EditorGUI.BeginChangeCheck();
				_materialEditor.TexturePropertySingleLine(new GUIContent("Blend Texture", "When a blend texture is set the albedo will be a mix of the blend texture and main texture based on the blend amount."), _blendTexture, _blendTextureLerp);
				if (EditorGUI.EndChangeCheck())
					SetKeyword(material, "_TEXTURE_BLEND", _blendTexture != null);
			}
		}

		if (_diffuseRamp != null) {
			EditorGUILayout.Space();
			_materialEditor.TexturePropertySingleLine(new GUIContent("Diffuse Ramp", "A gradient can be used to create a 'Toon Shading' effect."), _diffuseRamp);
		}

		//		if (showAdvanced)
		//			_materialEditor.TextureScaleOffsetProperty(_mainTexture);
	}

	bool UseMeshNormalsCheckbox (Material material) {
		EditorGUI.BeginChangeCheck();
		bool fixedNormals = material.IsKeywordEnabled(_FIXED_NORMALS);
		bool fixedNormalsBackRendering = material.IsKeywordEnabled(_FIXED_NORMALS_BACK_RENDERING);
		bool meshNormals = EditorGUILayout.Toggle(new GUIContent("Use Mesh Normals", "If this is unticked, a Fixed Normal value will be used instead of the vertex normals on the mesh. Using a fixed normal is better for performance and can result in better looking lighting effects on 2d objects."), 
			!fixedNormals && !fixedNormalsBackRendering);
		if (EditorGUI.EndChangeCheck()) {
			SetKeyword(material, _FIXED_NORMALS, meshNormals ? false : fixedNormalsBackRendering ? false : true);
			SetKeyword(material, _FIXED_NORMALS_BACK_RENDERING, meshNormals ? false : fixedNormalsBackRendering);
		}
		return meshNormals;
	}

	protected virtual void RenderColorProperties (string label, Material material) {
		if (ToggleHeadingKeyword(label, material, "_COLOR_ADJUST")) {
			_materialEditor.ColorProperty(_overlayColor, "Overlay Color");
			EditorGUILayout.Space();
			using (new SpineInspectorUtility.IndentScope()) {
				_materialEditor.RangeProperty(_hue, "Hue");
				_materialEditor.RangeProperty(_saturation, "Saturation");
				_materialEditor.RangeProperty(_brightness, "Brightness");
			}
		}
	}

	protected virtual void RenderEmissionProperties (Material material) {
		if (ToggleHeadingKeyword("Emission", material, "_EMISSION")) {
			_materialEditor.TexturePropertyWithHDRColor(new GUIContent("Emission"), _emissionMap, _emissionColor, new ColorPickerHDRConfig(0,1, 0.01010101f, 3), true);
			_materialEditor.FloatProperty(_emissionPower, "Emission Power");
		}
	}

	protected virtual void RenderRimLightingProperties (Material material) {
		if (ToggleHeadingKeyword("Rim Lighting", material, "_RIM_LIGHTING")) {
			_materialEditor.ColorProperty(_rimColor, "Rim Color");
			_materialEditor.FloatProperty(_rimPower, "Rim Power");
		}
	}
	#endregion

	static void SetDefaultSpriteKeywords (Material material, Shader shader) {
		SetKeyword(material, "_EMISSION", false); // Disabled. standard shader sets this on by default.
		SetKeyword(material, PremultipledAlpha, true); // PMA by default
		SetKeyword(material, _FIXED_NORMALS, true); // Fixed normals by default, best for Spine.
		SetKeyword(material, _SPHERICAL_HARMONICS, true);
	}

	void SetLightModeFromShader (Material material) {
		if (material.shader.name == ShaderPixelLit)
			_lightMode = eLightMode.PixelLit;
		else if (material.shader.name == ShaderUnlit)
			_lightMode = eLightMode.Unlit;
		else
			_lightMode = eLightMode.VertexLit;
	}

	static void SetRenderQueue (Material material, string queue) {
		bool meshNormal = true;

		if (material.HasProperty("_FixedNormal")) {
			bool fixedNormals = material.IsKeywordEnabled(_FIXED_NORMALS);
			bool fixedNormalsBackRendering = material.IsKeywordEnabled(_FIXED_NORMALS_BACK_RENDERING);
			meshNormal = !fixedNormals && !fixedNormalsBackRendering;
		}

		material.SetOverrideTag("RenderType", meshNormal ? queue : "Sprite");
	}

	static void SetMaterialKeywords (Material material) {
		bool normalMap = material.HasProperty("_BumpMap") && material.GetTexture("_BumpMap") != null;
		SetKeyword(material, "_NORMALMAP", normalMap);

		bool zWrite = material.GetFloat("_ZWrite") > 0.0f;
		bool clipAlpha = zWrite && material.GetFloat("_Cutoff") > 0.0f;
		SetKeyword(material, "_ALPHA_CLIP", clipAlpha);

		bool diffuseRamp = material.HasProperty("_DiffuseRamp") && material.GetTexture("_DiffuseRamp") != null;
		SetKeyword(material, "_DIFFUSE_RAMP", diffuseRamp);

		bool blendTexture = material.HasProperty("_BlendTex") && material.GetTexture("_BlendTex") != null;
		SetKeyword(material, "_TEXTURE_BLEND", blendTexture);

		eBlendMode blendMode = GetMaterialBlendMode(material);
		SetBlendMode(material, blendMode);
	}

	static eBlendMode GetMaterialBlendMode (Material material) {
		if (material.IsKeywordEnabled(PremultipledAlpha))
			return eBlendMode.PreMultipliedAlpha;
		if (material.IsKeywordEnabled(Multiply))
			return eBlendMode.Multiply;
		if (material.IsKeywordEnabled(Multiply2x))
			return eBlendMode.Multiplyx2;
		if (material.IsKeywordEnabled(Additive))
			return eBlendMode.Additive;
		if (material.IsKeywordEnabled(SoftAdditive))
			return eBlendMode.SoftAdditive;

		return eBlendMode.StandardAlpha;
	}

	void BlendModePopup () {
		var material = _materialEditor.target as Material;
		eBlendMode blendMode = GetMaterialBlendMode(material);
		EditorGUI.BeginChangeCheck();
		blendMode = (eBlendMode)EditorGUILayout.Popup("Blend Mode", (int)blendMode, Enum.GetNames(typeof(eBlendMode)));

		if (EditorGUI.EndChangeCheck())
			SetBlendMode(material, blendMode);
	}

	static void SetBlendMode (Material material, eBlendMode blendMode) {
		SetKeyword(material, PremultipledAlpha, blendMode == eBlendMode.PreMultipliedAlpha);
		SetKeyword(material, Multiply, blendMode == eBlendMode.Multiply);
		SetKeyword(material, Multiply2x, blendMode == eBlendMode.Multiplyx2);
		SetKeyword(material, Additive, blendMode == eBlendMode.Additive);
		SetKeyword(material, SoftAdditive, blendMode == eBlendMode.SoftAdditive);

		int renderQueue;

		switch (blendMode) {
		case eBlendMode.Solid:
			{
				material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
				material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
				SetRenderQueue(material, "Opaque");
				renderQueue = SolidQueue;
			}
			break;
		case eBlendMode.Additive:
			{ 
				material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
				material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
				SetRenderQueue(material, "Transparent");
				renderQueue = TransparentQueue;
			}
			break;
		case eBlendMode.SoftAdditive:
			{
				material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
				material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcColor);
				SetRenderQueue(material, "Transparent");
				renderQueue = TransparentQueue;
			}
			break;
		case eBlendMode.Multiply:
			{
				material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
				material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.SrcColor);
				SetRenderQueue(material, "Transparent");
				renderQueue = TransparentQueue;
			}
			break;
		case eBlendMode.Multiplyx2:
			{
				material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.DstColor);
				material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.SrcColor);
				SetRenderQueue(material, "Transparent");
				renderQueue = TransparentQueue;
			}
			break;
		case eBlendMode.PreMultipliedAlpha:
		case eBlendMode.StandardAlpha:
		default:
			{
				bool zWrite = material.GetFloat("_ZWrite") > 0.0f;
				material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
				material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
				SetRenderQueue(material, zWrite ? "TransparentCutout" : "Transparent");
				renderQueue = zWrite ? AlphaTestQueue : TransparentQueue;
			}
			break;
		}

		material.renderQueue = renderQueue + material.GetInt("_RenderQueue");
	}

	static void Heading (string label) {
		GUILayout.Label(label, EditorStyles.boldLabel);
	}

	static bool ToggleHeadingKeyword (string label, Material material, string keyword) {
		int i = EditorGUI.indentLevel;
		var o = EditorStyles.label.fontStyle;
		EditorGUI.indentLevel = 0;
		EditorStyles.label.fontStyle = FontStyle.Bold;

		EditorGUI.BeginChangeCheck();
		bool r = EditorGUILayout.Toggle(new GUIContent(label, string.Format("This checkbox sets shader keyword: '{0}', which causes the Material to use extra shader features.", keyword)), material.IsKeywordEnabled(keyword));
		if (EditorGUI.EndChangeCheck())
			SetKeyword(material, keyword, r);

		EditorStyles.label.fontStyle = o;
		EditorGUI.indentLevel = i;
		return r;
	}

	static void MaterialChanged (Material material) {
		SetMaterialKeywords(material);
	}

	static void SetKeyword (Material m, string keyword, bool state) {
		if (state)
			m.EnableKeyword(keyword);
		else
			m.DisableKeyword(keyword);
	}

	void LightingModePopup () {
		EditorGUI.BeginChangeCheck();
		_lightMode = (eLightMode)EditorGUILayout.Popup("Lighting Mode", (int)_lightMode, Enum.GetNames(typeof(eLightMode)));
		if (EditorGUI.EndChangeCheck()) {
			var material = _materialEditor.target as Material;

			switch (_lightMode) {
			case eLightMode.VertexLit:
				if (material.shader.name != ShaderVertexLit)
					_materialEditor.SetShader(Shader.Find(ShaderVertexLit), false);
				break;
			case eLightMode.PixelLit:
				if (material.shader.name != ShaderPixelLit)
					_materialEditor.SetShader(Shader.Find(ShaderPixelLit), false);
				break;
			case eLightMode.Unlit:
				if (material.shader.name != ShaderUnlit)
					_materialEditor.SetShader(Shader.Find(ShaderUnlit), false);
				break;
			}

			MaterialChanged(material);
		}
	}


}