//////////////////////////////////////////////////////
// MK Toon Unlit Editor Base						//
//					                                //
// Created by Michael Kremmel                       //
// www.michaelkremmel.de                            //
// Copyright © 2020 All rights reserved.            //
//////////////////////////////////////////////////////

#if UNITY_EDITOR
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using System.Linq;
using System;
using UnityEditor.Utils;
using UnityEditorInternal;
using EditorHelper = MK.Toon.Editor.EditorHelper;

// ------------------------------------------------------------------------------------------
// Note:
// All Editors are based on 3 different Lit modes and should inherit from at least one
// Outline, Refraction and Particles: Are treated as a "component"
//
// Every feature added in the future that use an additional render pass should be treated as a component
// Components should only be drawn if at least one nessecary Property (all properties still required) is found
//
// UnlitBase = ShaderGUI + Particles + Outline + Refraction + virtual base functions
//
// Shader Template:
// UnlitBase => Simple => Physically Based
//
// Enabling/Disabling shader passes would make the whole thing much easier (avoid variants for outline and refraction), however it only works for builtin lightModes, not for custom passes
// ------------------------------------------------------------------------------------------

namespace MK.Toon.Editor
{
    /// <summary>
    /// Base class for unlit editors
    /// </summary>
    internal abstract class UnlitEditorBase : ShaderGUI
    {
        public UnlitEditorBase(RenderPipeline renderPipeline)
        {
            _shaderTemplate = ShaderTemplate.Unlit;
            _renderPipeline = renderPipeline;
        }

        //CurvedWorldSupport
        //CurvedWorldEditor
        //protected MaterialProperty _curvedWorldBlendSettings;
        //

        /////////////////////////////////////////////////////////////////////////////////////////////
        // Properties                                                                              //
        /////////////////////////////////////////////////////////////////////////////////////////////
        protected ShaderTemplate _shaderTemplate;
        protected RenderPipeline _renderPipeline; 
   
        /////////////////
        // Options     //
        /////////////////
        protected MaterialProperty _surface;
        protected MaterialProperty _zWrite;
        protected MaterialProperty _blend;
        protected MaterialProperty _zTest;
        protected MaterialProperty _blendSrc;
        protected MaterialProperty _blendDst;
        protected MaterialProperty _blendSrcAlpha;
        protected MaterialProperty _blendDstAlpha;
        protected MaterialProperty _alphaClipping;
        protected MaterialProperty _renderFace;

        /////////////////
        // Input       //
        /////////////////
        protected MaterialProperty _albedoColor;
        protected MaterialProperty _alphaCutoff;
        protected MaterialProperty _albedoMap;
        protected MaterialProperty _albedoMapIntensity;

        /////////////////
        // Stylize     //
        /////////////////
        protected MaterialProperty _hue;
        protected MaterialProperty _contrast;
        protected MaterialProperty _saturation;
        protected MaterialProperty _brightness;
        protected MaterialProperty _colorGrading;
        protected MaterialProperty _vertexAnimation;
        protected MaterialProperty _vertexAnimationStutter;
        protected MaterialProperty _vertexAnimationFrequency;
        protected MaterialProperty _vertexAnimationIntensity;
        protected MaterialProperty _vertexAnimationMap;
        protected MaterialProperty _dissolve;
        protected MaterialProperty _dissolveMap;
        protected MaterialProperty _dissolveMapScale;
        protected MaterialProperty _dissolveAmount;
        protected MaterialProperty _dissolveBorderSize;
        protected MaterialProperty _dissolveBorderRamp;
        protected MaterialProperty _dissolveBorderColor;

        /////////////////
        // Advanced    //
        /////////////////
        protected MaterialProperty _screenSpaceReflections;
        protected MaterialProperty _screenSpaceReflectionsContributeTransparent;
        protected MaterialProperty _renderPriority;
        protected MaterialProperty _alembicMotionVectors;

        //Stencil
        protected MaterialProperty _stencil;
        protected MaterialProperty _stencilRef;
        protected MaterialProperty _stencilReadMask;
        protected MaterialProperty _stencilWriteMask;
        protected MaterialProperty _stencilComp;
        protected MaterialProperty _stencilPass;
        protected MaterialProperty _stencilFail;
        protected MaterialProperty _stencilZFail;

        /////////////////
        // Editor Only //
        /////////////////
        protected MaterialProperty _initialized;
        protected MaterialProperty _optionsTab;
        protected MaterialProperty _inputTab;
        protected MaterialProperty _stylizeTab;
        protected MaterialProperty _advancedTab;
        protected FontStyle _defaultFontStyle;

        /////////////////
        // Outline     //
        /////////////////
        protected MK.Toon.Editor.OutlineComponent _outline = new MK.Toon.Editor.OutlineComponent();

        /////////////////
        // Refraction  //
        /////////////////
        protected MK.Toon.Editor.RefractionComponent _refraction = new MK.Toon.Editor.RefractionComponent();

        /////////////////
        // Particles   //
        /////////////////
        protected MK.Toon.Editor.ParticlesComponent _particles = new MK.Toon.Editor.ParticlesComponent();

        /// <summary>
        /// Find Properties to draw the editor
        /// </summary>
        /// <param name="props"></param>
        protected virtual void FindProperties(MaterialProperty[] props)
        {
            //CurvedWorldSupport
            //CurvedWorldEditor
            //_curvedWorldBlendSettings = FindProperty(Properties.curvedWorldBlendSettings.uniform.name, props, false);
            //

            _surface = FindProperty(Properties.surface.uniform.name, props);
            _zWrite = FindProperty(Properties.zWrite.uniform.name, props);
            _blend = FindProperty(Properties.blend.uniform.name, props);
            _zTest = FindProperty(Properties.zTest.uniform.name, props);
            _blendSrc = FindProperty(Properties.blendSrc.uniform.name, props);
            _blendDst = FindProperty(Properties.blendDst.uniform.name, props);
            _blendSrcAlpha = FindProperty(Properties.blendSrcAlpha.uniform.name, props);
            _blendDstAlpha = FindProperty(Properties.blendDstAlpha.uniform.name, props);
            _alphaClipping = FindProperty(Properties.alphaClipping.uniform.name, props);
            _renderFace = FindProperty(Properties.renderFace.uniform.name, props);

            _albedoColor = FindProperty(Properties.albedoColor.uniform.name, props);
            _alphaCutoff = FindProperty(Properties.alphaCutoff.uniform.name, props);
            _albedoMap = FindProperty(Properties.albedoMap.uniform.name, props);
            _albedoMapIntensity = FindProperty(Properties.albedoMapIntensity.uniform.name, props);

            _colorGrading = FindProperty(Properties.colorGrading.uniform.name, props);
            _hue = FindProperty(Properties.hue.uniform.name, props);
            _contrast = FindProperty(Properties.contrast.uniform.name, props);
            _saturation = FindProperty(Properties.saturation.uniform.name, props);
            _brightness = FindProperty(Properties.brightness.uniform.name, props);

            _vertexAnimation = FindProperty(Properties.vertexAnimation.uniform.name, props);
            _vertexAnimationStutter = FindProperty(Properties.vertexAnimationStutter.uniform.name, props);
            _vertexAnimationFrequency = FindProperty(Properties.vertexAnimationFrequency.uniform.name, props);
            _vertexAnimationIntensity = FindProperty(Properties.vertexAnimationIntensity.uniform.name, props);
            _vertexAnimationMap = FindProperty(Properties.vertexAnimationMap.uniform.name, props);

            _dissolve = FindProperty(Properties.dissolve.uniform.name, props);
            _dissolveMap = FindProperty(Properties.dissolveMap.uniform.name, props);
            _dissolveMapScale = FindProperty(Properties.dissolveMapScale.uniform.name, props);
            _dissolveAmount = FindProperty(Properties.dissolveAmount.uniform.name, props);
            _dissolveBorderRamp = FindProperty(Properties.dissolveBorderRamp.uniform.name, props);
            _dissolveBorderSize = FindProperty(Properties.dissolveBorderSize.uniform.name, props);
            _dissolveBorderColor = FindProperty(Properties.dissolveBorderColor.uniform.name, props);
            
            _screenSpaceReflectionsContributeTransparent = FindProperty(Properties.screenSpaceReflectionsContributeTransparent.uniform.name, props, false);
            _renderPriority = FindProperty(Properties.renderPriority.uniform.name, props);
            _alembicMotionVectors = FindProperty(Properties.alembicMotionVectors.uniform.name, props, false);

            _stencil = FindProperty(Properties.stencil.uniform.name, props);
            _stencilRef = FindProperty(Properties.stencilRef.uniform.name, props);
            _stencilReadMask = FindProperty(Properties.stencilReadMask.uniform.name, props);
            _stencilWriteMask = FindProperty(Properties.stencilWriteMask.uniform.name, props);
            _stencilComp = FindProperty(Properties.stencilComp.uniform.name, props);
            _stencilPass = FindProperty(Properties.stencilPass.uniform.name, props);
            _stencilFail = FindProperty(Properties.stencilFail.uniform.name, props);
            _stencilZFail = FindProperty(Properties.stencilZFail.uniform.name, props);

            _initialized = FindProperty(EditorProperties.initialized.uniform.name, props);
            _optionsTab = FindProperty(EditorProperties.optionsTab.uniform.name, props);
            _inputTab = FindProperty(EditorProperties.inputTab.uniform.name, props);
            _stylizeTab = FindProperty(EditorProperties.stylizeTab.uniform.name, props);
            _advancedTab = FindProperty(EditorProperties.advancedTab.uniform.name, props);

            _outline.FindProperties(props);
            _refraction.FindProperties(props);
            _particles.FindProperties(props);
        }

        /////////////////////////////////////////////////////////////////////////////////////////////
		// Setup                                                                                   //
		/////////////////////////////////////////////////////////////////////////////////////////////
        
        /// <summary>
        /// Find similar values from the changed shader
        /// </summary>
        /// <param name="propertiesSrc"></param>
        /// <param name="materialDst"></param>
        /// <param name="materialSrc"></param>
        protected virtual void ConvertSimilarValues(MaterialProperty[] propertiesSrc, Material materialSrc, Material materialDst)
        {
            MaterialProperty mainTex = FindProperty("_MainTex", propertiesSrc, false);
            MaterialProperty color = FindProperty("_Color", propertiesSrc, false);
            MaterialProperty baseTex = FindProperty("_BaseTex", propertiesSrc, false);
            MaterialProperty baseMap = FindProperty("_BaseMap", propertiesSrc, false);
            MaterialProperty baseColor = FindProperty("_BaseColor", propertiesSrc, false);
            MaterialProperty cutoff = FindProperty("_Cutoff", propertiesSrc, false);
            MaterialProperty cull = FindProperty("_Cull", propertiesSrc, false);
            MaterialProperty alphaClip = FindProperty("_AlphaClip", propertiesSrc, false);
            MaterialProperty surface = FindProperty("_SurfaceType", propertiesSrc, false);
            MaterialProperty mode = FindProperty("_Mode", propertiesSrc, false);
            MaterialProperty blend = FindProperty("_BlendMode", propertiesSrc, false);
            MaterialProperty addPrecomputedVelocity = FindProperty("_AddPrecomputedVelocity", propertiesSrc, false);

            if(mode != null)
                Properties.surface.SetValue(materialDst, mode.floatValue <= 1 ? Surface.Opaque : Surface.Transparent);
            if(surface != null)
                Properties.surface.SetValue(materialDst, surface.floatValue > 0 ? Surface.Transparent : Surface.Opaque);
            if(blend != null)
                Properties.blend.SetValue(materialDst, (Blend) ((int) blend.floatValue));

            if(materialSrc.shader.name.Contains("Universal Render Pipeline") || materialSrc.shader.name.Contains("Lightweight Render Pipeline"))
            {
                if(alphaClip != null)
                    Properties.alphaClipping.SetValue(materialDst, alphaClip.floatValue > 0 ? true : false);
                if(baseTex != null)
                    Properties.albedoMap.SetValue(materialDst, baseTex.textureValue);
                if(baseMap != null)
                    Properties.albedoMap.SetValue(materialDst, baseMap.textureValue);
                if(baseColor != null)
                    Properties.albedoColor.SetValue(materialDst, baseColor.colorValue);
            }
            else
            {
                if(mode != null)
                    Properties.alphaClipping.SetValue(materialDst, mode.floatValue == 1 ? true : false);
                if(mainTex != null)
                {
                    Properties.albedoMap.SetValue(materialDst, mainTex.textureValue);
                    Properties.mainTiling.SetValue(materialDst, materialSrc.mainTextureScale);
                    Properties.mainOffset.SetValue(materialDst, materialSrc.mainTextureOffset);
                }
                if(color != null)
                    Properties.albedoColor.SetValue(materialDst, color.colorValue);
            }

            if(cutoff != null)
                Properties.alphaCutoff.SetValue(materialDst, cutoff.floatValue);
            if(cull != null)
                Properties.renderFace.SetValue(materialDst, (RenderFace) cull.floatValue);

            if(_alembicMotionVectors != null)
            {
                if(addPrecomputedVelocity != null)
                {
                    Properties.alembicMotionVectors.SetValue(materialDst, addPrecomputedVelocity.floatValue > 0 ? true : false);
                }
            }
        }

        /// <summary>
        /// Unity Message AssignNewShaderToMaterial, override MaterialSetup instead
        /// </summary>
        /// <param name="materialDst"></param>
        /// <param name="oldShader"></param>
        /// <param name="newShader"></param>
        public override void AssignNewShaderToMaterial(Material materialDst, Shader oldShader, Shader newShader)
        {
            MaterialSetup(materialDst, oldShader, newShader);
        }

        protected void SetBoldFontStyle(bool b)
        {
            EditorStyles.label.fontStyle = b ? FontStyle.Bold : _defaultFontStyle;
        }

        /// <summary>
        /// Unity Message OnGUI, override DrawInspector instead
        /// </summary>
        /// <param name="materialEditor"></param>
        /// <param name="properties"></param>
        public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] properties)
        {
            Material material = materialEditor.target as Material;
            _defaultFontStyle = EditorStyles.label.fontStyle;
            FindProperties(properties);

            #if !UNITY_2021_2_OR_NEWER
            EditorGUI.BeginChangeCheck();
            #endif
            DrawInspector(materialEditor, properties, material);

            #if !UNITY_2021_2_OR_NEWER
            if(EditorGUI.EndChangeCheck())
            {
                foreach (Material mat in _stylizeTab.targets)
                    ValidateMaterial(mat);
            }
            #endif
        }

        /// <summary>
        /// Setup the material when shader is changed
        /// </summary>
        /// <param name="materialDst"></param>
        /// <param name="oldShader"></param>
        /// <param name="newShader"></param>
        protected virtual void MaterialSetup(Material materialDst, Shader oldShader, Shader newShader)
        {            
            Material materialSrc = new Material(materialDst);
            MaterialProperty[] propertiesSrc = MaterialEditor.GetMaterialProperties(new Material[] { materialSrc });

            base.AssignNewShaderToMaterial(materialDst, oldShader, newShader);

            MaterialProperty[] propertiesDst = MaterialEditor.GetMaterialProperties(new Material[] { materialDst });
            FindProperties(propertiesDst);
            _particles.FindProperties(propertiesDst);
            _outline.FindProperties(propertiesDst);
            _refraction.FindProperties(propertiesDst);

            ConvertSimilarValues(propertiesSrc, materialSrc, materialDst);

            if(_outline.active)
            {
                Properties.surface.SetValue(materialDst, Surface.Opaque, Properties.alphaClipping.GetValue(materialDst));
            }
            if(_refraction.active)
            {
                Properties.surface.SetValue(materialDst, Surface.Transparent, Properties.alphaClipping.GetValue(materialDst));
            }

            UpdateKeywords(materialDst);
        }

        /////////////////////////////////////////////////////////////////////////////////////////////
		// Draw                                                                                    //
		/////////////////////////////////////////////////////////////////////////////////////////////
        
        /// <summary>
        /// Unlit warning for legacy renderpipeline
        /// </summary>
        protected void LegacyUnlitWarning()
        {
            EditorGUILayout.HelpBox("To completely unlit, please disable shadow casting & recieving on the MeshRenderer", MessageType.Info);
        }

        /////////////////
        // Options     //
        /////////////////
        protected bool OptionsBehavior(MaterialEditor materialEditor)
        {
            return EditorHelper.HandleBehavior("Options", "", _optionsTab, null, materialEditor, false);
        }
        
        protected virtual void DrawSurfaceType(MaterialEditor materialEditor)
        {
            materialEditor.ShaderProperty(_surface, UI.surface);
        }

        /*
        protected virtual void DrawZWrite(MaterialEditor materialEditor)
        {
            EditorGUI.BeginChangeCheck();
            materialEditor.ShaderProperty(_zWrite, UI.zWrite, 1);
            EditorGUI.EndChangeCheck();
        }
        */

        protected virtual void DrawCustomBlend(MaterialEditor materialEditor)
        {
            if((Blend) _blend.floatValue == Blend.Custom)
            {
                materialEditor.ShaderProperty(_zWrite, UI.zWrite, 1);
                materialEditor.ShaderProperty(_zTest, UI.zTest, 1);
                materialEditor.ShaderProperty(_blendSrc, UI.blendSrc, 1);
                materialEditor.ShaderProperty(_blendDst, UI.blendDst, 1);
                if(_renderPipeline == RenderPipeline.Universal)
                {
                    materialEditor.ShaderProperty(_blendSrcAlpha, UI.blendSrcAlpha, 1);
                    materialEditor.ShaderProperty(_blendDstAlpha, UI.blendDstAlpha, 1);
                }
            }
        }

        protected virtual void DrawBlend(MaterialEditor materialEditor)
        {
            EditorGUI.showMixedValue = _blend.hasMixedValue;
            Blend blend = (Blend) _blend.floatValue;

            EditorGUI.BeginChangeCheck();
            if((Surface) _surface.floatValue == Surface.Transparent)
                blend = (Blend) EditorGUILayout.EnumPopup(UI.blend, (Blend) blend);
            else
                blend = (Blend) EditorGUILayout.EnumPopup(UI.blend, (BlendOpaque) blend);
            if(EditorGUI.EndChangeCheck())
            {
                materialEditor.RegisterPropertyChangeUndo("Blend");
                _blend.floatValue = (int) blend;
            }
            EditorGUI.showMixedValue = false;
        }

        protected virtual void DrawRenderFace(MaterialEditor materialEditor)
        {
            materialEditor.ShaderProperty(_renderFace, UI.renderFace);
        }

        protected virtual void DrawAlphaClipping(MaterialEditor materialEditor)
        {
            materialEditor.ShaderProperty(_alphaClipping, UI.alphaClipping);

            if(_alphaClipping.floatValue == 1)
            {
                materialEditor.ShaderProperty(_alphaCutoff, UI.alphaCutoff);
            }
        }

        /// <summary>
        /// Draw the content of the Options Behavior
        /// </summary>
        /// <param name="materialEditor"></param>
        protected virtual void DrawOptionsContent(MaterialEditor materialEditor)
        {
            DrawSurfaceType(materialEditor);
            DrawBlend(materialEditor);
            DrawCustomBlend(materialEditor);
            DrawRenderFace(materialEditor);
            DrawAlphaClipping(materialEditor);
        }

        private void DrawOptions(MaterialEditor materialEditor)
        {
            EditorHelper.DrawSplitter();
            if(OptionsBehavior(materialEditor))
            {
                DrawOptionsContent(materialEditor);
            }
        }

        /////////////////
        // Input       //
        /////////////////
        protected bool InputBehavior(MaterialEditor materialEditor)
        {
            return EditorHelper.HandleBehavior("Input", "", _inputTab, null, materialEditor, true);
        }

        protected void DrawMainHeader()
        {
            EditorGUILayout.LabelField("Main: ", UnityEditor.EditorStyles.boldLabel);
        }

        protected virtual void DrawAlbedoMap(MaterialEditor materialEditor)
        {
            if(_albedoMap.textureValue == null)
                materialEditor.TexturePropertySingleLine(UI.albedoMap, _albedoMap, _albedoColor);
            else
                materialEditor.TexturePropertySingleLine(UI.albedoMap, _albedoMap, _albedoColor, _albedoMapIntensity);
        }

        protected void DrawAlbedoScaleTransform(MaterialEditor materialEditor)
        {
            materialEditor.TextureScaleOffsetProperty(_albedoMap);
        }
            
        /// <summary>
        /// Draw the Input Content
        /// </summary>
        /// <param name="materialEditor"></param>
        protected virtual void DrawInputContent(MaterialEditor materialEditor)
        {
            DrawMainHeader();
            DrawAlbedoMap(materialEditor);
            DrawAlbedoScaleTransform(materialEditor);
        }

        private void DrawInput(MaterialEditor materialEditor)
        {
            if(InputBehavior(materialEditor))
            {
                DrawInputContent(materialEditor);
            }
        }

        /////////////////
        // Stylize     //
        /////////////////
        protected bool StylizeBehavior(MaterialEditor materialEditor)
        {
            return EditorHelper.HandleBehavior("Stylize", "", _stylizeTab, null, materialEditor, true);
        }

        protected void DrawColorGradingHeader()
        {
            EditorGUILayout.LabelField("Color Grading:", UnityEditor.EditorStyles.boldLabel);
        }

        protected virtual void DrawColorGrading(MaterialEditor materialEditor)
        {
            //DrawColorGradingHeader();
            SetBoldFontStyle(true);
            materialEditor.ShaderProperty(_colorGrading, UI.colorGrading);
            SetBoldFontStyle(false);
            if(_colorGrading.floatValue != (int)(ColorGrading.Off))
            {
                materialEditor.ShaderProperty(_contrast, UI.contrast);
                materialEditor.ShaderProperty(_saturation, UI.saturation);
                materialEditor.ShaderProperty(_brightness, UI.brightness);
                materialEditor.ShaderProperty(_hue, UI.hue);
            }
        }

        protected void DrawDissolveHeader()
        {
            EditorGUILayout.LabelField("Dissolve:", UnityEditor.EditorStyles.boldLabel);
        }

        protected virtual void DrawDissolve(MaterialEditor materialEditor)
        {
            //DrawDissolveHeader();
            SetBoldFontStyle(true);
            materialEditor.ShaderProperty(_dissolve, UI.dissolve);
            SetBoldFontStyle(false);
            if(_dissolve.floatValue != (int)Dissolve.Off)
            {
                if(_dissolveMap.textureValue != null)
                    materialEditor.TexturePropertySingleLine(UI.dissolveMap, _dissolveMap, _dissolveMapScale);
                else
                    materialEditor.TexturePropertySingleLine(UI.dissolveMap, _dissolveMap);

                if(_dissolveMap.textureValue != null)
                {
                    materialEditor.ShaderProperty(_dissolveAmount, UI.dissolveAmount);
                    if(_dissolve.floatValue == (int)Dissolve.BorderRamp)
                    {
                        materialEditor.TexturePropertySingleLine(UI.dissolveBorderRamp, _dissolveBorderRamp, _dissolveBorderSize, _dissolveBorderColor);
                    }
                    else if(_dissolve.floatValue == (int)Dissolve.BorderColor)
                    {
                        materialEditor.ShaderProperty(_dissolveBorderColor, UI.dissolveBorderColor);
                        materialEditor.ShaderProperty(_dissolveBorderSize, UI.dissolveBorderSize);
                    }
                }
            }
        }

        protected void DrawVertexAnimationHeader()
        {
            EditorGUILayout.LabelField("Vertex Animation:", UnityEditor.EditorStyles.boldLabel);
        }

        protected virtual void DrawVertexAnimation(MaterialEditor materialEditor)
        {
            //DrawVertexAnimationHeader();
            SetBoldFontStyle(true);
            materialEditor.ShaderProperty(_vertexAnimation, UI.vertexAnimation);
            SetBoldFontStyle(false);

            if((VertexAnimation) _vertexAnimation.floatValue != VertexAnimation.Off)
            {
                materialEditor.TexturePropertySingleLine(UI.vertexAnimationMap, _vertexAnimationMap, _vertexAnimationIntensity);
                materialEditor.ShaderProperty(_vertexAnimationStutter, UI.vertexAnimationStutter);
                materialEditor.ShaderProperty(_vertexAnimationFrequency, UI.vertexAnimationFrequency);
            }
        }

        /// <summary>
        /// Draw Stylize Content
        /// </summary>
        /// <param name="materialEditor"></param>
        protected virtual void DrawStylizeContent(MaterialEditor materialEditor)
        {
            DrawColorGrading(materialEditor);

            EditorHelper.VerticalSpace();

            DrawDissolve(materialEditor);

            EditorHelper.VerticalSpace();
            DrawVertexAnimation(materialEditor);
        }

        private void DrawStylize(MaterialEditor materialEditor)
        {
            if(StylizeBehavior(materialEditor))
            {
                DrawStylizeContent(materialEditor);
            }
        }

        /////////////////
        // Advanced    //
        /////////////////
        protected bool AdvancedBehavior(MaterialEditor materialEditor)
        {
            return EditorHelper.HandleBehavior("Advanced", "", _advancedTab, null, materialEditor, true);
        }

        //Stencil Builtin
        private void SetBuiltinStencilSettings(MaterialEditor materialEditor, Material material)
        {
            EditorGUI.BeginChangeCheck();
            Properties.stencil.SetValue(material, Stencil.Builtin);
            if(EditorGUI.EndChangeCheck())
            {
                materialEditor.RegisterPropertyChangeUndo("Stencil Mode");
            }
        }

        protected void DrawStencilHeader()
        {
            EditorGUILayout.LabelField("Stencil:", UnityEditor.EditorStyles.boldLabel);
        }

        protected void DrawPipelineHeader()
        {
            EditorGUILayout.LabelField("Pipeline:", UnityEditor.EditorStyles.boldLabel);
        }

        protected void DrawRenderPriority(MaterialEditor materialEditor)
        {
            materialEditor.ShaderProperty(_renderPriority, UI.renderPriority);
        }

        protected void DrawAddPrecomputedVelocity(MaterialEditor materialEditor)
        {
            #if UNITY_2023_2_OR_NEWER
            if(_alembicMotionVectors != null)
                materialEditor.ShaderProperty(_alembicMotionVectors, UI.alembicMotionVectors);
            #endif
        }

        protected virtual void DrawPipeline(MaterialEditor materialEditor)
        {
            DrawPipelineHeader();

            materialEditor.EnableInstancingField();
            DrawRenderPriority(materialEditor);
            DrawAddPrecomputedVelocity(materialEditor);
        }

        protected virtual void DrawStencil(MaterialEditor materialEditor, Material material)
        {
            DrawStencilHeader();

            materialEditor.ShaderProperty(_stencil, UI.stencil);
            if(_stencil.floatValue == (int)Stencil.Custom)
            {
                materialEditor.ShaderProperty(_stencilRef, UI.stencilRef);
                materialEditor.ShaderProperty(_stencilReadMask, UI.stencilReadMask);
                materialEditor.ShaderProperty(_stencilWriteMask, UI.stencilWriteMask);
                materialEditor.ShaderProperty(_stencilComp, UI.stencilComp);
                materialEditor.ShaderProperty(_stencilPass, UI.stencilPass);
                materialEditor.ShaderProperty(_stencilFail, UI.stencilFail);
                materialEditor.ShaderProperty(_stencilZFail, UI.stencilZFail);
            }
            else// if(_stencil.floatValue == (int)Stencil.Builtin)
            {
                SetBuiltinStencilSettings(materialEditor, material);
            }
        }

        protected void DrawScreenSpaceReflections(MaterialEditor materialEditor, Material material)
        {
            #if URP_SCREEN_SPACE_REFLECTION
            bool isTransparent = material.renderQueue >= (int) UnityEngine.Rendering.RenderQueue.Transparent;
            if(_screenSpaceReflections != null)
                materialEditor.ShaderProperty(_screenSpaceReflections, UI.screenSpaceReflections);
            if(_screenSpaceReflectionsContributeTransparent != null && isTransparent)
                materialEditor.ShaderProperty(_screenSpaceReflectionsContributeTransparent, UI.screenSpaceReflectionsContributeTransparent);
            #endif
        }

        /// <summary>
        /// Draw Advanced Content
        /// </summary>
        /// <param name="materialEditor"></param>
        protected virtual void DrawAdvancedContent(MaterialEditor materialEditor, Material material)
        {            
            DrawScreenSpaceReflections(materialEditor, material);
            DrawPipeline(materialEditor);
            EditorHelper.Divider();
            DrawStencil(materialEditor, material);
        }

        private void DrawAdvanced(MaterialEditor materialEditor, Material material)
        {
            if(AdvancedBehavior(materialEditor))
            {
                DrawAdvancedContent(materialEditor, material);
            }
            EditorHelper.DrawSplitter();
        }

        /// <summary>
        /// Draw the complete editor based on the tabs
        /// </summary>
        /// <param name="materialEditor"></param>
        /// <param name="properties"></param>
        protected virtual void DrawInspector(MaterialEditor materialEditor, MaterialProperty[] properties, Material material)
        {
            //get properties
            FindProperties(properties);

            //EditorGUI.BeginChangeCheck();
            //CurvedWorldSupport
            //CurvedWorldEditor
            //if (_curvedWorldBlendSettings != null)
            //    materialEditor.ShaderProperty(_curvedWorldBlendSettings, "Curved World Blend Settings");
            //

            DrawOptions(materialEditor);
            DrawInput(materialEditor);
            DrawStylize(materialEditor);
            DrawAdvanced(materialEditor, material);
            _particles.DrawParticles(materialEditor, properties, _surface, _shaderTemplate);
            _refraction.DrawRefraction(materialEditor, properties);
            _outline.DrawOutline(materialEditor, properties);

            //EditorGUI.EndChangeCheck();
        }

        /////////////////////////////////////////////////////////////////////////////////////////////
		// Variants Setup                                                                          //
		/////////////////////////////////////////////////////////////////////////////////////////////
        
        private void ManageKeywordsBlend(Material material)
        {
            //Colorsource
            Blend bm = Properties.blend.GetValue(material);
            EditorHelper.SetKeyword(Properties.blend.GetValue(material) == Blend.Premultiply, Keywords.blend[1], material);
            EditorHelper.SetKeyword(Properties.blend.GetValue(material) == Blend.Additive, Keywords.blend[2], material);
            EditorHelper.SetKeyword(Properties.blend.GetValue(material) == Blend.Multiply, Keywords.blend[3], material);
            EditorHelper.SetKeyword(Properties.blend.GetValue(material) == Blend.Custom, Keywords.blend[4], material);
            //No Keyword == Alpha

            Properties.blend.SetValue(material, bm);
        }

        private void ManageKeywordsAlbedoMap(Material material)
        {
            //Colorsource
            EditorHelper.SetKeyword(Properties.albedoMap.GetValue(material), Keywords.albedoMap, material);
            //No Keyword == Vertex Colors
        }

        private void ManageKeywordsSurface(Material material)
        {
            //Surface Type
            Properties.surface.SetValue(material, Properties.surface.GetValue(material), Properties.alphaClipping.GetValue(material));
            //No Keyword == Opaque
        }

        private void ManageKeywordsAlphaClipping(Material material)
        {
            //Alpha Clipping
            Properties.alphaClipping.SetValue(material, Properties.alphaClipping.GetValue(material));
            //No Keyword == No Alpha Clipping
        }

        private void ManageKeywordsColorGrading(Material material)
        {
            //ColorGrading
            EditorHelper.SetKeyword(Properties.colorGrading.GetValue(material) == ColorGrading.Albedo, Keywords.colorGrading[1], material);
            EditorHelper.SetKeyword(Properties.colorGrading.GetValue(material) == ColorGrading.FinalOutput, Keywords.colorGrading[2], material);
            //No keyword = No ColorGrading
        }

        private void ManageKeywordsDissolve(Material material)
        {
            //Dissolve
            EditorHelper.SetKeyword(Properties.dissolve.GetValue(material) == Dissolve.Default, Keywords.dissolve[1], material);
            EditorHelper.SetKeyword(Properties.dissolve.GetValue(material) == Dissolve.BorderColor, Keywords.dissolve[2], material);
            EditorHelper.SetKeyword(Properties.dissolve.GetValue(material) == Dissolve.BorderRamp, Keywords.dissolve[3], material);
            //No Keyword = Dissolve Off
        }

        private void ManageKeywordsVertexAnimation(Material material)
        {
            //Vertex animation
            EditorHelper.SetKeyword(Properties.vertexAnimation.GetValue(material) == VertexAnimation.Sine, Keywords.vertexAnimation[1], material);
            EditorHelper.SetKeyword(Properties.vertexAnimation.GetValue(material) == VertexAnimation.Pulse, Keywords.vertexAnimation[2], material);
            EditorHelper.SetKeyword(Properties.vertexAnimation.GetValue(material) == VertexAnimation.Noise, Keywords.vertexAnimation[3], material);
            //No Keyword = Vertex Animation Off
        }

        private void ManageKeywordsVertexAnimationStutter(Material material)
        {
            EditorHelper.SetKeyword(Properties.vertexAnimationStutter.GetValue(material), Keywords.vertexAnimationStutter, material);
            //No Keyword = Vertex Animation Stutter Off
        }

        private void ManageKeywordsVertexAnimationMap(Material material)
        {
            EditorHelper.SetKeyword(Properties.vertexAnimationMap.GetValue(material) != null, Keywords.vertexAnimationMap, material);
            //No Keyword = Vertex Animation Map Off
        }

        private void ManageKeywordsScreenSpaceReflections(Material material)
        {
            #if URP_SCREEN_SPACE_REFLECTION
            bool isTransparent = material.renderQueue >= (int) UnityEngine.Rendering.RenderQueue.Transparent;
            if(_screenSpaceReflections != null)
                EditorHelper.SetKeyword(Properties.screenSpaceReflections.GetValue(material) == false, "_SCREENSPACEREFLECTIONS_OFF", material);
            if(_screenSpaceReflectionsContributeTransparent != null && isTransparent)
                EditorHelper.SetKeyword(Properties.screenSpaceReflectionsContributeTransparent.GetValue(material) == false && material.renderQueue >= (int) UnityEngine.Rendering.RenderQueue.Transparent, "_SCREENSPACEREFLECTIONSCONTRIBUTETRANSPARENT_OFF", material);
            #endif
        }

        private void ManageKeywordsAlembicMotionVecotrs(Material material)
        {
            #if UNITY_2023_2_OR_NEWER
            if(_alembicMotionVectors != null)
            {
                EditorHelper.SetKeyword(Properties.alembicMotionVectors.GetValue(material), Keywords.alembicMotionVectors, material);
            }
            material.SetShaderPassEnabled("MotionVectors", true);
            #endif
        }

        private void UpdateRenderPriority(Material material)
        {
            Properties.renderPriority.SetValue(material, Properties.renderPriority.GetValue(material), Properties.alphaClipping.GetValue(material));
        }

        private void UpdateSystemProperties(Material material)
        {
            Properties.UpdateSystemProperties(material);
        }

        protected virtual void UpdateKeywords(Material material)
        {
            ManageKeywordsBlend(material);
            ManageKeywordsAlbedoMap(material);
            ManageKeywordsDissolve(material);
            ManageKeywordsAlphaClipping(material);
            ManageKeywordsSurface(material);
            UpdateRenderPriority(material);
            UpdateSystemProperties(material);
            ManageKeywordsColorGrading(material);
            ManageKeywordsVertexAnimation(material);
            ManageKeywordsVertexAnimationMap(material);
            ManageKeywordsVertexAnimationStutter(material);
            ManageKeywordsAlembicMotionVecotrs(material);
            ManageKeywordsScreenSpaceReflections(material);
            _particles.UpdateKeywords(material);
            _outline.ManageKeywordsOutline(material);
            _outline.ManageKeywordsOutlineNoise(material);
            _outline.ManageKeywordsOutlineMap(material);
            _outline.ManageKeywordsOutlineData(material);
            _refraction.ManageKeywordsRefractionMap(material);
            _refraction.ManageKeywordsIndexOfRefraction(material);
        }

        #if UNITY_2021_2_OR_NEWER
        public override void ValidateMaterial(Material material)
        {
            UpdateKeywords(material);
        }
        #else
        public void ValidateMaterial(Material material)
        {
            UpdateKeywords(material);
        }
        #endif
    }
}
#endif