﻿#if UNITY_EDITOR
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;

namespace Onward.CustomContent.EditorTools
{
    public class MaterialSceneScan : EditorWindow
    {
        static string[] URPConversionCompatibleShaders = new string[]
        {
            "Standard".ToLower(),
            "Standard (Specular Setup)".ToLower(),
            "Standard Terrain".ToLower(),
            "Particles/Standard Surface".ToLower(),
            "Particles/Standard Unlit".ToLower(),
            "Mobile/Diffuse".ToLower(),
            "Mobile/Bumped Specular".ToLower(),
            "Mobile/Bumped Specular(1 Directional Light)".ToLower(),
            "Mobile/Unlit (Supports Lightmap)".ToLower(),
            "Mobile/VertexLit".ToLower(),
            "Legacy Shaders/Diffuse".ToLower(),
            "Legacy Shaders/Specular".ToLower(),
            "Legacy Shaders/Bumped Diffuse".ToLower(),
            "Legacy Shaders/Bumped Specular".ToLower(),
            "Legacy Shaders/Self-Illumin/Diffuse".ToLower(),
            "Legacy Shaders/Self-Illumin/Bumped Diffuse".ToLower(),
            "Legacy Shaders/Self-Illumin/Specular".ToLower(),
            "Legacy Shaders/Self-Illumin/Bumped Specular".ToLower(),
            "Legacy Shaders/Transparent/Diffuse".ToLower(),
            "Legacy Shaders/Transparent/Specular".ToLower(),
            "Legacy Shaders/Transparent/Bumped Diffuse".ToLower(),
            "Legacy Shaders/Transparent/Bumped Specular".ToLower(),
            "Legacy Shaders/Transparent/Cutout/Diffuse".ToLower(),
            "Legacy Shaders/Transparent/Cutout/Specular".ToLower(),
            "Legacy Shaders/Transparent/Cutout/Bumped Diffuse".ToLower(),
            "Legacy Shaders/Transparent/Cutout/Bumped Specular".ToLower(),
        };

        class IncompatibleMaterialInstance
        {
            public enum EMaterialType
            {
                Unknown,
                Builtin
            }

            public Renderer renderer;
            public Material material;
            public EMaterialType materialType;
        }

        Vector2 m_scrollPositionList;
        Vector2 m_scrollPositionFoldout;

        List<IncompatibleMaterialInstance> m_detectedMaterials = new List<IncompatibleMaterialInstance>();
        HashSet<Material> m_uniqueMaterials = new HashSet<Material>();

        bool m_scanDone = false;

        bool m_listFoldout = false;

        [MenuItem("ONWARD/Scan for URP migration incompatible materials in scene")]
        static void Init()
        {
            MaterialSceneScan window = (MaterialSceneScan)EditorWindow.GetWindow(typeof(MaterialSceneScan), true, "Scan", true);

            window.Show();
        }

        void OnGUI()
        {
            GUILayout.Label("To make your upgrade process to URP as straight forward as possible you can already scan your scenes for materials that are incompatible.", EditorStyles.boldLabel);

            GUILayout.Space(20);

            m_listFoldout = EditorGUILayout.Foldout(m_listFoldout, "View compatible shaders");

            if (m_listFoldout)
            {
                m_scrollPositionFoldout = GUILayout.BeginScrollView(m_scrollPositionFoldout);

                foreach (string shaderName in URPConversionCompatibleShaders)
                {
                    GUILayout.BeginHorizontal();
                    GUILayout.Space(10);
                    GUILayout.Label($"{shaderName}", EditorStyles.textArea);
                    GUILayout.EndHorizontal();
                }

                GUILayout.Space(5);

                GUILayout.Label(" Any unlit shader is compatible as well.");

                GUILayout.EndScrollView();
            }

            GUILayout.Space(15);

            if (GUILayout.Button(m_scanDone ? "Scan again" : "Scan"))
            {
                Scan();
            }

            if (!m_scanDone)
                return;

            GUILayout.Space(15);

            if (m_detectedMaterials.Count <= 0)
            {
                GUILayout.Label("No incompatible shaders found.");

                return;
            }

            GUILayout.Label($"Incompatible shaders ({m_detectedMaterials.Count}):");

            GUILayout.Space(5);

            m_scrollPositionList = GUILayout.BeginScrollView(m_scrollPositionList);

            foreach (IncompatibleMaterialInstance detectedMaterial in m_detectedMaterials)
            {
                GUILayout.BeginHorizontal();
                {
                    GUILayout.Label(detectedMaterial.material.shader.name, EditorStyles.textArea);

                    /*
                    if (detectedMaterial.materialType == IncompatibleMaterialInstance.EMaterialType.Builtin)
                    {
                        Color oldColor = GUI.color;

                        GUI.color = Color.yellow;

                        GUILayout.Label("This is a built-in shader.", EditorStyles.textArea, GUILayout.Width(350));

                        GUI.color = oldColor;
                    }*/

                    if (GUILayout.Button("Select shader", GUILayout.Width(150)))
                    {
                        UnityEditor.Selection.activeObject = detectedMaterial.material.shader;
                    }

                    if (GUILayout.Button("Select material", GUILayout.Width(150)))
                    {
                        UnityEditor.Selection.activeObject = detectedMaterial.material;
                    }

                    if (GUILayout.Button("Select scene object", GUILayout.Width(150)))
                    {
                        UnityEditor.Selection.activeObject = detectedMaterial.renderer;
                    }
                }
                GUILayout.EndHorizontal();
            }

            GUILayout.EndScrollView();
        }

        void Scan()
        {
            m_detectedMaterials.Clear();
            m_uniqueMaterials.Clear();

            GameObject[] rootObjects = UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene().GetRootGameObjects();

            foreach (GameObject go in rootObjects)
            {
                List<Renderer> allRenderers = new List<Renderer>();

                go.GetComponentsInChildren<Renderer>(true, allRenderers);

                foreach (Renderer renderer in allRenderers)
                {
                    ProcessRenderer(renderer);
                }
            }

            m_scanDone = true;
        }

        void ProcessRenderer(Renderer renderer)
        {
            if (renderer == null)
                return;

            Material[] m_materials = renderer.sharedMaterials;

            foreach (Material material in m_materials)
            {
                ProcessMaterial(renderer, material);
            }
        }

        void ProcessMaterial(Renderer renderer, Material material)
        {
            if (material == null)
            {
                Debug.LogWarning($"Missing material on {renderer.gameObject}", renderer.gameObject);

                return;
            }

            if (m_uniqueMaterials.Contains(material))
                return;

            m_uniqueMaterials.Add(material);

            if (IsURPConversionCompatibleShader(material.shader.name))
                return;

            IncompatibleMaterialInstance.EMaterialType type = IncompatibleMaterialInstance.EMaterialType.Unknown;

            if (UnityEditor.AssetDatabase.GetAssetPath(material.shader) == "Resources/unity_builtin_extra")
                type = IncompatibleMaterialInstance.EMaterialType.Builtin;

            m_detectedMaterials.Add(new IncompatibleMaterialInstance()
            {
                renderer = renderer,
                material = material,
                materialType = type
            });
        }

        bool IsURPConversionCompatibleShader(string shaderName)
        {
            string lowerCaseShaderName = shaderName.ToLower();

            // Already URP
            if (lowerCaseShaderName.StartsWith("Universal Render Pipeline".ToLower()))
                return true;

            // Doesn't use any lighting
            if (lowerCaseShaderName.Contains("unlit"))
                return true;

            return System.Array.IndexOf(URPConversionCompatibleShaders, lowerCaseShaderName) != -1;
        }
    }
}
#endif