#if UNITY_EDITOR
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnityEditor;
using UnityEditor.SceneManagement;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using Object = UnityEngine.Object;

/// <summary>Authors HomeCamp through Pipeline; never constructs the scene at runtime.</summary>
public static class BuildHomeCamp
{
    const string Root = "Assets/Bundles/Scenes/Town/HomeCamp";
    const string Town = "Assets/Bundles/Scenes/Town/TownSquare";
    const string PrefabPath = Root + "/HomeCamp.prefab";
    const string ScenePath = Root + "/HomeCamp.unity";
    const int Layer = 29;
    static readonly string[] Parts = { "ground", "mainhouse", "cottage", "fountain" };
    static string Repo => Directory.GetParent(Application.dataPath).Parent.FullName;
    static string Review => Path.Combine(Repo, "Tools/output/homecamp_review");
    [Serializable] class Receipt { public string status = ""; public int triangles = 0; public int targetTriangles = 0; }

    public static string Inspect()
    {
        return string.Join("\n", Enumerable.Range(0, SceneManager.sceneCount).Select(i =>
        { var s = SceneManager.GetSceneAt(i); return s.path + " dirty=" + s.isDirty; }));
    }

    static void Folder(string path)
    {
        if (AssetDatabase.IsValidFolder(path)) return;
        var parent = path.Substring(0, path.LastIndexOf('/'));
        Folder(parent); AssetDatabase.CreateFolder(parent, Path.GetFileName(path));
    }
    static Bounds BoundsOf(GameObject go)
    {
        var renderers = go.GetComponentsInChildren<Renderer>(true);
        if (renderers.Length == 0) throw new InvalidOperationException("No renderer: " + go.name);
        var b = renderers[0].bounds;
        foreach (var r in renderers.Skip(1)) b.Encapsulate(r.bounds);
        return b;
    }
    static void SetLayer(GameObject go)
    {
        foreach (var t in go.GetComponentsInChildren<Transform>(true)) t.gameObject.layer = Layer;
    }
    static void Source(string source, string destination)
    {
        if (!File.Exists(source)) throw new FileNotFoundException(source);
        Folder(Path.GetDirectoryName(destination).Replace('\\', '/'));
        File.Copy(source, destination, true);
        AssetDatabase.ImportAsset(destination, ImportAssetOptions.ForceSynchronousImport);
    }
    static void TextureSettings(string path, bool srgb, bool backdrop = false)
    {
        var importer = (TextureImporter)AssetImporter.GetAtPath(path);
        importer.textureType = TextureImporterType.Default;
        importer.sRGBTexture = srgb; importer.alphaIsTransparency = false;
        importer.mipmapEnabled = !backdrop; importer.maxTextureSize = 2048;
        importer.textureCompression = TextureImporterCompression.Uncompressed;
        importer.wrapMode = TextureWrapMode.Clamp;
        importer.SaveAndReimport();
    }
    static Material SaveMaterial(string path, string shaderName)
    {
        var shader = Shader.Find(shaderName);
        if (!shader) throw new InvalidOperationException("Missing shader " + shaderName);
        var mat = AssetDatabase.LoadAssetAtPath<Material>(path);
        if (!mat) { mat = new Material(shader); AssetDatabase.CreateAsset(mat, path); }
        mat.shader = shader;
        return mat;
    }

    public static string BuildAssets()
    {
        if (EditorApplication.isPlaying) throw new InvalidOperationException("Stop Play before authoring.");
        AssetDatabase.ImportAsset("Assets/Bundles/Shaders/XShader/HomeCampXPbr.shader", ImportAssetOptions.ForceSynchronousImport);
        // Validate all four receipts before importing any model.
        foreach (var part in Parts)
        {
            var path = Path.Combine(Repo, "Tools/output/homecamp_studio", part, "production.json");
            var receipt = JsonUtility.FromJson<Receipt>(File.ReadAllText(path));
            if (receipt.status != "ready_for_unity" || receipt.triangles * 10 > receipt.targetTriangles * 13)
                throw new InvalidOperationException("Unfinished model " + part);
        }
        foreach (var part in Parts)
        {
            var dir = Root + "/" + part;
            var source = Path.Combine(Repo, "Tools/output/homecamp_studio", part, "xpbr");
            foreach (var suffix in new[] { ".fbx", "_base.png", "_mix.png" })
                Source(Path.Combine(source, part + suffix), dir + "/" + part + suffix);
            var fbx = dir + "/" + part + ".fbx";
            var importer = (ModelImporter)AssetImporter.GetAtPath(fbx);
            importer.globalScale = 1; importer.useFileScale = false; importer.bakeAxisConversion = true;
            importer.materialImportMode = ModelImporterMaterialImportMode.None;
            importer.meshCompression = ModelImporterMeshCompression.Off;
            importer.isReadable = part == "ground"; importer.addCollider = false;
            importer.SaveAndReimport();
            TextureSettings(dir + "/" + part + "_base.png", true);
            TextureSettings(dir + "/" + part + "_mix.png", false);
            var mat = SaveMaterial(dir + "/" + part + ".mat", "Test/HomeCampXPbr");
            mat.SetTexture("_MainTex", AssetDatabase.LoadAssetAtPath<Texture2D>(dir + "/" + part + "_base.png"));
            mat.SetTexture("_MixTex", AssetDatabase.LoadAssetAtPath<Texture2D>(dir + "/" + part + "_mix.png"));
            mat.SetColor("_BaseColor", Color.white); mat.SetFloat("_Metallic", 1); mat.SetFloat("_Roughness", 1); mat.SetFloat("_AO", 1);
            EditorUtility.SetDirty(mat); AssetDatabase.SaveAssetIfDirty(mat);
            var scene = EditorSceneManager.NewPreviewScene();
            try
            {
                var go = (GameObject)PrefabUtility.InstantiatePrefab(AssetDatabase.LoadAssetAtPath<GameObject>(fbx), scene);
                go.name = part;
                go.transform.localPosition = Vector3.zero; go.transform.localRotation = Quaternion.identity; go.transform.localScale = Vector3.one;
                foreach (var r in go.GetComponentsInChildren<Renderer>()) r.sharedMaterial = mat;
                if (part == "ground")
                    foreach (var f in go.GetComponentsInChildren<MeshFilter>())
                    { var c = f.gameObject.AddComponent<MeshCollider>(); c.sharedMesh = f.sharedMesh; c.convex = false; }
                PrefabUtility.SaveAsPrefabAsset(go, dir + "/" + part + ".prefab");
            }
            finally { EditorSceneManager.ClosePreviewScene(scene); }
        }
        Source(Path.Combine(Repo, "Doc/Design/Scene/HomeCamp/backdrop.png"), Root + "/backdrop.png");
        TextureSettings(Root + "/backdrop.png", true, true);
        var background = SaveMaterial(Root + "/backdrop.mat", "Universal Render Pipeline/Unlit");
        background.SetTexture("_BaseMap", AssetDatabase.LoadAssetAtPath<Texture2D>(Root + "/backdrop.png"));
        background.SetColor("_BaseColor", Color.white);
        EditorUtility.SetDirty(background); AssetDatabase.SaveAssetIfDirty(background);
        foreach (var name in new[] { "tree_card", "flower_card" })
        {
            Source(Path.Combine(Repo, "Doc/Design/Scene/HomeCamp", name + ".png"), Root + "/" + name + ".png");
            TextureSettings(Root + "/" + name + ".png", true);
            var ti = (TextureImporter)AssetImporter.GetAtPath(Root + "/" + name + ".png");
            ti.alphaIsTransparency = true; ti.SaveAndReimport();
            var card = SaveMaterial(Root + "/" + name + ".mat", "Universal Render Pipeline/Unlit");
            card.SetTexture("_BaseMap", AssetDatabase.LoadAssetAtPath<Texture2D>(Root + "/" + name + ".png"));
            card.SetColor("_BaseColor", Color.white); card.SetFloat("_AlphaClip", 1); card.SetFloat("_Cutoff", .55f);
            card.EnableKeyword("_ALPHATEST_ON"); card.SetFloat("_Cull", 0); card.renderQueue = 2450;
            card.SetOverrideTag("RenderType", "TransparentCutout");
            EditorUtility.SetDirty(card); AssetDatabase.SaveAssetIfDirty(card);
        }
        BuildGroundSurface();
        return "Imported four Studio assets + XPbr, authored four component Prefabs and unlit background material.";
    }

    static void BuildGroundSurface()
    {
        Source(Path.Combine(Repo, "Doc/Design/Scene/HomeCamp/ground_surface.png"), Root + "/ground_surface.png");
        TextureSettings(Root + "/ground_surface.png", true);
        var mat = SaveMaterial(Root + "/ground_surface.mat", "Universal Render Pipeline/Unlit");
        mat.SetTexture("_BaseMap", AssetDatabase.LoadAssetAtPath<Texture2D>(Root + "/ground_surface.png"));
        mat.SetColor("_BaseColor", Color.white);
        EditorUtility.SetDirty(mat); AssetDatabase.SaveAssetIfDirty(mat);
        var mesh = AssetDatabase.LoadAssetAtPath<Mesh>(Root + "/GroundSurface.asset");
        if (!mesh) { mesh = new Mesh(); AssetDatabase.CreateAsset(mesh, Root + "/GroundSurface.asset"); }
        mesh.Clear(); mesh.name = "HomeCamp continuous ground surface";
        mesh.vertices = new[] {new Vector3(-18,0,-21), new Vector3(-18,0,21), new Vector3(18,0,21), new Vector3(18,0,-21)};
        mesh.uv = new[] {new Vector2(0,0),new Vector2(0,1),new Vector2(1,1),new Vector2(1,0)};
        mesh.triangles = new[] {0,1,2,0,2,3}; mesh.RecalculateNormals(); mesh.RecalculateTangents(); mesh.RecalculateBounds();
        EditorUtility.SetDirty(mesh); AssetDatabase.SaveAssetIfDirty(mesh);
        var scene = EditorSceneManager.NewPreviewScene();
        try
        {
            var go = new GameObject("GroundSurface"); SceneManager.MoveGameObjectToScene(go, scene);
            go.AddComponent<MeshFilter>().sharedMesh = mesh; go.AddComponent<MeshRenderer>().sharedMaterial = mat;
            go.AddComponent<MeshCollider>().sharedMesh = mesh;
            PrefabUtility.SaveAsPrefabAsset(go, Root + "/GroundSurface.prefab");
        }
        finally { EditorSceneManager.ClosePreviewScene(scene); }
    }

    static GameObject Place(Transform parent, string path, string name, Vector3 pos, float size, bool width = false, bool faceCenter = false)
    {
        var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(path);
        if (!prefab) throw new FileNotFoundException(path);
        var go = (GameObject)PrefabUtility.InstantiatePrefab(prefab, parent);
        go.name = name; go.transform.localPosition = Vector3.zero; go.transform.localRotation = Quaternion.identity;
        go.transform.localScale = Vector3.one;
        var b = BoundsOf(go);
        var current = width ? Mathf.Max(b.size.x, b.size.z) : b.size.y;
        go.transform.localScale = Vector3.one * (size / current);
        if (faceCenter)
        { var away = new Vector3(pos.x, 0, pos.z - .8f); go.transform.localRotation = Quaternion.LookRotation(away, Vector3.up); }
        go.transform.position = pos;
        SetLayer(go);
        return go;
    }
    static string PartPath(string part) => Root + "/" + part + "/" + part + ".prefab";
    static string ReusePath(string part)
    {
        if (part == "tree" || part == "bush")
        {
            var name = part == "bush" ? "shrub" : "tree";
            return "Assets/Bundles/Scenes/Prototype/Battlefield/A/Components/" + name + "/" + name + ".prefab";
        }
        return Town + "/" + part + "/" + part + ".prefab";
    }
    static float GroundY(GameObject ground, float x, float z)
    {
        var ray = new Ray(new Vector3(x, 60, z), Vector3.down);
        var hits = ground.GetComponentsInChildren<MeshCollider>().Select(c =>
        { RaycastHit hit; return c.Raycast(ray, out hit, 120) ? hit.point.y : float.NegativeInfinity; }).ToArray();
        var y = hits.Max();
        if (float.IsNegativeInfinity(y)) throw new InvalidOperationException("Ground ray missed at " + x + "," + z);
        return y;
    }
    static GameObject FoliageCard(Transform parent, string name, string image, Vector3 bottom, float height)
    {
        var go = GameObject.CreatePrimitive(PrimitiveType.Quad); go.name = name;
        go.transform.SetParent(parent, false); Object.DestroyImmediate(go.GetComponent<Collider>());
        var texture = AssetDatabase.LoadAssetAtPath<Texture2D>(Root + "/" + image + ".png");
        var rotation = Quaternion.LookRotation(new Vector3(0, 1.8f, 3) - new Vector3(0, 15, -27), Vector3.up);
        go.transform.rotation = rotation;
        go.transform.position = bottom + (rotation * Vector3.up) * height * .5f;
        go.transform.localScale = new Vector3(height * texture.width / texture.height, height, 1);
        var renderer = go.GetComponent<Renderer>(); renderer.sharedMaterial = AssetDatabase.LoadAssetAtPath<Material>(Root + "/" + image + ".mat");
        renderer.shadowCastingMode = ShadowCastingMode.Off; renderer.receiveShadows = false;
        SetLayer(go); return go;
    }
    static Camera MakeCamera(Scene scene, Transform parent)
    {
        var go = new GameObject("HomeCampCamera"); SceneManager.MoveGameObjectToScene(go, scene);
        if (parent) go.transform.SetParent(parent, false);
        var camera = go.AddComponent<Camera>();
        go.transform.position = new Vector3(0, 15, -27);
        go.transform.LookAt(new Vector3(0, 1.8f, 3));
        camera.fieldOfView = 48; camera.nearClipPlane = .1f; camera.farClipPlane = 180;
        camera.clearFlags = CameraClearFlags.SolidColor; camera.backgroundColor = new Color(.46f, .72f, .88f);
        camera.cullingMask = 1 << Layer; camera.scene = scene;
        camera.allowHDR = false; camera.allowMSAA = true;
        return camera;
    }
    static void Light(Scene scene, Transform parent)
    {
        var go = new GameObject("HomeCampSun"); SceneManager.MoveGameObjectToScene(go, scene);
        if (parent) go.transform.SetParent(parent, false);
        var light = go.AddComponent<Light>(); light.type = LightType.Directional;
        light.color = new Color(1, .95f, .84f); light.intensity = 1.05f; light.shadows = LightShadows.Soft;
        light.cullingMask = 1 << Layer; go.transform.rotation = Quaternion.Euler(43, -32, 0);
    }
    static void Background(Transform parent, Camera camera)
    {
        var go = GameObject.CreatePrimitive(PrimitiveType.Quad); go.name = "DistantLakeWaterfallCastle";
        go.transform.SetParent(parent, false); Object.DestroyImmediate(go.GetComponent<Collider>());
        var renderer = go.GetComponent<MeshRenderer>();
        renderer.sharedMaterial = AssetDatabase.LoadAssetAtPath<Material>(Root + "/backdrop.mat");
        renderer.shadowCastingMode = ShadowCastingMode.Off; renderer.receiveShadows = false;
        const float distance = 75;
        var halfHeight = distance * Mathf.Tan(camera.fieldOfView * Mathf.Deg2Rad * .5f);
        var width = halfHeight * 2 * 1080f / 1920;
        var height = width / 1.5f;
        go.transform.position = camera.transform.position + camera.transform.forward * distance + camera.transform.up * (halfHeight - height * .5f);
        go.transform.rotation = camera.transform.rotation;
        go.transform.localScale = new Vector3(width * 1.04f, height * 1.04f, 1);
        SetLayer(go);
    }

    public static string Build()
    {
        if (EditorApplication.isPlaying) throw new InvalidOperationException("Author in Edit Mode.");
        var previous = SceneManager.GetActiveScene();
        var scene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Additive);
        try
        {
            SceneManager.SetActiveScene(scene);
            var root = new GameObject("HomeCamp");
            var ground = (GameObject)PrefabUtility.InstantiatePrefab(AssetDatabase.LoadAssetAtPath<GameObject>(Root + "/GroundSurface.prefab"), root.transform);
            ground.name = "Ground"; SetLayer(ground);
            // Final source ground must be horizontal; reject a vertical generated plate.
            var gb = BoundsOf(ground);
            if (gb.size.y > Mathf.Min(gb.size.x, gb.size.z) * .3f)
                throw new InvalidOperationException("Ground requires offline orientation correction before assembly: " + gb.size);
            Physics.SyncTransforms();
            var placements = new List<string>();
            void Put(string part, string name, float x, float z, float size, bool width = false, bool facing = false, bool reused = false)
            {
                var y = GroundY(ground, x, z);
                if (reused && (part == "tree" || part == "bush"))
                {
                    FoliageCard(root.transform, name, part == "tree" ? "tree_card" : "flower_card", new Vector3(x,y,z), size);
                    placements.Add(name + " card groundY=" + y.ToString("F3")); return;
                }
                var path = reused ? ReusePath(part) : PartPath(part);
                var go = Place(root.transform, path, name, new Vector3(x, y, z), size, width, facing);
                var bottom = BoundsOf(go).min.y;
                go.transform.position += Vector3.up * (y - bottom);
                placements.Add(name + " groundY=" + y.ToString("F3"));
            }
            Put("mainhouse", "MainHouse", 0, 7.2f, 6.5f, false, true);
            Put("mainhouse", "HouseLeft", -7.5f, 4, 4, false, true);
            Put("mainhouse", "HouseRight", 7.5f, 4, 4, false, true);
            Put("fountain", "Fountain", 0, .8f, 4.4f, true);
            Put("tree", "TreeBackLeft", -9, 8, 7, false, false, true);
            Put("tree", "TreeBackRight", 9, 9, 6.5f, false, false, true);
            Put("tree", "TreeRearLeft", -5.6f, 14, 4.8f, false, false, true);
            Put("tree", "TreeRearRight", 5.6f, 14, 4.8f, false, false, true);
            Put("tree", "TreeFrontLeft", -10, -4, 5, false, false, true);
            Put("lamp", "LampLeft", -5.2f, -.5f, 2.6f, false, false, true);
            Put("lamp", "LampRight", 5.2f, 1, 2.6f, false, false, true);
            Put("lamp", "LampForeground", 5.5f, -6, 2.7f, false, false, true);
            Put("bench", "BenchFrontLeft", -4.4f, -4, 2.2f, true, true, true);
            for (int i = 0; i < 12; i++)
            {
                var angle = (i * 30f) * Mathf.Deg2Rad;
                Put("bush", "FountainFlowers" + i, Mathf.Sin(angle) * 2.7f, .8f + Mathf.Cos(angle) * 2.7f, .55f, false, false, true);
            }
            foreach (var p in new[] { new Vector2(-7,-5), new Vector2(-5,-7), new Vector2(6,-6), new Vector2(8,-3), new Vector2(-9,2), new Vector2(9,2) })
                Put("bush", "BorderFlowers", p.x, p.y, .9f, false, false, true);
            var camera = MakeCamera(scene, root.transform);
            Light(scene, root.transform); Background(root.transform, camera); SetLayer(root);
            RenderSettings.ambientMode = AmbientMode.Trilight;
            RenderSettings.ambientSkyColor = new Color(.68f, .75f, .82f);
            RenderSettings.ambientEquatorColor = new Color(.55f, .57f, .52f);
            RenderSettings.ambientGroundColor = new Color(.35f, .34f, .29f);
            PrefabUtility.SaveAsPrefabAsset(root, PrefabPath);
            EditorSceneManager.SaveScene(scene, ScenePath);
            Directory.CreateDirectory(Review);
            File.WriteAllText(Path.Combine(Review, "assembly.txt"), string.Join("\n", placements));
            CaptureCamera(camera, 1080, 1920, "homecamp_portrait.png");
            CaptureCamera(camera, 1080, 2400, "homecamp_tall.png");
            return "Saved " + PrefabPath + " and " + ScenePath + "; " + placements.Count + " placements; portrait/tall rendered.";
        }
        finally
        {
            if (previous.IsValid() && previous.isLoaded) SceneManager.SetActiveScene(previous);
            EditorSceneManager.CloseScene(scene, true);
        }
    }
    static void CaptureCamera(Camera camera, int width, int height, string name)
    {
        Directory.CreateDirectory(Review);
        var rt = RenderTexture.GetTemporary(width, height, 24, RenderTextureFormat.ARGB32);
        var old = RenderTexture.active; var oldTarget = camera.targetTexture; var oldAspect = camera.aspect;
        var oldAsync = ShaderUtil.allowAsyncCompilation;
        var texture = new Texture2D(width, height, TextureFormat.RGB24, false);
        try
        {
            ShaderUtil.allowAsyncCompilation = false;
            camera.aspect = (float)width / height; camera.targetTexture = rt; camera.Render(); camera.Render();
            RenderTexture.active = rt; texture.ReadPixels(new Rect(0, 0, width, height), 0, 0); texture.Apply();
            File.WriteAllBytes(Path.Combine(Review, name), texture.EncodeToPNG());
        }
        finally { ShaderUtil.allowAsyncCompilation = oldAsync; camera.targetTexture = oldTarget; camera.aspect = oldAspect; RenderTexture.active = old; RenderTexture.ReleaseTemporary(rt); Object.DestroyImmediate(texture); }
    }
    public static string CaptureParts() => CaptureSet(Parts);
    public static string CaptureReuse() => CaptureSet(new[] { "tree", "lamp", "bench", "bush" });
    static string CaptureSet(IEnumerable<string> parts)
    {
        foreach (var part in parts)
        {
            var scene = EditorSceneManager.NewPreviewScene();
            try
            {
                var path = Parts.Contains(part) ? PartPath(part) : ReusePath(part);
                var go = (GameObject)PrefabUtility.InstantiatePrefab(AssetDatabase.LoadAssetAtPath<GameObject>(path), scene);
                SetLayer(go); Light(scene, null);
                var b = BoundsOf(go); var extent = Mathf.Max(b.size.x, Mathf.Max(b.size.y, b.size.z));
                var camera = MakeCamera(scene, null); camera.orthographic = true; camera.orthographicSize = extent * .7f;
                camera.nearClipPlane = Mathf.Max(.00001f, extent * .01f); camera.farClipPlane = Mathf.Max(10, extent * 10);
                foreach (var direction in new[] { "front", "side", "back", "perspective" })
                {
                    var offset = direction == "front" ? new Vector3(0,.15f,-3) : direction == "side" ? new Vector3(3,.15f,0) : direction == "back" ? new Vector3(0,.15f,3) : new Vector3(2,1.8f,-3);
                    camera.transform.position = b.center + offset * extent;
                    camera.transform.LookAt(b.center);
                    CaptureCamera(camera, 640, 640, part + "_" + direction + ".png");
                }
            }
            finally { EditorSceneManager.ClosePreviewScene(scene); }
        }
        return "Rendered four views per component.";
    }
    public static string Verify()
    {
        var report = new List<string>();
        foreach (var part in Parts)
        {
            var p = AssetDatabase.LoadAssetAtPath<GameObject>(PartPath(part));
            if (!p) throw new InvalidOperationException("Missing component " + part);
            var triangles = p.GetComponentsInChildren<MeshFilter>().Sum(f => (int)f.sharedMesh.GetIndexCount(0) / 3);
            var receipt = JsonUtility.FromJson<Receipt>(File.ReadAllText(Path.Combine(Repo, "Tools/output/homecamp_studio", part, "production.json")));
            if (triangles > receipt.targetTriangles * 1.3f) throw new InvalidOperationException("Triangle budget " + part);
            foreach (var r in p.GetComponentsInChildren<Renderer>())
                if (!r.sharedMaterial || r.sharedMaterial.shader.name != "Test/HomeCampXPbr") throw new InvalidOperationException("XPbr " + part);
            report.Add(part + "=" + triangles);
        }
        var root = AssetDatabase.LoadAssetAtPath<GameObject>(PrefabPath);
        if (!root || !File.Exists(ScenePath)) throw new InvalidOperationException("Missing assembled scene/prefab");
        if (root.GetComponentsInChildren<MeshCollider>().Length == 0) throw new InvalidOperationException("Missing ground collider");
        var preview = EditorSceneManager.NewPreviewScene();
        var triangleCount = 0;
        try
        {
            var instance = (GameObject)PrefabUtility.InstantiatePrefab(root, preview);
            var ground = instance.transform.Find("Ground").gameObject;
            Physics.SyncTransforms();
            for (int x=-8; x<=8; x+=4) for (int z=-8; z<=8; z+=4) GroundY(ground,x,z);
            triangleCount = instance.GetComponentsInChildren<MeshFilter>().Sum(f => (int)f.sharedMesh.GetIndexCount(0)/3);
        }
        finally { EditorSceneManager.ClosePreviewScene(preview); }
        var backdrop = root.transform.Find("DistantLakeWaterfallCastle");
        if (!backdrop || backdrop.GetComponent<Collider>()) throw new InvalidOperationException("Backdrop collider");
        var bg = backdrop.GetComponent<Renderer>();
        if (bg.sharedMaterial.shader.name != "Universal Render Pipeline/Unlit" || bg.shadowCastingMode != ShadowCastingMode.Off)
            throw new InvalidOperationException("Backdrop must be unlit without shadows");
        if (EditorBuildSettings.scenes.Any(s => s.path == ScenePath)) throw new InvalidOperationException("Review scene unexpectedly added to build");
        Directory.CreateDirectory(Review);
        File.WriteAllText(Path.Combine(Review, "verification.txt"), "PASS " + string.Join("; ", report) + "; assembledTriangles=" + triangleCount + "; ground collision 25/25; unlit quad backdrop; independent scene; cottage/Studio ground retained as review candidates and not placed");
        return File.ReadAllText(Path.Combine(Review, "verification.txt"));
    }
    public static string OpenForReview()
    {
        var scene = SceneManager.GetSceneByPath(ScenePath);
        if (!scene.IsValid() || !scene.isLoaded) scene = EditorSceneManager.OpenScene(ScenePath, OpenSceneMode.Additive);
        SceneManager.SetActiveScene(scene);
        var root = scene.GetRootGameObjects().Single(); Selection.activeGameObject = root;
        var camera = root.GetComponentInChildren<Camera>();
        if (SceneView.lastActiveSceneView != null) SceneView.lastActiveSceneView.AlignViewToObject(camera.transform);
        return "Opened HomeCamp additively; existing scenes preserved.";
    }
}
#endif