using System;
using System.IO;
using System.Linq;
using System.Collections.Generic;

using UnityEngine;
using UnityEditor;


namespace AmazingAssets.CurvedWorldEditor
{
    public static class EditorUtilities
    {
        public enum EXTENSTION { cginc, UnityShaderGraphNormal, UnityShaderGraphVertex, AmplifyShaderEditorNormal, AmplifyShaderEditorVertex }
        public enum KEYWORDS_COMPILE { Default, ShaderFeature, MultiCompile }
        public enum RENDER_PIPELINE { Builtin, Universal, HighDefinition }
        public enum ACTIVATE_STATE { Done, Skip, Problem }



        static public readonly int MAX_SUPPORTED_BEND_IDS = 32;
        static public readonly int MAX_SUPPORTED_BEND_TYPES = Enum.GetValues(typeof(CurvedWorld.BEND_TYPE)).Length;
        static public string[] bendTypesNamesForLabel = Enum.GetValues(typeof(CurvedWorld.BEND_TYPE)).Cast<int>().Select(x => EditorUtilities.GetBendTypeNameInfo((CurvedWorld.BEND_TYPE)x).forLable).ToArray();
        static public string[] bendTypesNamesForMenu = Enum.GetValues(typeof(CurvedWorld.BEND_TYPE)).Cast<int>().Select(x => EditorUtilities.GetBendTypeNameInfo((CurvedWorld.BEND_TYPE)x).forMenu).ToArray();


        static public string shaderProprtyName_BendSettings = "_CurvedWorldBendSettings";
        static public string shaderKeywordName_CurvedWorldDisabled = "CURVEDWORLD_DISABLED_ON";
        static public string shaderKeywordName_BendTransformNormal = "CURVEDWORLD_NORMAL_TRANSFORMATION_ON";
        static public string shaderKeywordPrefix_BendType = "CURVEDWORLD_BEND_TYPE_";
        static public string shaderKeywordPrefix_BendID = "CURVEDWORLD_BEND_ID_";


        static public char[] invalidFileNameCharachters = Path.GetInvalidFileNameChars();


        static string curvedWorldEditorFolderPath;
        static string curvedWorldTransformFilePath;
        static string amplifyShaderEditorWindowPath;


        static Dictionary<int, BendFiles> projectBendsFilePathes = null;




        static public string GetCurvedWorldEditorFolderPath()
        {
            if (string.IsNullOrEmpty(curvedWorldEditorFolderPath))
            {
                string[] assets = AssetDatabase.FindAssets("CurvedWorldTransform");

                if (assets != null && assets.Length > 0)
                {
                    for (int i = 0; i < assets.Length; i++)
                    {
                        if (string.IsNullOrEmpty(assets[i]) == false)
                        {
                            string currentFilePath = AssetDatabase.GUIDToAssetPath(assets[i]);

                            if (currentFilePath.Contains("Amazing Assets") &&
                                currentFilePath.Contains("Curved World") &&
                                currentFilePath.Contains("Shaders") &&
                                currentFilePath.Contains("Core") &&
                                Path.GetExtension(currentFilePath) == ".cginc")

                            {
                                curvedWorldEditorFolderPath = Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(currentFilePath)));
                                break;
                            }
                        }
                    }
                }
            }

            return curvedWorldEditorFolderPath;
        }

        static public string GetCoreTransformFilePath()
        {
            if (string.IsNullOrEmpty(curvedWorldTransformFilePath) || File.Exists(curvedWorldTransformFilePath) == false)
            {
                curvedWorldTransformFilePath = Path.Combine(GetCurvedWorldEditorFolderPath(), "Shaders", "Core", "CurvedWorldTransform.cginc");
            }

            return curvedWorldTransformFilePath;
        }

        static public string GetCoreTransformFilePathForShader()
        {
            string pathToTransformCGINC = "\"" + GetCoreTransformFilePath() + "\"";
            pathToTransformCGINC = pathToTransformCGINC.Replace(Path.DirectorySeparatorChar, '/');
            pathToTransformCGINC = pathToTransformCGINC.Replace('\\', '/');

            return "#include " + pathToTransformCGINC;
        }

        static public string GetBendFileLocation(CurvedWorld.BEND_TYPE bendType, int bendID, EXTENSTION extention)
        {
            if (projectBendsFilePathes == null)
            {
                if (projectBendsFilePathes != null)
                    projectBendsFilePathes.Clear();

                projectBendsFilePathes = new Dictionary<int, BendFiles>();
            }

            bendID = (int)Mathf.Clamp(bendID, 1, EditorUtilities.MAX_SUPPORTED_BEND_IDS);

            int key = (int)bendType * EditorUtilities.MAX_SUPPORTED_BEND_IDS + bendID;


            if (projectBendsFilePathes.ContainsKey(key) == false)
            {
                BendFiles bendFiles;
                bendFiles.pathToCGINC = GetGeneratedFilePath(bendType, bendID, EXTENSTION.cginc, false);
                bendFiles.pathToUnityShaderGraphNormal = GetGeneratedFilePath(bendType, bendID, EXTENSTION.UnityShaderGraphNormal, false);
                bendFiles.pathToUnityShaderGraphVertex = GetGeneratedFilePath(bendType, bendID, EXTENSTION.UnityShaderGraphVertex, false);
                bendFiles.pathToAmplifyShaderEditorNormal = GetGeneratedFilePath(bendType, bendID, EXTENSTION.AmplifyShaderEditorNormal, false);
                bendFiles.pathToAmplifyShaderEditorVertex = GetGeneratedFilePath(bendType, bendID, EXTENSTION.AmplifyShaderEditorVertex, false);

                projectBendsFilePathes.Add(key, bendFiles);
            }


            switch (extention)
            {
                case EXTENSTION.cginc:
                    return projectBendsFilePathes[key].pathToCGINC;

                case EXTENSTION.UnityShaderGraphNormal:
                    return projectBendsFilePathes[key].pathToUnityShaderGraphNormal;
                case EXTENSTION.UnityShaderGraphVertex:
                    return projectBendsFilePathes[key].pathToUnityShaderGraphVertex;

                case EXTENSTION.AmplifyShaderEditorNormal:
                    return projectBendsFilePathes[key].pathToAmplifyShaderEditorNormal;
                case EXTENSTION.AmplifyShaderEditorVertex:
                    return projectBendsFilePathes[key].pathToAmplifyShaderEditorVertex;

                default:
                    return string.Empty;
            }
        }


        static public void RebuildProjectBendsInfo()
        {
            projectBendsFilePathes = null;


            for (int i = 0; i < MAX_SUPPORTED_BEND_TYPES; i++)
            {
                for (int j = 0; j < EditorUtilities.MAX_SUPPORTED_BEND_IDS; j++)
                {
                    GetBendFileLocation((CurvedWorld.BEND_TYPE)i, j, EXTENSTION.cginc);
                    GetBendFileLocation((CurvedWorld.BEND_TYPE)i, j, EXTENSTION.UnityShaderGraphNormal);
                    GetBendFileLocation((CurvedWorld.BEND_TYPE)i, j, EXTENSTION.UnityShaderGraphVertex);
                    GetBendFileLocation((CurvedWorld.BEND_TYPE)i, j, EXTENSTION.AmplifyShaderEditorNormal);
                    GetBendFileLocation((CurvedWorld.BEND_TYPE)i, j, EXTENSTION.AmplifyShaderEditorVertex);
                }
            }
        }


        static CurvedWorld.BEND_TYPE[] StringToBendTypes(string bendTypesString)
        {
            List<CurvedWorld.BEND_TYPE> list = new List<CurvedWorld.BEND_TYPE>();


            if (string.IsNullOrEmpty(bendTypesString) == false)
            {
                bendTypesString = bendTypesString.Replace("\"", string.Empty).Trim();

                string[] bendTypes = bendTypesString.Split(',');

                if (bendTypes != null && bendTypes.Length > 0)
                {
                    for (int j = 0; j < bendTypes.Length; j++)
                    {
                        CurvedWorld.BEND_TYPE bt;
                        if (System.Enum.TryParse(bendTypes[j], out bt))
                        {
                            list.Add(bt);
                        }
                    }
                }
            }

            return list.ToArray();
        }

        static int[] StringToBendIDs(string bendTypesString)
        {
            List<int> list = new List<int>();


            if (string.IsNullOrEmpty(bendTypesString) == false)
            {
                bendTypesString = bendTypesString.Replace("\"", string.Empty).Trim();

                string[] bendTypes = bendTypesString.Split(',');

                if (bendTypes != null && bendTypes.Length > 0)
                {
                    for (int j = 0; j < bendTypes.Length; j++)
                    {
                        int iOut;
                        if (int.TryParse(bendTypes[j], out iOut))
                        {
                            if (iOut >= 1 && iOut <= EditorUtilities.MAX_SUPPORTED_BEND_IDS)
                                list.Add(iOut);
                        }
                    }
                }
            }

            return list.ToArray();
        }

        static bool StringToNormalTransform(string normalTransfromString)
        {
            bool value = false;
            if (string.IsNullOrEmpty(normalTransfromString) == false && normalTransfromString.Length == 1 && normalTransfromString == "1")
                value = true;

            return value;
        }


        static public bool StringToBendSettings(string label, out CurvedWorld.BEND_TYPE[] bendTypes, out int[] bendIDs, out bool hasNormalTransform)
        {
            bendTypes = null;
            bendIDs = null;
            hasNormalTransform = false;

            if (string.IsNullOrEmpty(label) == false)
            {
                string[] bendSettings = label.Replace("\"", string.Empty).Trim().Split('|');

                if (bendSettings != null)
                {
                    if (bendSettings.Length == 2)
                    {
                        bendTypes = StringToBendTypes(bendSettings[0]);
                        bendIDs = StringToBendIDs(bendSettings[1]);
                        hasNormalTransform = false;

                        return true;
                    }
                    else if (bendSettings.Length == 3)
                    {
                        bendTypes = StringToBendTypes(bendSettings[0]);
                        bendIDs = StringToBendIDs(bendSettings[1]);
                        hasNormalTransform = StringToNormalTransform(bendSettings[2]);

                        return true;
                    }

                }
            }

            return false;
        }

        static public string BendSettingsToString(CurvedWorld.BEND_TYPE[] bendTypes, int[] bendIDs, bool hasNormalTransform)
        {
            if (bendTypes == null || bendTypes.Length == 0 || bendIDs == null || bendIDs.Length == 0)
                return string.Empty;

            bendTypes = (new List<CurvedWorld.BEND_TYPE>(bendTypes)).Distinct().OrderBy(x => (int)x).ToArray();
            bendIDs = (new List<int>(bendIDs)).Distinct().OrderBy(x => x).ToArray();


            return String.Join(",", bendTypes.Select(p => (int)p)) + "|" + String.Join(",", bendIDs) + (hasNormalTransform ? "|1" : string.Empty);
        }

        static public void GetBendSettingsFromVector(Vector4 prop, out CurvedWorld.BEND_TYPE bendType, out int bendID, out bool normalTransform)
        {
            bendType = (CurvedWorld.BEND_TYPE)prop[0];
            bendID = prop[1] <= 1 ? 1 : (int)prop[1];
            normalTransform = prop[2] == 1 ? true : false;
        }

        static public bool GetShaderSupportedBendSettings(Shader shader, out CurvedWorld.BEND_TYPE[] bendTypes, out int[] bendIDs, out bool hasNormalTransform)
        {
            bendTypes = null;
            bendIDs = null;
            hasNormalTransform = false;


            for (int i = 0; i < ShaderUtil.GetPropertyCount(shader); i++)
            {
                if (ShaderUtil.GetPropertyName(shader, i) == shaderProprtyName_BendSettings)
                {
                    string propertyDescription = ShaderUtil.GetPropertyDescription(shader, i);

                    if (StringToBendSettings(propertyDescription, out bendTypes, out bendIDs, out hasNormalTransform))
                        break;
                }
            }

            if (bendTypes != null && bendTypes.Length > 0 &&
               bendIDs != null && bendIDs.Length > 0)
            {
                return true;
            }
            else
            {
                bendTypes = null;
                bendIDs = null;

                return false;
            }

        }

        static public bool AddShaderBendSettings(Shader shader, CurvedWorld.BEND_TYPE bendType, int bendID, KEYWORDS_COMPILE keywordsCompile, bool reimport)
        {
            CurvedWorld.BEND_TYPE[] bendTypes;
            int[] bendIDs;
            bool hasNormalTransform;

            if (GetShaderSupportedBendSettings(shader, out bendTypes, out bendIDs, out hasNormalTransform))
            {
                if (bendTypes.Contains(bendType) == false)
                {
                    List<CurvedWorld.BEND_TYPE> temp = new List<CurvedWorld.BEND_TYPE>(bendTypes);
                    temp.Add(bendType);

                    bendTypes = temp.ToArray();
                }

                if (bendIDs.Contains(bendID) == false)
                {
                    List<int> temp = new List<int>(bendIDs);
                    temp.Add(bendID);

                    bendIDs = temp.ToArray();
                }


                return SetShaderBendSettings(shader, bendTypes, bendIDs, keywordsCompile, reimport);
            }

            return false;
        }

        static public bool SetShaderBendSettings(Shader shader, CurvedWorld.BEND_TYPE[] bendTypes, int[] bendIDs, KEYWORDS_COMPILE keywordsCompile, bool reimport)
        {
            if (shader == null || bendTypes == null || bendTypes.Length == 0 || bendIDs == null || bendIDs.Length == 0)
                return false;


            string propDescription = string.Empty;
            for (int i = 0; i < ShaderUtil.GetPropertyCount(shader); i++)
            {
                if (ShaderUtil.GetPropertyName(shader, i) == shaderProprtyName_BendSettings)
                {
                    propDescription = "\"" + ShaderUtil.GetPropertyDescription(shader, i).Trim() + "\"";
                    break;
                }
            }

            if (string.IsNullOrEmpty(propDescription))
                return false;



            string shaderFilePath = AssetDatabase.GetAssetPath(shader.GetInstanceID());
            if (string.IsNullOrEmpty(shaderFilePath))
                return false;



            string label = "\"" + BendSettingsToString(bendTypes, bendIDs, HasShaderNormalTransform(shader)) + "\"";


            string bendTypeKeywordString = null;
            string bendIDKeywordString = null;



            string[] allLines = File.ReadAllLines(shaderFilePath);

            bool replaceProperty = false;
            bool replaceBendTypeDefinitions = false;
            bool replaceBendIDDefinitions = false;

            //Replace Property
            for (int i = 0; i < allLines.Length; i++)
            {
                //Replace property 
                if (replaceProperty == false && allLines[i].Contains(shaderProprtyName_BendSettings) && allLines[i].Contains(propDescription))
                {
                    if (StringIsCommented(allLines[i]) == false)
                    {
                        allLines[i] = allLines[i].Replace(propDescription, label);

                        replaceProperty = true;
                        break;
                    }
                }
            }

            for (int i = 0; i < allLines.Length; i++)
            {
                //Replace Bend Type Keyword
                if (allLines[i].Contains(shaderKeywordPrefix_BendType) &&
                    (allLines[i].Contains("#define") || allLines[i].Contains("#pragma")))
                {
                    if (StringIsCommented(allLines[i]))
                        continue;

                    if (string.IsNullOrEmpty(bendTypeKeywordString))
                    {
                        if (bendTypes.Length == 1)
                        {
                            bendTypeKeywordString = "#define " + GetKeywordName(bendTypes[0]);
                        }
                        else
                        {
                            switch (keywordsCompile)
                            {
                                case KEYWORDS_COMPILE.ShaderFeature:
                                    bendTypeKeywordString = "#pragma shader_feature_local";
                                    break;

                                case KEYWORDS_COMPILE.MultiCompile:
                                    bendTypeKeywordString = "#pragma multi_compile_local";
                                    break;

                                default:
                                    bendTypeKeywordString = allLines[i].Contains("multi_compile_local") ? "#pragma multi_compile_local" : "#pragma shader_feature_local";
                                    break;
                            }

                            for (int j = 0; j < bendTypes.Length; j++)
                            {
                                bendTypeKeywordString += " " + GetKeywordName(bendTypes[j]);
                            }
                        }
                    }

                    allLines[i] = bendTypeKeywordString;

                    replaceBendTypeDefinitions = true;
                }


                //Replace Bend ID Keyword
                if (allLines[i].Contains(shaderKeywordPrefix_BendID) &&
                    (allLines[i].Contains("#define") || allLines[i].Contains("#pragma")))
                {

                    if (StringIsCommented(allLines[i]))
                        continue;

                    if (string.IsNullOrEmpty(bendIDKeywordString))
                    {
                        if (bendIDs.Length == 1)
                        {
                            bendIDKeywordString = "#define " + GetKeywordName(bendIDs[0]);
                        }
                        else
                        {
                            bendIDKeywordString = string.Empty;
                            switch (keywordsCompile)
                            {
                                case KEYWORDS_COMPILE.ShaderFeature:
                                    bendIDKeywordString = "#pragma shader_feature_local";
                                    break;

                                case KEYWORDS_COMPILE.MultiCompile:
                                    bendIDKeywordString = "#pragma multi_compile_local";
                                    break;

                                default:
                                    bendIDKeywordString = allLines[i].Contains("multi_compile_local") ? "#pragma multi_compile_local" : "#pragma shader_feature_local";
                                    break;
                            }

                            for (int j = 0; j < bendIDs.Length; j++)
                            {
                                bendIDKeywordString += " " + GetKeywordName(bendIDs[j]);
                            }
                        }
                    }

                    allLines[i] = bendIDKeywordString;

                    replaceBendIDDefinitions = true;
                }
            }


            File.WriteAllLines(shaderFilePath, allLines);


            if (reimport)
                AssetDatabase.ImportAsset(shaderFilePath);


            if (replaceProperty && replaceBendTypeDefinitions && replaceBendIDDefinitions)
                return true;
            else
            {
                return false;
            }
        }

        static public void SetMaterialBendSettings(Material material, CurvedWorld.BEND_TYPE bendType, int bendID, bool normalTransform)
        {
            if (material != null && material.shader != null && material.HasProperty(shaderProprtyName_BendSettings))
            {
                bendID = Mathf.Clamp(bendID, 1, MAX_SUPPORTED_BEND_IDS);


                //Setup shader Bend Type
                CurvedWorld.BEND_TYPE[] shadersBendTypes;
                int[] shadersBendIDs;
                bool hasNormalTransform;

                if (GetShaderSupportedBendSettings(material.shader, out shadersBendTypes, out shadersBendIDs, out hasNormalTransform))
                {
                    if (shadersBendTypes.Contains(bendType) == false)
                    {
                        List<CurvedWorld.BEND_TYPE> temp = new List<CurvedWorld.BEND_TYPE>(shadersBendTypes);
                        temp.Add(bendType);

                        shadersBendTypes = temp.ToArray();
                    }

                    if (shadersBendIDs.Contains(bendID) == false)
                    {
                        List<int> temp = new List<int>(shadersBendIDs);
                        temp.Add(bendID);

                        shadersBendIDs = temp.ToArray();
                    }

                    SetShaderBendSettings(material.shader, shadersBendTypes, shadersBendIDs, KEYWORDS_COMPILE.Default, false);


                    UpdateMaterialKeyWords(material, bendType, bendID, normalTransform);
                }
                else
                {
                    UpdateMaterialKeyWords(material, bendType, bendID, normalTransform);
                }
            }
        }

        static public void UpdateMaterialKeyWords(Material material, CurvedWorld.BEND_TYPE bendType, int bendID, bool normalTransform)
        {
            if (material == null || material.shader == null)
                return;


            if (normalTransform && HasShaderNormalTransform(material.shader) == false)
                normalTransform = false;



            List<string> keyWords = new List<string>(material.shaderKeywords);
            for (int i = keyWords.Count - 1; i >= 0; i -= 1)
            {
                if (keyWords[i].Contains(shaderKeywordPrefix_BendType) || keyWords[i].Contains(shaderKeywordPrefix_BendID))
                {
                    material.DisableKeyword(keyWords[i]);

                    keyWords.RemoveAt(i);
                }
            }

            material.DisableKeyword(shaderKeywordName_BendTransformNormal);
            keyWords.Remove(EditorUtilities.shaderKeywordName_BendTransformNormal);


            //Bend Type
            keyWords.Add(GetKeywordName(bendType));

            //Bend ID
            keyWords.Add(GetKeywordName(bendID));

            if (normalTransform)
                keyWords.Add(EditorUtilities.shaderKeywordName_BendTransformNormal);


            material.shaderKeywords = null;
            material.shaderKeywords = keyWords.ToArray();


            //Enable keywords
            {
                material.EnableKeyword(GetKeywordName(bendType));
                material.EnableKeyword(GetKeywordName(bendID));

                if (normalTransform)
                    material.EnableKeyword(shaderKeywordName_BendTransformNormal);
            }


            if (material.HasProperty(shaderProprtyName_BendSettings))
            {
                Vector4 prop = material.GetVector(shaderProprtyName_BendSettings);

                prop.x = (int)bendType;
                prop.y = bendID;
                prop.z = normalTransform ? 1 : 0;


                material.SetVector(shaderProprtyName_BendSettings, prop);
            }
        }

        static public bool HasShaderCurvedWorldBendSettingsProperty(Shader shader)
        {
            if (shader != null)
            {
                for (int i = 0; i < ShaderUtil.GetPropertyCount(shader); i++)
                {
                    if (ShaderUtil.GetPropertyName(shader, i) == shaderProprtyName_BendSettings)
                        return true;
                }
            }

            return false;
        }

        static public bool HasShaderNormalTransform(Shader shader)
        {
            CurvedWorld.BEND_TYPE[] bendType;
            int[] bendID;
            bool hasNormalTransform;

            if (GetShaderSupportedBendSettings(shader, out bendType, out bendID, out hasNormalTransform))
            {
                return hasNormalTransform;
            }

            return false;
        }

        static public bool IsShaderCurvedWorldTerrain(Shader shader)
        {
            if (shader == null || string.IsNullOrEmpty(shader.name))
                return false;

            return shader.name.Contains("Amazing Assets/Curved World") && shader.name.Contains("Terrain");

        }



        static public string GetGeneratedFilePath(CurvedWorld.BEND_TYPE bendType, int bendID, EXTENSTION extention, bool createFolder)
        {
            string filePath = string.Empty;


            switch (extention)
            {
                case EXTENSTION.cginc:   //Main CGINC
                    filePath = GetCurvedWorldEditorFolderPath();
                    filePath = Path.Combine(filePath, "Shaders");
                    filePath = Path.Combine(filePath, "CGINC");
                    if (createFolder && Directory.Exists(filePath) == false)
                        Directory.CreateDirectory(filePath);

                    filePath = Path.Combine(filePath, GetBendTypeNameInfo(bendType).nameOnly);
                    if (createFolder && Directory.Exists(filePath) == false)
                        Directory.CreateDirectory(filePath);

                    filePath = Path.Combine(filePath, ("CurvedWorld_" + bendType.ToString() + "_ID" + bendID) + ".cginc");
                    break;

                case EXTENSTION.AmplifyShaderEditorNormal:   //Amplify Shder Editor
                case EXTENSTION.AmplifyShaderEditorVertex:
                    filePath = GetCurvedWorldEditorFolderPath();
                    filePath = Path.Combine(filePath, "Shaders");
                    filePath = Path.Combine(filePath, "Amplify Shader Editor");
                    if (createFolder && Directory.Exists(filePath) == false)
                        Directory.CreateDirectory(filePath);

                    filePath = Path.Combine(filePath, GetBendTypeNameInfo(bendType).nameOnly);
                    if (createFolder && Directory.Exists(filePath) == false)
                        Directory.CreateDirectory(filePath);

                    filePath = Path.Combine(filePath, ("CurvedWorld_" + bendType.ToString() + "_ID" + bendID) + (extention == EXTENSTION.AmplifyShaderEditorNormal ? "_Normal" : "_Vertex") + ".asset");
                    break;

                case EXTENSTION.UnityShaderGraphNormal:  //Unity Shader Graph
                case EXTENSTION.UnityShaderGraphVertex:
                    filePath = GetCurvedWorldEditorFolderPath();
                    filePath = Path.Combine(filePath, "Shaders");

                    filePath = Path.Combine(filePath, "Unity Shader Graph");
                    if (createFolder && Directory.Exists(filePath) == false)
                        Directory.CreateDirectory(filePath);

                    filePath = Path.Combine(filePath, GetBendTypeNameInfo(bendType).nameOnly);
                    if (createFolder && Directory.Exists(filePath) == false)
                        Directory.CreateDirectory(filePath);

                    filePath = Path.Combine(filePath, ("CurvedWorld_" + bendType.ToString() + "_ID" + bendID) + (extention == EXTENSTION.UnityShaderGraphNormal ? "_Normal" : "_Vertex") + ".shadersubgraph");
                    break;

                default:
                    break;
            }


            return filePath;
        }

        static public string GetTempleFilePath(CurvedWorld.BEND_TYPE bendType, EXTENSTION extention)
        {
            string filePath = string.Empty;

            switch (extention)
            {
                case EXTENSTION.cginc:
                    filePath = GetCurvedWorldEditorFolderPath();
                    filePath = Path.Combine(filePath, "Shaders");
                    filePath = Path.Combine(filePath, "Templates");
                    filePath = Path.Combine(filePath, "Template_" + GetBendTypeNameInfo(bendType).templateFileName + ".txt");

                    break;

                case EXTENSTION.AmplifyShaderEditorNormal:
                case EXTENSTION.AmplifyShaderEditorVertex:
                    filePath = GetCurvedWorldEditorFolderPath();
                    filePath = Path.Combine(filePath, "Shaders");
                    filePath = Path.Combine(filePath, "Templates");
                    filePath = Path.Combine(filePath, "Template_AmplifyShaderEditor_" + (extention == EXTENSTION.AmplifyShaderEditorNormal ? "Normal" : "Vertex") + ".txt");
                    break;

                case EXTENSTION.UnityShaderGraphNormal:
                case EXTENSTION.UnityShaderGraphVertex:
                    filePath = GetCurvedWorldEditorFolderPath();
                    filePath = Path.Combine(filePath, "Shaders");
                    filePath = Path.Combine(filePath, "Templates");
                    filePath = Path.Combine(filePath, "Template_UnityShaderGraph_" + (extention == EXTENSTION.UnityShaderGraphNormal ? "Normal" : "Vertex") + ".txt");
                    break;

                default:
                    break;
            }


            if (File.Exists(filePath))
                return filePath;
            else
                return string.Empty;
        }


        static public string GetGeneratedTerrainShaderPath(CurvedWorld.BEND_TYPE bendType, int ID, bool createFolder)
        {
            if (ID < 1)
                ID = 1;


            string filePath = string.Empty;


            filePath = GetCurvedWorldEditorFolderPath();
            filePath = Path.Combine(filePath, "Shaders", "Custom");
            if (createFolder && Directory.Exists(filePath) == false)
                Directory.CreateDirectory(filePath);

            filePath = Path.Combine(filePath, "Terrain");
            if (createFolder && Directory.Exists(filePath) == false)
                Directory.CreateDirectory(filePath);

            filePath = Path.Combine(filePath, GetBendTypeNameInfo(bendType).forLable + " ID" + ID);
            if (createFolder && Directory.Exists(filePath) == false)
                Directory.CreateDirectory(filePath);

            if (GetCurrentRenderPipeline() == RENDER_PIPELINE.Builtin)
            {
                filePath = Path.Combine(filePath, "Splats");
                if (createFolder && Directory.Exists(filePath) == false)
                    Directory.CreateDirectory(filePath);

                filePath = Path.Combine(filePath, "FirstPass.shader");
            }
            else
            {
                filePath = Path.Combine(filePath, "TerrainLit.shader");
            }

            return filePath;
        }

        static public string GetGeneratedTerrainShadersFolderPath(CurvedWorld.BEND_TYPE bendType, int ID)
        {
            string filePath = string.Empty;


            filePath = GetCurvedWorldEditorFolderPath();
            filePath = Path.Combine(filePath, "Shaders", "Custom", "Terrain");
            filePath = Path.Combine(filePath, GetBendTypeNameInfo(bendType).forLable + " ID" + ID);

            return filePath;
        }

        static public string GetTempleTerrainFolderPath()
        {
            string filePath = string.Empty;

            filePath = GetCurvedWorldEditorFolderPath();
            filePath = Path.Combine(filePath, "Shaders", "Templates", "Terrain");

            return filePath;
        }


        public static string CreateCGINCFile(CurvedWorld.BEND_TYPE _BendType, int _BendID)
        {
            string templateFileLocation = EditorUtilities.GetTempleFilePath(_BendType, EditorUtilities.EXTENSTION.cginc);
            if (File.Exists(templateFileLocation) == false)
                return string.Empty;


            string[] templateFileAllLines = File.ReadAllLines(templateFileLocation);
            if (templateFileAllLines == null || templateFileAllLines.Length == 0)
                return null;



            if (_BendID < 1)
                _BendID = 1;

            string[] localFile = new string[templateFileAllLines.Length];

            for (int i = 0; i < templateFileAllLines.Length; i++)
            {
                localFile[i] = templateFileAllLines[i].Replace("#BEND_TYPE_SMALL#", _BendType.ToString()).
                                                       Replace("#BEND_TYPE_BIG#", _BendType.ToString().ToUpperInvariant()).
                                                       Replace("#ID#", _BendID.ToString());
            }


            string saveLocalFileName = EditorUtilities.GetGeneratedFilePath(_BendType, _BendID, EditorUtilities.EXTENSTION.cginc, true);

            if (string.IsNullOrEmpty(saveLocalFileName) == false)
            {
                File.WriteAllLines(saveLocalFileName, localFile);


                return saveLocalFileName;
            }
            else
                return null;
        }

        public static void CreateSubGraphFile(CurvedWorld.BEND_TYPE _BendType, int _BendID, string localGUID, EditorUtilities.EXTENSTION extention)
        {
            string templateFileLocation = EditorUtilities.GetTempleFilePath(_BendType, extention);
            if (File.Exists(templateFileLocation) == false)
                return;


            string[] templateFileAllLines = File.ReadAllLines(templateFileLocation);
            if (templateFileAllLines == null || templateFileAllLines.Length == 0)
            {
                Debug.LogWarning("Template file for " + _BendType.ToString() + " not found: ");
                return;
            }


            EditorUtilities.BendTypeNameInfo bandTypeNameInfo = EditorUtilities.GetBendTypeNameInfo(_BendType);

            string[] subGraphFile = new string[templateFileAllLines.Length];

            for (int i = 0; i < templateFileAllLines.Length; i++)
            {
                subGraphFile[i] = templateFileAllLines[i].Replace("#BEND_TYPE_SMALL#", _BendType.ToString()).
                                                          Replace("#BEND_TYPE_BIG#", _BendType.ToString().ToUpperInvariant()).
                                                          Replace("#ID#", _BendID.ToString()).
                                                          Replace("#BEND_NAME#", bandTypeNameInfo.nameOnly).
                                                          Replace("#BEND_AXIS#", string.IsNullOrEmpty(bandTypeNameInfo.axisOnly) ? string.Empty : "/" + bandTypeNameInfo.axisOnly).
                                                          Replace("#CGINC_FILE_GUID#", localGUID);
            }




            string saveLocalFileName = EditorUtilities.GetGeneratedFilePath(_BendType, _BendID, extention, true);
            if (string.IsNullOrEmpty(saveLocalFileName) == false)
            {
                File.WriteAllLines(saveLocalFileName, subGraphFile);
            }
        }



        static public BendTypeNameInfo GetBendTypeNameInfo(CurvedWorld.BEND_TYPE _bendType)
        {
            BendTypeNameInfo nameInfo;

            nameInfo.nameOnly = string.Empty;
            nameInfo.nameOnlyWithoutSpace = string.Empty;
            nameInfo.axisOnly = string.Empty;
            nameInfo.forLable = string.Empty;
            nameInfo.forMenu = string.Empty;
            nameInfo.templateFileName = string.Empty;


            switch (_bendType)
            {
                case CurvedWorld.BEND_TYPE.ClassicRunner_X_Positive:
                    nameInfo.nameOnly = "Classic Runner";
                    nameInfo.nameOnlyWithoutSpace = "ClassicRunner";
                    nameInfo.axisOnly = "X Positive";
                    nameInfo.forLable = "Classic Runner (X Positive)";
                    nameInfo.forMenu = "Classic Runner/X Positive";
                    nameInfo.templateFileName = "ClassicRunner";
                    break;
                case CurvedWorld.BEND_TYPE.ClassicRunner_X_Negative:
                    nameInfo.nameOnly = "Classic Runner";
                    nameInfo.nameOnlyWithoutSpace = "ClassicRunner";
                    nameInfo.axisOnly = "X Negative";
                    nameInfo.forLable = "Classic Runner (X Negative)";
                    nameInfo.forMenu = "Classic Runner/X Negative";
                    nameInfo.templateFileName = "ClassicRunner";
                    break;
                case CurvedWorld.BEND_TYPE.ClassicRunner_Z_Positive:
                    nameInfo.nameOnly = "Classic Runner";
                    nameInfo.nameOnlyWithoutSpace = "ClassicRunner";
                    nameInfo.axisOnly = "Z Positive";
                    nameInfo.forLable = "Classic Runner (Z Positive)";
                    nameInfo.forMenu = "Classic Runner/Z Positive";
                    nameInfo.templateFileName = "ClassicRunner";
                    break;
                case CurvedWorld.BEND_TYPE.ClassicRunner_Z_Negative:
                    nameInfo.nameOnly = "Classic Runner";
                    nameInfo.nameOnlyWithoutSpace = "ClassicRunner";
                    nameInfo.axisOnly = "Z Negative";
                    nameInfo.forLable = "Classic Runner (Z Negative)";
                    nameInfo.forMenu = "Classic Runner/Z Negative";
                    nameInfo.templateFileName = "ClassicRunner";
                    break;

                case CurvedWorld.BEND_TYPE.LittlePlanet_X:
                    nameInfo.nameOnly = "Little Planet";
                    nameInfo.nameOnlyWithoutSpace = "LittlePlanet";
                    nameInfo.axisOnly = "X";
                    nameInfo.forLable = "Little Planet (X)";
                    nameInfo.forMenu = "Little Planet/X";
                    nameInfo.templateFileName = "LittlePlanet";
                    break;
                case CurvedWorld.BEND_TYPE.LittlePlanet_Y:
                    nameInfo.nameOnly = "Little Planet";
                    nameInfo.nameOnlyWithoutSpace = "LittlePlanet";
                    nameInfo.axisOnly = "Y";
                    nameInfo.forLable = "Little Planet (Y)";
                    nameInfo.forMenu = "Little Planet/Y";
                    nameInfo.templateFileName = "LittlePlanet";
                    break;
                case CurvedWorld.BEND_TYPE.LittlePlanet_Z:
                    nameInfo.nameOnly = "Little Planet";
                    nameInfo.nameOnlyWithoutSpace = "LittlePlanet";
                    nameInfo.axisOnly = "Z";
                    nameInfo.forLable = "Little Planet (Z)";
                    nameInfo.forMenu = "Little Planet/Z";
                    nameInfo.templateFileName = "LittlePlanet";
                    break;


                case CurvedWorld.BEND_TYPE.CylindricalRolloff_X:
                    nameInfo.nameOnly = "Cylindrical Rolloff";
                    nameInfo.nameOnlyWithoutSpace = "CylindricalRolloff";
                    nameInfo.axisOnly = "X";
                    nameInfo.forLable = "Cylindrical Rolloff (X)";
                    nameInfo.forMenu = "Cylindrical Rolloff/X";
                    nameInfo.templateFileName = "CylindricalRolloff";
                    break;
                case CurvedWorld.BEND_TYPE.CylindricalRolloff_Z:
                    nameInfo.nameOnly = "Cylindrical Rolloff";
                    nameInfo.nameOnlyWithoutSpace = "CylindricalRolloff";
                    nameInfo.axisOnly = "Z";
                    nameInfo.forLable = "Cylindrical Rolloff (Z)";
                    nameInfo.forMenu = "Cylindrical Rolloff/Z";
                    nameInfo.templateFileName = "CylindricalRolloff";
                    break;


                case CurvedWorld.BEND_TYPE.CylindricalTower_X:
                    nameInfo.nameOnly = "Cylindrical Tower";
                    nameInfo.nameOnlyWithoutSpace = "CylindricalTower";
                    nameInfo.axisOnly = "X";
                    nameInfo.forLable = "Cylindrical Tower (X)";
                    nameInfo.forMenu = "Cylindrical Tower/X";
                    nameInfo.templateFileName = "CylindricalTower";
                    break;
                case CurvedWorld.BEND_TYPE.CylindricalTower_Z:
                    nameInfo.nameOnly = "Cylindrical Tower";
                    nameInfo.nameOnlyWithoutSpace = "CylindricalTower";
                    nameInfo.axisOnly = "Z";
                    nameInfo.forLable = "Cylindrical Tower (Z)";
                    nameInfo.forMenu = "Cylindrical Tower/Z";
                    nameInfo.templateFileName = "CylindricalTower";
                    break;


                case CurvedWorld.BEND_TYPE.SpiralHorizontal_X_Positive:
                    nameInfo.nameOnly = "Spiral Horizontal";
                    nameInfo.nameOnlyWithoutSpace = "SpiralHorizontal";
                    nameInfo.axisOnly = "X Positive";
                    nameInfo.forLable = "Spiral Horizontal (X Positive)";
                    nameInfo.forMenu = "Spiral Horizontal/X Positive";
                    nameInfo.templateFileName = "Spiral";
                    break;
                case CurvedWorld.BEND_TYPE.SpiralHorizontal_X_Negative:
                    nameInfo.nameOnly = "Spiral Horizontal";
                    nameInfo.nameOnlyWithoutSpace = "SpiralHorizontal";
                    nameInfo.axisOnly = "X Negative";
                    nameInfo.forLable = "Spiral Horizontal (X Negative)";
                    nameInfo.forMenu = "Spiral Horizontal/X Negative";
                    nameInfo.templateFileName = "Spiral";
                    break;
                case CurvedWorld.BEND_TYPE.SpiralHorizontal_Z_Positive:
                    nameInfo.nameOnly = "Spiral Horizontal";
                    nameInfo.nameOnlyWithoutSpace = "SpiralHorizontal";
                    nameInfo.axisOnly = "Z Positive";
                    nameInfo.forLable = "Spiral Horizontal (Z Positive)";
                    nameInfo.forMenu = "Spiral Horizontal/Z Positive";
                    nameInfo.templateFileName = "Spiral";
                    break;
                case CurvedWorld.BEND_TYPE.SpiralHorizontal_Z_Negative:
                    nameInfo.nameOnly = "Spiral Horizontal";
                    nameInfo.nameOnlyWithoutSpace = "SpiralHorizontal";
                    nameInfo.axisOnly = "Z Negative";
                    nameInfo.forLable = "Spiral Horizontal (Z Negative)";
                    nameInfo.forMenu = "Spiral Horizontal/Z Negative";
                    nameInfo.templateFileName = "Spiral";
                    break;


                case CurvedWorld.BEND_TYPE.SpiralHorizontalRolloff_X:
                    nameInfo.nameOnly = "Spiral Horizontal Rolloff";
                    nameInfo.nameOnlyWithoutSpace = "SpiralHorizontalRolloff";
                    nameInfo.axisOnly = "X";
                    nameInfo.forLable = "Spiral Horizontal Rolloff (X)";
                    nameInfo.forMenu = "Spiral Horizontal Rolloff/X";
                    nameInfo.templateFileName = "SpiralRolloff";
                    break;
                case CurvedWorld.BEND_TYPE.SpiralHorizontalRolloff_Z:
                    nameInfo.nameOnly = "Spiral Horizontal Rolloff";
                    nameInfo.nameOnlyWithoutSpace = "SpiralHorizontalRolloff";
                    nameInfo.axisOnly = "Z";
                    nameInfo.forLable = "Spiral Horizontal Rolloff (Z)";
                    nameInfo.forMenu = "Spiral Horizontal Rolloff/Z";
                    nameInfo.templateFileName = "SpiralRolloff";
                    break;


                case CurvedWorld.BEND_TYPE.SpiralHorizontalDouble_X:
                    nameInfo.nameOnly = "Spiral Horizontal Double";
                    nameInfo.nameOnlyWithoutSpace = "SpiralHorizontalDouble";
                    nameInfo.axisOnly = "X";
                    nameInfo.forLable = "Spiral Horizontal Double (X)";
                    nameInfo.forMenu = "Spiral Horizontal Double/X";
                    nameInfo.templateFileName = "SpiralDouble";
                    break;
                case CurvedWorld.BEND_TYPE.SpiralHorizontalDouble_Z:
                    nameInfo.nameOnly = "Spiral Horizontal Double";
                    nameInfo.nameOnlyWithoutSpace = "SpiralHorizontalDouble";
                    nameInfo.axisOnly = "Z";
                    nameInfo.forLable = "Spiral Horizontal Double (Z)";
                    nameInfo.forMenu = "Spiral Horizontal Double/Z";
                    nameInfo.templateFileName = "SpiralDouble";
                    break;


                case CurvedWorld.BEND_TYPE.SpiralVertical_X_Positive:
                    nameInfo.nameOnly = "Spiral Vertical";
                    nameInfo.nameOnlyWithoutSpace = "SpiralVertical";
                    nameInfo.axisOnly = "X Positive";
                    nameInfo.forLable = "Spiral Vertical (X Positive)";
                    nameInfo.forMenu = "Spiral Vertical/X Positive";
                    nameInfo.templateFileName = "Spiral";
                    break;
                case CurvedWorld.BEND_TYPE.SpiralVertical_X_Negative:
                    nameInfo.nameOnly = "Spiral Vertical";
                    nameInfo.nameOnlyWithoutSpace = "SpiralVertical";
                    nameInfo.axisOnly = "X Negative";
                    nameInfo.forLable = "Spiral Vertical (X Negative)";
                    nameInfo.forMenu = "Spiral Vertical/X Negative";
                    nameInfo.templateFileName = "Spiral";
                    break;
                case CurvedWorld.BEND_TYPE.SpiralVertical_Z_Positive:
                    nameInfo.nameOnly = "Spiral Vertical";
                    nameInfo.nameOnlyWithoutSpace = "SpiralVertical";
                    nameInfo.axisOnly = "Z Positive";
                    nameInfo.forLable = "Spiral Vertical (Z Positive)";
                    nameInfo.forMenu = "Spiral Vertical/Z Positive";
                    nameInfo.templateFileName = "Spiral";
                    break;
                case CurvedWorld.BEND_TYPE.SpiralVertical_Z_Negative:
                    nameInfo.nameOnly = "Spiral Vertical";
                    nameInfo.nameOnlyWithoutSpace = "SpiralVertical";
                    nameInfo.axisOnly = "Z Negative";
                    nameInfo.forLable = "Spiral Vertical (Z Negative)";
                    nameInfo.forMenu = "Spiral Vertical/Z Negative";
                    nameInfo.templateFileName = "Spiral";
                    break;


                case CurvedWorld.BEND_TYPE.SpiralVerticalRolloff_X:
                    nameInfo.nameOnly = "Spiral Vertical Rolloff";
                    nameInfo.nameOnlyWithoutSpace = "SpiralVerticalRolloff";
                    nameInfo.axisOnly = "X";
                    nameInfo.forLable = "Spiral Vertical Rolloff (X)";
                    nameInfo.forMenu = "Spiral Vertical Rolloff/X";
                    nameInfo.templateFileName = "SpiralRolloff";
                    break;
                case CurvedWorld.BEND_TYPE.SpiralVerticalRolloff_Z:
                    nameInfo.nameOnly = "Spiral Vertical Rolloff";
                    nameInfo.nameOnlyWithoutSpace = "SpiralVerticalRolloff";
                    nameInfo.axisOnly = "Z";
                    nameInfo.forLable = "Spiral Vertical Rolloff (Z)";
                    nameInfo.forMenu = "Spiral Vertical Rolloff/Z";
                    nameInfo.templateFileName = "SpiralRolloff";
                    break;


                case CurvedWorld.BEND_TYPE.SpiralVerticalDouble_X:
                    nameInfo.nameOnly = "Spiral Vertical Double";
                    nameInfo.nameOnlyWithoutSpace = "SpiralVerticalDouble";
                    nameInfo.axisOnly = "X";
                    nameInfo.forLable = "Spiral Vertical Double (X)";
                    nameInfo.forMenu = "Spiral Vertical Double/X";
                    nameInfo.templateFileName = "SpiralDouble";
                    break;
                case CurvedWorld.BEND_TYPE.SpiralVerticalDouble_Z:
                    nameInfo.nameOnly = "Spiral Vertical Double";
                    nameInfo.nameOnlyWithoutSpace = "SpiralVerticalDouble";
                    nameInfo.axisOnly = "Z";
                    nameInfo.forLable = "Spiral Vertical Double (Z)";
                    nameInfo.forMenu = "Spiral Vertical Double/Z";
                    nameInfo.templateFileName = "SpiralDouble";
                    break;


                case CurvedWorld.BEND_TYPE.TwistedSpiral_X_Positive:
                    nameInfo.nameOnly = "Twisted Spiral";
                    nameInfo.nameOnlyWithoutSpace = "TwistedSpiral";
                    nameInfo.axisOnly = "X Positive";
                    nameInfo.forLable = "Twisted Spiral (X Positive)";
                    nameInfo.forMenu = "Twisted Spiral/X Positive";
                    nameInfo.templateFileName = "TwistedSpiral";
                    break;
                case CurvedWorld.BEND_TYPE.TwistedSpiral_X_Negative:
                    nameInfo.nameOnly = "Twisted Spiral";
                    nameInfo.nameOnlyWithoutSpace = "TwistedSpiral";
                    nameInfo.axisOnly = "X Negative";
                    nameInfo.forLable = "Twisted Spiral (X Negative)";
                    nameInfo.forMenu = "Twisted Spiral/X Negative";
                    nameInfo.templateFileName = "TwistedSpiral";
                    break;
                case CurvedWorld.BEND_TYPE.TwistedSpiral_Z_Positive:
                    nameInfo.nameOnly = "Twisted Spiral";
                    nameInfo.nameOnlyWithoutSpace = "TwistedSpiral";
                    nameInfo.axisOnly = "Z Positive";
                    nameInfo.forLable = "Twisted Spiral (Z Positive)";
                    nameInfo.forMenu = "Twisted Spiral/Z Positive";
                    nameInfo.templateFileName = "TwistedSpiral";
                    break;
                case CurvedWorld.BEND_TYPE.TwistedSpiral_Z_Negative:
                    nameInfo.nameOnly = "Twisted Spiral";
                    nameInfo.nameOnlyWithoutSpace = "TwistedSpiral";
                    nameInfo.axisOnly = "Z Negative";
                    nameInfo.forLable = "Twisted Spiral (Z Negative)";
                    nameInfo.forMenu = "Twisted Spiral/Z Negative";
                    nameInfo.templateFileName = "TwistedSpiral";
                    break;


            }

            return nameInfo;
        }

        static public GenericMenu BuildBendTypesMenu(CurvedWorld.BEND_TYPE _BendType, UnityEditor.GenericMenu.MenuFunction2 callback)
        {
            GenericMenu menu = new GenericMenu();

            foreach (CurvedWorld.BEND_TYPE bendType in Enum.GetValues(typeof(CurvedWorld.BEND_TYPE)))
            {
                menu.AddItem(new GUIContent(EditorUtilities.GetBendTypeNameInfo(bendType).forMenu), _BendType == bendType, callback, bendType);
            }

            return menu;
        }


        static public bool IsMaterialBuiltInResource(Material material)
        {
            if (material == null)
                return true;

            return IsMaterialBuiltInResource(AssetDatabase.GetAssetPath(material.GetInstanceID()));
        }

        static public bool IsMaterialBuiltInResource(string materialPath)
        {
            if (string.IsNullOrEmpty(materialPath) == false && materialPath.Contains("Assets") && materialPath.Contains(".mat"))
                return false;


            return true;
        }

        static public bool IsShaderBuiltInResource(Shader shader)
        {
            if (shader == null)
                return true;


            return IsShaderBuiltInResource(AssetDatabase.GetAssetPath(shader.GetInstanceID()));
        }

        static public bool IsShaderBuiltInResource(string shaderPath)
        {
            if (string.IsNullOrEmpty(shaderPath) == false && shaderPath.Contains("Assets") && shaderPath.Contains(".shader"))
                return false;


            return true;
        }


        static public bool StringIsCommented(string line)
        {
            //We need only uncomented line

            if (string.IsNullOrEmpty(line) || line.Length == 0)
                return true;

            line = line.TrimStart();

            return (line.IndexOf("//") == 0 ? true : false);
        }


        static public string GetKeywordName(CurvedWorld.BEND_TYPE bendType)
        {
            return shaderKeywordPrefix_BendType + bendType.ToString().ToUpperInvariant();
        }

        static public string GetKeywordName(int bendID)
        {
            return shaderKeywordPrefix_BendID + bendID;
        }

        static public RENDER_PIPELINE GetCurrentRenderPipeline()
        {
            if (UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset == null)
                return RENDER_PIPELINE.Builtin;
            else
            {
                if (UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset.name.Contains("Universal") ||
                    UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset.name.Contains("URP"))
                    return RENDER_PIPELINE.Universal;
                else
                    return RENDER_PIPELINE.HighDefinition;
            }
        }

        static public bool CanGenerateUnityShaderGrap()
        {
            return GetCurrentRenderPipeline() == RENDER_PIPELINE.Builtin ? false : true;
        }

        static public bool CanGenerateAmplifyShaderFuntion()
        {
            if (amplifyShaderEditorWindowPath == null)
            {
                amplifyShaderEditorWindowPath = string.Empty;

                string[] assets = AssetDatabase.FindAssets("AmplifyShaderEditorWindow", null);
                if (assets != null && assets.Length > 0)
                {
                    for (int i = 0; i < assets.Length; i++)
                    {
                        if (string.IsNullOrEmpty(assets[i]) == false)
                        {
                            string filePath = AssetDatabase.GUIDToAssetPath(assets[i]);

                            if (filePath.Contains("AmplifyShaderEditor"))
                            {
                                amplifyShaderEditorWindowPath = filePath;
                                break;
                            }
                        }
                    }
                }
            }

            return string.IsNullOrEmpty(amplifyShaderEditorWindowPath) ? false : true;
        }


        static public ACTIVATE_STATE ActivateShader(Shader shader, bool activate, bool reimport)
        {
            if (shader == null)
                return ACTIVATE_STATE.Skip;

            if (IsShaderBuiltInResource(shader))
                return ACTIVATE_STATE.Skip;


            string path = AssetDatabase.GetAssetPath(shader.GetInstanceID());

            if (File.Exists(path) == false)
                return ACTIVATE_STATE.Skip;


            string[] allLines = File.ReadAllLines(path);
            if (allLines == null || allLines.Length == 0)
                return ACTIVATE_STATE.Skip;


            bool hasProperty = false;
            bool hasBendType = false;
            bool hasBendID = false;
            bool hasPathtoCGINC = false;


            for (int i = 0; i < allLines.Length; i++)
            {
                //Material Property
                if (allLines[i].Contains("CurvedWorldBendSettings") && allLines[i].Contains(shaderProprtyName_BendSettings))
                {
                    allLines[i] = (activate ? string.Empty : "//") + (allLines[i].Contains("HideInInspector") ? "[HideInInspector]" : string.Empty) + "[CurvedWorldBendSettings] _CurvedWorldBendSettings(\"0|1|1\", Vector) = (0, 0, 0, 0)";

                    hasProperty = true;
                }

                //Bend Type keywords
                if (allLines[i].Contains(shaderKeywordPrefix_BendType))
                {
                    allLines[i] = (activate ? string.Empty : "//") + "#define CURVEDWORLD_BEND_TYPE_CLASSICRUNNER_X_POSITIVE";

                    hasBendType = true;
                }

                //Bend ID keywords
                if (allLines[i].Contains(shaderKeywordPrefix_BendID))
                {
                    allLines[i] = (activate ? string.Empty : "//") + "#define CURVEDWORLD_BEND_ID_1";

                    hasBendID = true;
                }

                //Disable keyword
                if (allLines[i].Contains(shaderKeywordName_CurvedWorldDisabled) && allLines[i].Contains("#pragma"))
                {
                    allLines[i] = (activate ? string.Empty : "//") + "#pragma shader_feature_local " + shaderKeywordName_CurvedWorldDisabled;

                    hasBendID = true;
                }

                //Normal Transforamtion
                if (allLines[i].Contains(shaderKeywordName_BendTransformNormal) && allLines[i].Contains("#pragma"))
                {
                    allLines[i] = (activate ? string.Empty : "//") + "#pragma shader_feature_local " + shaderKeywordName_BendTransformNormal;

                    //has normal - not nessesary
                }

                //Path to the cginc
                if (allLines[i].Contains("Core/CurvedWorldTransform.cginc"))
                {
                    allLines[i] = (activate ? string.Empty : "//") + GetCoreTransformFilePathForShader();

                    hasPathtoCGINC = true;
                }
            }

            //Nothing changed
            if (hasProperty == false && hasBendType == false && hasBendID == false && hasPathtoCGINC == false)
                return ACTIVATE_STATE.Skip;

            //Problem detected
            if (hasProperty == false || hasBendType == false || hasBendID == false || hasPathtoCGINC == false)
            {
                string warningMessage = string.Format("Curved World {0} problem for shader '{1}'\nhasProperty: {2}\nhasBendType: {3}\nhasBendID: {4}\nhasPathtoCGINC: {5}\n", (activate ? "activation" : "deactivation"), shader.name, hasProperty, hasBendType, hasBendID, hasPathtoCGINC);
                Debug.LogWarning(warningMessage, shader);

                return ACTIVATE_STATE.Problem;
            }


            File.WriteAllLines(path, allLines);


            if (reimport)
                AssetDatabase.ImportAsset(path);


            return ACTIVATE_STATE.Done;
        }


        static public void CallbackFindController(object obj)
        {
            if (obj == null)
                return;

            //Format - (int)bendType + "_" + bendID

            string objString = obj.ToString();
            if (string.IsNullOrEmpty(objString))
                return;

            string[] info = objString.Split('_');
            if (info.Length != 2)
                return;


            CurvedWorld.BEND_TYPE bendType = (CurvedWorld.BEND_TYPE)0;
            int bendID = 0;

            int result;

            if (int.TryParse(info[0], out result))
            {
                if (result >= 0 && result < EditorUtilities.MAX_SUPPORTED_BEND_TYPES)
                    bendType = (CurvedWorld.BEND_TYPE)result;
                else
                    return;
            }

            if (int.TryParse(info[1], out result))
            {
                if (result > 0 && result <= EditorUtilities.MAX_SUPPORTED_BEND_IDS)
                    bendID = result;
                else
                    return;
            }

            CurvedWorld.CurvedWorldController[] sceneControllers = Resources.FindObjectsOfTypeAll<CurvedWorld.CurvedWorldController>();
            if (sceneControllers != null && sceneControllers.Length > 0)
            {
                for (int i = 0; i < sceneControllers.Length; i++)
                {
                    if (sceneControllers[i] != null &&
                       sceneControllers[i].bendType == bendType &&
                       sceneControllers[i].bendID == bendID)
                    {
                        Selection.activeGameObject = sceneControllers[i].gameObject;
                        return;
                    }
                }
            }

            Debug.LogWarning("Can not find 'CurvedWorld.Controller' script with BendType: " + EditorUtilities.GetBendTypeNameInfo(bendType).forLable + " and BendID: " + bendID + ".\n");
        }

        static public void CallbackAnalyzeShaderCurvedWorldKeywords(object obj)
        {
            if (obj == null)
                return;

            Shader shader = (Shader)obj;
            if (shader == null)
                return;


            if (CurvedWorldEditorWindow.activeWindow == null)
                CurvedWorldEditorWindow.ShowWindow();

            if (CurvedWorldEditorWindow.activeWindow != null)
            {
                CurvedWorldEditorWindow.activeWindow.gTab = CurvedWorldEditorWindow.TAB.CurvedWorldKeywords;
                CurvedWorldEditorWindow.activeWindow.gCurvedWorldKeywordsShader = shader;
                CurvedWorldEditorWindow.gCurvedWorldKeywordsShaderInfo = null;

                CurvedWorldEditorWindow.activeWindow.Repaint();
            }
        }

        static public void CallbackReimportShader(object obj)
        {
            if (obj == null)
                return;

            Shader shader = (Shader)obj;
            if (shader == null)
                return;


            string shaderPath = AssetDatabase.GetAssetPath(shader.GetInstanceID());
            if (EditorUtilities.IsShaderBuiltInResource(shaderPath) == false)
            {
                AssetDatabase.ImportAsset(shaderPath);
            }
        }

        static public void CallbackOpenCurvedWorldSettingsWindow(object obj)
        {
            if (CurvedWorldEditorWindow.activeWindow == false)
                CurvedWorldEditorWindow.ShowWindow();


            //Select bendType and ID
            //Format - (int)bendType + "_" + bendID

            string objString = obj.ToString();
            if (string.IsNullOrEmpty(objString))
                return;

            string[] info = objString.Split('_');
            if (info.Length != 2)
                return;


            CurvedWorld.BEND_TYPE bendType = (CurvedWorld.BEND_TYPE)0;
            int bendID = 0;

            int result;

            if (int.TryParse(info[0], out result))
            {
                if (result >= 0 && result < EditorUtilities.MAX_SUPPORTED_BEND_TYPES)
                    bendType = (CurvedWorld.BEND_TYPE)result;
                else
                    return;
            }

            if (int.TryParse(info[1], out result))
            {
                if (result > 0 && result <= EditorUtilities.MAX_SUPPORTED_BEND_IDS)
                    bendID = result;
                else
                    return;
            }


            CurvedWorldEditorWindow.activeWindow.gTab = CurvedWorldEditorWindow.TAB.Manage;
            CurvedWorldEditorWindow.activeWindow.gBendType = bendType;
            CurvedWorldEditorWindow.activeWindow.gBendID = bendID;
        }

        static public void CallbackOpenCurvedWorldSettingsWindowControllers()
        {
            if (CurvedWorldEditorWindow.activeWindow == false)
                CurvedWorldEditorWindow.ShowWindow();


            CurvedWorldEditorWindow.activeWindow.gTab = CurvedWorldEditorWindow.TAB.Controllers;
        }


        static internal Texture2D LoadTexture(string resourceName, TextureWrapMode wrapMode, bool linear)
        {
            Texture2D texture = (Texture2D)UnityEditor.AssetDatabase.LoadAssetAtPath(Path.Combine(GetCurvedWorldEditorFolderPath(), "Editor", "Icons", resourceName + ".png"), typeof(Texture2D));

            if (texture != null)
                texture.wrapMode = wrapMode;

            return texture;
        }


        static public string RemoveInvalidCharacters(string name)
        {
            if (string.IsNullOrEmpty(name))
                return string.Empty;
            else
            {
                if (name.IndexOfAny(invalidFileNameCharachters) == -1)
                    return name;
                else
                    return string.Concat(name.Split(invalidFileNameCharachters, StringSplitOptions.RemoveEmptyEntries));
            }
        }

        static public bool ContainsInvalidFileNameCharacters(string name)
        {
            if (string.IsNullOrEmpty(name))
                return false;
            else
                return name.IndexOfAny(invalidFileNameCharachters) >= 0;
        }



        public struct BendFiles
        {
            public string pathToCGINC;

            public string pathToUnityShaderGraphNormal;
            public string pathToUnityShaderGraphVertex;

            public string pathToAmplifyShaderEditorNormal;
            public string pathToAmplifyShaderEditorVertex;
        }

        public struct BendTypeNameInfo
        {
            public string nameOnly;
            public string nameOnlyWithoutSpace;
            public string forLable;
            public string forMenu;
            public string axisOnly;
            public string templateFileName;
        }

        public class MaterialInfo
        {
            public Material material;
            public bool isBuiltInresource;
            public bool existsInScene;

            public MaterialInfo(Material mat)
            {
                material = mat;

                isBuiltInresource = EditorUtilities.IsMaterialBuiltInResource(mat);

                existsInScene = true;
            }
        }

        public class ShaderOverview
        {
            public Shader shader;
            public bool isShaderUnityBuiltInResource;

            public List<MaterialInfo> materialsInfo;
            public string[] keywordsArray;
            public string keywordsString;
            public string keywordsTooltip;

            HashSet<string> keywordsHashSet;

            public int hashCode;

            public bool foldout;

            public ShaderOverview(Material material)
            {
                shader = material.shader;

                isShaderUnityBuiltInResource = IsShaderBuiltInResource(shader);


                AddMaterial(material);

                KeywordsHasChanged(material.shaderKeywords);
            }

            public void AddMaterial(Material mat)
            {
                if (materialsInfo == null)
                    materialsInfo = new List<MaterialInfo>();


                if (mat != null && materialsInfo.Any(m => m.material == mat) == false)
                {
                    materialsInfo.Add(new MaterialInfo(mat));
                }
            }

            public void SetNewKeywords(string keywords)
            {
                if (keywords == null)
                    return;


                string[] newKeywords = keywords.Replace(',', ' ').Replace('.', ' ').Replace(System.Environment.NewLine, " ").Replace("\n", " ").Split(' ').Where(k => string.IsNullOrEmpty(k.Trim()) == false).ToArray();

                for (int i = 0; i < materialsInfo.Count; i++)
                {
                    if (materialsInfo[i] != null && materialsInfo[i].material != null && materialsInfo[i].isBuiltInresource == false)
                    {
                        Undo.RecordObject(materialsInfo[i].material, "Change keywords");
                        materialsInfo[i].material.shaderKeywords = newKeywords;
                    }
                }


                KeywordsHasChanged(newKeywords);

                AssetDatabase.SaveAssets();
            }

            void KeywordsHasChanged(string[] keywords)
            {
                keywordsArray = keywords;
                if (string.IsNullOrEmpty(string.Concat(keywordsArray)))
                {
                    keywordsString = "Keywords:   None";
                    keywordsTooltip = string.Empty;
                }
                else
                {
                    keywordsString = "Keywords (" + keywordsArray.Length + "):   " + string.Join(",   ", keywordsArray.OrderBy(s => s));

                    keywordsTooltip = string.Join("\n", keywordsArray.OrderBy(s => s));
                }


                keywordsHashSet = new HashSet<string>(keywordsArray);

                hashCode = (shader.name + keywordsTooltip).GetHashCode();
            }

            public bool AllMaterialsAreBuiltInResources()
            {
                bool value = true;

                if (materialsInfo != null)
                {
                    for (int i = 0; i < materialsInfo.Count; i++)
                    {
                        if (materialsInfo[i] != null && materialsInfo[i].material != null && materialsInfo[i].isBuiltInresource == false)
                        {
                            value = false;
                            break;
                        }
                    }
                }

                return value;
            }

            public bool ContainSameKeywords(string[] array)
            {
                HashSet<string> hSet = new HashSet<string>(array);
                bool value = keywordsHashSet.SetEquals(hSet);

                return value;
            }
        }

        public class ShaderCurvedWorldKeywordsInfo
        {
            public CurvedWorld.BEND_TYPE[] supportedBendTypes;
            public bool[] selectedBendTypes;

            public int[] supportedBendIDs;
            public bool[] selectedBendIDs;

            public bool supportedMultiCompile;
            public bool selecedMultiCompile;


            public ShaderCurvedWorldKeywordsInfo(Shader shader)
            {
                supportedBendTypes = null;
                selectedBendTypes = null;
                bool hasNormalTransform;


                if (shader == false || EditorUtilities.HasShaderCurvedWorldBendSettingsProperty(shader) == false)
                    return;


                EditorUtilities.GetShaderSupportedBendSettings(shader, out supportedBendTypes, out supportedBendIDs, out hasNormalTransform);

                if (supportedBendTypes != null && supportedBendIDs != null)
                {
                    selectedBendTypes = new bool[MAX_SUPPORTED_BEND_TYPES];
                    for (int i = 0; i < MAX_SUPPORTED_BEND_TYPES; i++)
                    {
                        selectedBendTypes[i] = supportedBendTypes.Contains((CurvedWorld.BEND_TYPE)i);
                    }

                    selectedBendIDs = new bool[EditorUtilities.MAX_SUPPORTED_BEND_IDS];
                    for (int i = 0; i < EditorUtilities.MAX_SUPPORTED_BEND_IDS; i++)
                    {
                        selectedBendIDs[i] = supportedBendIDs.Contains(i + 1);
                    }


                    //Check multi_compile
                    string shaderFilePath = AssetDatabase.GetAssetPath(shader.GetInstanceID());

                    string[] allLines = File.ReadAllLines(shaderFilePath);
                    for (int i = 0; i < allLines.Length; i++)
                    {
                        if (allLines[i].Contains("#"))
                        {
                            if (allLines[i].Contains(shaderKeywordPrefix_BendType))
                            {
                                supportedMultiCompile = allLines[i].Contains("multi_compile_local");

                                selecedMultiCompile = supportedMultiCompile;

                                break;
                            }
                        }
                    }
                }
            }


            public bool IsCurvedWorldShader()
            {
                if (supportedBendTypes != null &&
                    supportedBendIDs != null)
                    return true;
                else
                    return false;
            }

            public CurvedWorld.BEND_TYPE[] GetSelectedBendTypes()
            {
                List<CurvedWorld.BEND_TYPE> bendTypes = new List<CurvedWorld.BEND_TYPE>();
                for (int i = 0; i < EditorUtilities.MAX_SUPPORTED_BEND_TYPES; i++)
                {
                    if (selectedBendTypes[i])
                        bendTypes.Add((CurvedWorld.BEND_TYPE)i);
                }

                return bendTypes.ToArray();
            }

            public int[] GetSelectedBendIDs()
            {
                List<int> bendIDs = new List<int>();
                for (int i = 0; i < EditorUtilities.MAX_SUPPORTED_BEND_IDS; i++)
                {
                    if (selectedBendIDs[i])
                        bendIDs.Add(i + 1);     //ID indexes start from 1, not 0
                }

                return bendIDs.ToArray();
            }
        }

        public static bool Contains(this string source, string toCheck, bool ingnoreCase)
        {
            return source?.IndexOf(toCheck, ingnoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal) >= 0;
        }
    }
}