using Procedural;
using UnityEditor;
using UnityEditor.SceneManagement;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using UnityEngine.UI;

namespace ProceduralEditor
{
    public static class SetupMainMenuScene
    {
        const string ScenePath = "Assets/Scenes/Menu.unity";
        const string MaterialsFolder = "Assets/Materials";
        const string FaceMaterialPath = MaterialsFolder + "/LowPolyTriangleFace.mat";
        const string SettingsFolder = "Assets/Settings";
        const string PostProcessProfilePath = SettingsFolder + "/MenuPostProcessProfile.asset";

        // Slightly deeper background and a wider field of view for a more open framing
        static readonly Color BackgroundColor = new Color(0.92f, 0.93f, 0.95f);
        static readonly Vector3 PanelCenter = new Vector3(0f, 0f, 10f);

        [MenuItem("Tools/Scene/Setup Main Menu Scene")]
        public static void Setup()
        {
            if (EditorApplication.isPlaying)
            {
                Debug.LogError("Setup Main Menu Scene: exit Play Mode first — EditorSceneManager.OpenScene() can't run during Play Mode.");
                return;
            }

            var scene = EditorSceneManager.OpenScene(ScenePath, OpenSceneMode.Single);

            var faceMaterial = GetOrCreateMaterial(FaceMaterialPath, "Universal Render Pipeline/Lit", mat =>
            {
                mat.SetColor("_BaseColor", new Color(0.08f, 0.09f, 0.12f));
                if (mat.HasProperty("_Smoothness")) mat.SetFloat("_Smoothness", 0.3f);
                if (mat.HasProperty("_Metallic")) mat.SetFloat("_Metallic", 0.05f);
                if (mat.HasProperty("_Cull")) mat.SetFloat("_Cull", 0f);
            });

            SetupQuality();
            SetupCamera();
            SetupLight();
            SetupPanel(faceMaterial);
            SetupFog();
            SetupPostProcessVolume();
            RemoveLegacyLogo();
            SetupFadeCanvas();

            EditorSceneManager.MarkSceneDirty(scene);
            Debug.Log("Main Menu scene set up. Review the Game view framing, then save the scene.");
        }

        static void SetupCamera()
        {
            var cam = Camera.main;
            if (cam == null)
            {
                var go = new GameObject("Main Camera", typeof(Camera), typeof(AudioListener));
                go.tag = "MainCamera";
                cam = go.GetComponent<Camera>();
            }

            // Position/rotation/FOV captured from the live scene after manual framing in the
            // Editor (approved there first, then copied back here) rather than computed — the
            // rotation includes a deliberate manual roll (Z) that a LookAt-based rotation
            // wouldn't produce, and the narrow FOV is a much tighter, more telephoto framing
            // than the original 60.
            cam.transform.position = new Vector3(-0.86f, 0.07f, 5.88f);
            cam.transform.rotation = Quaternion.Euler(-29.064f, -21.054f, -11.311f);
            // Increased FOV to give a more open, less telephoto composition
            cam.fieldOfView = 35f;
            cam.clearFlags = CameraClearFlags.SolidColor;
            cam.backgroundColor = BackgroundColor;
            cam.nearClipPlane = 0.3f;
            cam.farClipPlane = 60f;
            // URP silently disables TAA when MSAA is active (they're mutually exclusive) — the
            // pipeline asset has MSAA on for other scenes (see SetupQuality), so it's turned off
            // per-camera here rather than touching that shared, project-wide asset.
            cam.allowMSAA = false;

            // URP has no "Post Process Layer" component (that's Built-in RP's Post-Processing
            // Stack v2) — post-processing is a per-camera flag on UniversalAdditionalCameraData
            // plus the antialiasing mode below; that combination is the URP equivalent.
            //
            // Switched from SMAA to TAA (Temporal Anti-Aliasing) for higher quality — SMAA was
            // already maxed at "High" quality with no further headroom, while TAA accumulates
            // sub-pixel samples across frames and handles the specular sparkle far better.
            // Tradeoff: TAA can ghost/smear on continuously moving edges, and this panel never
            // stops moving (wave + tilt + sway), so varianceClampScale is pulled down from URP's
            // default (0.9 -> 0.65) to bias toward less ghosting, with contrast-adaptive
            // sharpening turned on to counter the softening TAA otherwise introduces. Watch for
            // trailing/streaking behind fast-moving edges — if it shows up, SMAA is the fallback.
            var camData = cam.GetComponent<UniversalAdditionalCameraData>();
            if (camData == null) camData = cam.gameObject.AddComponent<UniversalAdditionalCameraData>();
            camData.renderPostProcessing = true;
            camData.antialiasing = AntialiasingMode.TemporalAntiAliasing;
            ref var taa = ref camData.taaSettings;
            taa.quality = TemporalAAQuality.High;
            taa.varianceClampScale = 0.65f;
            taa.contrastAdaptiveSharpening = 0.6f;
        }

        static void SetupLight()
        {
            Light light = Object.FindFirstObjectByType<Light>();
            GameObject go;
            if (light == null)
            {
                go = new GameObject("Directional Light", typeof(Light));
                light = go.GetComponent<Light>();
            }
            else
            {
                go = light.gameObject;
            }

            light.type = LightType.Directional;
            go.transform.position = new Vector3(0f, 3f, 0f);
            // The panel's visible faces have world normal +Z, so the light needs a strong
            // -Z travel direction (yaw ~180) to actually illuminate them head-on instead of
            // grazing the wall edge-on the way the old floor-tuned angle did.
            go.transform.rotation = Quaternion.Euler(35f, 180f, 0f);
            light.color = new Color(1f, 0.96f, 0.86f);
            light.intensity = 1.9f;

            RenderSettings.ambientMode = AmbientMode.Flat;
            RenderSettings.ambientLight = new Color(0.22f, 0.24f, 0.28f);

            if (go.GetComponent<MenuLightAnimator>() == null)
                go.AddComponent<MenuLightAnimator>();
        }

        static void SetupPanel(Material faceMaterial)
        {
            var existing = GameObject.Find("Triangle Wave Panel");
            if (existing != null) Object.DestroyImmediate(existing);

            var go = new GameObject("Triangle Wave Panel");
            go.transform.position = PanelCenter;
            // Rotate the panel from its default horizontal (floor, XZ) orientation to vertical
            // (XY, facing the camera along Z). Local Y (the wave/thickness axis) becomes world Z,
            // so tiles ripple toward/away from the camera instead of bobbing up/down.
            go.transform.rotation = Quaternion.Euler(90f, 0f, 0f);

            var panel = go.AddComponent<TriangleWavePanel>();
            // Slightly larger than the minimum frame-filling size, since the camera now views the
            // panel off-axis (see SetupCamera) rather than dead-on, which eats into the margin.
            panel.columns = 46;
            panel.rows = 30;
            panel.triangleSize = 1f;
            // Values below captured from the live scene after manual tweaking in the Inspector
            // (approved there first, then copied back here).
            panel.gapScale = 0.973f;
            panel.cornerRadius = 0f;
            panel.cornerSegments = 3;
            panel.thickness = 0.15f;
            panel.waveAmplitude = 0.45f;
            panel.waveFrequency = 0.18f;
            panel.waveSpeed = 0.8f;
            panel.tiltAmount = 1.4f;
            panel.swayAmplitude = 10f;
            panel.swaySpeed = 0.2f;
            panel.showBacker = false;
            panel.faceMaterial = faceMaterial;
            panel.backerMaterial = faceMaterial;

            // AddComponent already triggered one Rebuild() using class defaults before the fields
            // above were set (see TriangleWavePanel.RebuildNow's doc comment) — force a real one
            // now that the panel is fully configured.
            panel.RebuildNow();
        }

        static void SetupFog()
        {
            // A vertical, camera-facing wall has no receding horizon to hide, so fog stays off;
            // the grid is sized so its edges fall outside the frustum instead.
            RenderSettings.fog = false;
        }

        static void RemoveLegacyLogo()
        {
            var legacyLogo = GameObject.Find("NetCode Logo");
            if (legacyLogo != null)
                Object.DestroyImmediate(legacyLogo);
        }

        static void SetupFadeCanvas()
        {
            var existing = GameObject.Find("Fade Canvas");
            if (existing != null)
            {
                existing.SetActive(true);
                existing.transform.localScale = Vector3.one;
                var existingImage = existing.transform.Find("Fade Image");
                if (existingImage != null)
                {
                    existingImage.gameObject.SetActive(true);
                    var existingFadeIn = existingImage.GetComponent<MenuFadeIn>();
                    if (existingFadeIn == null)
                        existingFadeIn = existingImage.gameObject.AddComponent<MenuFadeIn>();

                    existingFadeIn.delay = 2.5f;
                    existingFadeIn.duration = 3.5f;
                    existingFadeIn.enabled = true;

                    var existingGroup = existingImage.GetComponent<CanvasGroup>();
                    if (existingGroup != null)
                    {
                        existingGroup.alpha = 1f;
                        existingGroup.blocksRaycasts = true;
                        existingGroup.interactable = true;
                    }

                    return;
                }
            }

            var canvasGo = new GameObject("Fade Canvas", typeof(Canvas), typeof(CanvasScaler), typeof(GraphicRaycaster));
            canvasGo.transform.localScale = Vector3.one;
            var canvas = canvasGo.GetComponent<Canvas>();
            canvas.renderMode = RenderMode.ScreenSpaceOverlay;
            // Ensure fade canvas draws on top of other UI canvases
            canvas.overrideSorting = true;
            canvas.sortingOrder = 1000;
            var scaler = canvasGo.GetComponent<CanvasScaler>();
            scaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
            scaler.referenceResolution = new Vector2(1920, 1080);

            var imageGo = new GameObject("Fade Image", typeof(Image), typeof(CanvasGroup));
            imageGo.transform.SetParent(canvasGo.transform, false);
            var image = imageGo.GetComponent<Image>();
            image.color = new Color(0.03f, 0.03f, 0.04f, 1f);
            var rect = image.rectTransform;
            rect.anchorMin = Vector2.zero;
            rect.anchorMax = Vector2.one;
            rect.offsetMin = Vector2.zero;
            rect.offsetMax = Vector2.zero;

            var fadeIn = imageGo.AddComponent<MenuFadeIn>();
            fadeIn.delay = 2.5f;
            fadeIn.duration = 3.5f;

            // Make sure the image initially is fully opaque so the menu starts covered by the backdrop
            var initColor = image.color;
            initColor.a = 1f;
            image.color = initColor;

            // DEBUG: add a small top-right button to toggle fade (full opacity <-> transparent)
            var buttonGo = new GameObject("Debug Toggle Fade Button", typeof(RectTransform), typeof(UnityEngine.UI.Button), typeof(Image));
            buttonGo.transform.SetParent(canvasGo.transform, false);
            var btnRect = buttonGo.GetComponent<RectTransform>();
            // anchor to top-right
            btnRect.anchorMin = new Vector2(1f, 1f);
            btnRect.anchorMax = new Vector2(1f, 1f);
            btnRect.pivot = new Vector2(1f, 1f);
            btnRect.sizeDelta = new Vector2(140f, 32f);
            btnRect.anchoredPosition = new Vector2(-10f, -10f);

            var btnImage = buttonGo.GetComponent<Image>();
            btnImage.color = new Color(0.08f, 0.08f, 0.08f, 0.85f);

            var button = buttonGo.GetComponent<UnityEngine.UI.Button>();
            var colors = button.colors;
            colors.normalColor = new Color(0.12f, 0.12f, 0.12f, 0.9f);
            colors.highlightedColor = new Color(0.18f, 0.18f, 0.18f, 0.95f);
            colors.pressedColor = new Color(0.06f, 0.06f, 0.06f, 0.9f);
            button.colors = colors;

            // simple text label (legacy UI Text so no TMP dependency required)
            var textGo = new GameObject("Text", typeof(RectTransform), typeof(UnityEngine.UI.Text));
            textGo.transform.SetParent(buttonGo.transform, false);
            var txt = textGo.GetComponent<UnityEngine.UI.Text>();
            txt.text = "Toggle Fade";
            txt.alignment = TextAnchor.MiddleCenter;
            txt.color = Color.white;
            txt.fontSize = 14;
            var txtRect = textGo.GetComponent<RectTransform>();
            txtRect.anchorMin = Vector2.zero;
            txtRect.anchorMax = Vector2.one;
            txtRect.offsetMin = Vector2.zero;
            txtRect.offsetMax = Vector2.zero;

            // add runtime helper (component created in new file DebugFadeToggle.cs)
            var debugToggle = buttonGo.AddComponent<ProceduralEditor.DebugFadeToggleBridge>();
            debugToggle.targetImage = image;
            debugToggle.duration = fadeIn.duration;
        }

        static void SetupPostProcessVolume()
        {
            var existing = GameObject.Find("Post Process Volume");
            if (existing != null) Object.DestroyImmediate(existing);

            var profile = AssetDatabase.LoadAssetAtPath<VolumeProfile>(PostProcessProfilePath);
            if (profile == null)
            {
                if (!AssetDatabase.IsValidFolder(SettingsFolder))
                    AssetDatabase.CreateFolder("Assets", "Settings");
                profile = ScriptableObject.CreateInstance<VolumeProfile>();
                AssetDatabase.CreateAsset(profile, PostProcessProfilePath);
            }

            if (!profile.TryGet(out DepthOfField dof))
                dof = profile.Add<DepthOfField>();

            // "Blur" here is depth-of-field rather than a flat uniform blur: at this close a
            // camera distance (see SetupCamera, Z=7.5 vs panel at Z=10) the panel's own width
            // creates a big apparent depth range across the frame purely from perspective, so
            // gaussianStart/End are tuned to keep roughly the center sharp and let the
            // corners/edges soften — a graduated blur rather than blurring everything equally.
            dof.active = true;
            dof.mode.overrideState = true;
            dof.mode.value = DepthOfFieldMode.Gaussian;
            dof.gaussianStart.overrideState = true;
            dof.gaussianStart.value = 2f;
            dof.gaussianEnd.overrideState = true;
            dof.gaussianEnd.value = 9f;
            dof.gaussianMaxRadius.overrideState = true;
            dof.gaussianMaxRadius.value = 1f;
            dof.highQualitySampling.overrideState = true;
            dof.highQualitySampling.value = true;

            EditorUtility.SetDirty(profile);
            AssetDatabase.SaveAssets();

            var go = new GameObject("Post Process Volume", typeof(Volume));
            var volume = go.GetComponent<Volume>();
            volume.isGlobal = true;
            volume.priority = 0f;
            volume.weight = 1f;
            volume.sharedProfile = profile;
        }

        static void SetupQuality()
        {
            // Sets MSAA on the shared pipeline asset for scenes/cameras that still use SMAA/FXAA
            // (which do benefit from stacking with MSAA). This menu's own camera now uses TAA
            // instead, which requires MSAA off, so it opts itself out via cam.allowMSAA in
            // SetupCamera() rather than leaving this project-wide asset at 1x for everyone.
            if (GraphicsSettings.currentRenderPipeline is UniversalRenderPipelineAsset urpAsset)
            {
                urpAsset.msaaSampleCount = 8;
                EditorUtility.SetDirty(urpAsset);
                AssetDatabase.SaveAssets();
            }
        }

        static Material GetOrCreateMaterial(string path, string shaderName, System.Action<Material> configure)
        {
            var existing = AssetDatabase.LoadAssetAtPath<Material>(path);
            if (existing != null) return existing;

            if (!AssetDatabase.IsValidFolder(MaterialsFolder))
                AssetDatabase.CreateFolder("Assets", "Materials");

            var shader = Shader.Find(shaderName);
            if (shader == null)
            {
                Debug.LogError($"SetupMainMenuScene: could not find shader '{shaderName}'.");
                return null;
            }

            var mat = new Material(shader);
            configure(mat);
            AssetDatabase.CreateAsset(mat, path);
            AssetDatabase.SaveAssets();
            return mat;
        }
    }
}