using System;
using System.Collections.Generic;
using System.IO;
using System.Text.RegularExpressions;
using NUnit.Framework;
using Newtonsoft.Json.Linq;
using Unity.Pipeline;
using Unity.Pipeline.Editor.Commands.Batch;
using Unity.Pipeline.Editor.Commands.GameObjects;
using UnityEditor;
using UnityEngine;
using UnityEngine.TestTools;
using Object = UnityEngine.Object;

namespace Unity.Pipeline.Tests.Editor.Batch
{
    /// <summary>
    /// Tests for the transactional <c>batch</c> command (AUTHAPI-27), driven end-to-end through an
    /// isolated <see cref="PipelineTestServer"/> (the ViaClient pattern). Covers the acceptance
    /// criteria: cross-op references resolve, a mid-batch failure atomically rolls back every prior
    /// op, a successful batch collapses into a single Undo group, dry-run validates without mutating,
    /// a bad reference errors clearly, <c>on_error=continue</c> applies independent ops without
    /// reverting, and the 200-op cap is enforced.
    /// </summary>
    class BatchCommandTests
    {
        private readonly List<GameObject> m_Spawned = new List<GameObject>();

        private GameObject Track(GameObject go)
        {
            if (go != null)
                m_Spawned.Add(go);
            return go;
        }

        private static ObjectId? InstanceIdOf(JToken opResult) =>
            opResult?["result"]?["instanceId"]?.ToObject<ObjectId?>();

        private GameObject ResolveGameObject(JToken opResult)
        {
            var id = InstanceIdOf(opResult);
            if (!id.HasValue)
                return null;
            return Track(PipelineUtils.IdToObject(id.Value) as GameObject);
        }

        [TearDown]
        public void TearDown()
        {
            foreach (var go in m_Spawned)
            {
                if (go != null)
                    Object.DestroyImmediate(go);
            }
            m_Spawned.Clear();

            // Deliberately NO Undo.ClearAll() here: this suite runs inside the dogfood editor, and
            // wiping the global Undo stack would destroy the developer's own undo history. Per-test
            // state is cleaned up by destroying m_Spawned above; the batch Undo groups left on the
            // stack only reference those (now destroyed) test objects and are inert.
        }

        private static JObject Op(string command, JObject parameters = null, string id = null)
        {
            var op = new JObject { ["command"] = command };
            if (id != null)
                op["id"] = id;
            op["params"] = parameters ?? new JObject();
            return op;
        }

        [Test]
        public void Batch_CrossOpReferences_ResolveAndApply()
        {
            // AC: create_gameobject -> add_component -> set_serialized_field, where later ops use
            // $0.instanceId / $1.instanceId, executes in one round-trip with references resolved.
            using (var server = new PipelineTestServer())
            {
                var operations = new JArray
                {
                    Op("create_gameobject", new JObject { ["name"] = "BatchRef_Root" }),
                    Op("add_component", new JObject { ["target"] = "$0.instanceId", ["type"] = "Rigidbody" }),
                    Op("set_serialized_field", new JObject
                    {
                        ["target"] = "$1.instanceId",
                        ["field"] = "m_Mass",
                        ["value"] = new JValue(2.5f)
                    }),
                };

                var response = server.Execute("batch", new JObject { ["operations"] = operations });
                Assert.IsTrue(response.IsSuccess, $"batch should return HTTP success: {response.RawResponse}");

                var batch = response.JsonResponse["result"];
                Assert.AreEqual(3, batch["applied"]?.ToObject<int>(), "all three ops should apply");
                Assert.IsFalse(batch["reverted"]?.ToObject<bool>() ?? true, "a successful batch must not revert");
                Assert.IsNotNull(batch["undoGroup"], "execution result should carry the batch Undo group");

                var results = batch["results"] as JArray;
                Assert.AreEqual(3, results.Count);
                for (int i = 0; i < 3; i++)
                    Assert.IsTrue(results[i]["success"]?.ToObject<bool>() ?? false,
                        $"op {i} should succeed: {results[i]["error"]}");

                // The reference chain wired a Rigidbody onto op 0's GameObject and set its mass.
                var root = ResolveGameObject(results[0]);
                Assert.IsNotNull(root, "op 0's GameObject should be resolvable from its returned instanceId");
                var rb = root.GetComponent<Rigidbody>();
                Assert.IsNotNull(rb, "$0.instanceId must resolve so add_component targets op 0's GameObject");
                Assert.AreEqual(2.5f, rb.mass, 0.0001f,
                    "$1.instanceId must resolve so set_serialized_field targets the added Rigidbody");
            }
        }

        [Test]
        public void Batch_Transactional_MidBatchFailure_RevertsAllPriorOps()
        {
            // AC: an op fails mid-batch -> every prior op is reverted; scene equals pre-batch state.
            using (var server = new PipelineTestServer())
            {
                var operations = new JArray
                {
                    Op("create_gameobject", new JObject { ["name"] = "BatchRollback_A" }),
                    Op("create_gameobject", new JObject { ["name"] = "BatchRollback_B" }),
                    // Fails: unknown component type -> add_component throws before mutating.
                    Op("add_component", new JObject { ["target"] = "$0.instanceId", ["type"] = "NoSuchTypeXYZ" }),
                };

                // The failing sub-op logs an error through the shared command-dispatch path (batch
                // reuses it); the batch surfaces the failure structurally, but the log still fires.
                LogAssert.Expect(LogType.Error, new Regex("add_component' failed: Could not resolve component type 'NoSuchTypeXYZ'"));

                var response = server.Execute("batch", new JObject { ["operations"] = operations });
                Assert.IsTrue(response.IsSuccess, $"batch itself should return HTTP success: {response.RawResponse}");

                var batch = response.JsonResponse["result"];
                Assert.IsTrue(batch["reverted"]?.ToObject<bool>() ?? false, "a transactional failure must revert");
                Assert.AreEqual(2, batch["applied"]?.ToObject<int>(), "two ops ran before the failure");

                var results = batch["results"] as JArray;
                Assert.IsTrue(results[0]["success"]?.ToObject<bool>() ?? false);
                Assert.IsTrue(results[1]["success"]?.ToObject<bool>() ?? false);
                Assert.IsFalse(results[2]["success"]?.ToObject<bool>() ?? true, "op 2 must fail");
                StringAssert.Contains("component type", results[2]["error"]?.ToString(),
                    "the failing op's error should be reported");

                // The two created objects must be gone (reverted), both by name and by their ids.
                Assert.AreEqual(0, GameObjectCommands.FindGameObjects(name: "BatchRollback_A").Count,
                    "op 0's object must be reverted");
                Assert.AreEqual(0, GameObjectCommands.FindGameObjects(name: "BatchRollback_B").Count,
                    "op 1's object must be reverted");

                var id0 = InstanceIdOf(results[0]);
                var id1 = InstanceIdOf(results[1]);
                Assert.IsTrue(id0.HasValue && id1.HasValue, "reverted ops still report the ids they had created");
                Assert.IsNull(PipelineUtils.IdToObject(id0.Value), "op 0's object should no longer resolve");
                Assert.IsNull(PipelineUtils.IdToObject(id1.Value), "op 1's object should no longer resolve");
            }
        }

        [Test]
        public void Batch_SuccessfulBatch_CollapsesIntoSingleUndoGroup()
        {
            // AC: a successful batch shows exactly one Undo group -> a single Undo reverts the whole batch.
            using (var server = new PipelineTestServer())
            {
                var operations = new JArray
                {
                    Op("create_gameobject", new JObject { ["name"] = "BatchUndo_A" }),
                    Op("create_gameobject", new JObject { ["name"] = "BatchUndo_B" }),
                };

                var response = server.Execute("batch", new JObject { ["operations"] = operations });
                Assert.IsTrue(response.IsSuccess, $"batch should return HTTP success: {response.RawResponse}");

                // Track the created objects so TearDown cleans them up even if the Undo below misbehaves.
                var results = response.JsonResponse["result"]["results"] as JArray;
                ResolveGameObject(results[0]);
                ResolveGameObject(results[1]);

                Assert.AreEqual(1, GameObjectCommands.FindGameObjects(name: "BatchUndo_A").Count);
                Assert.AreEqual(1, GameObjectCommands.FindGameObjects(name: "BatchUndo_B").Count);

                // One Undo must revert BOTH creations, proving the whole batch collapsed into one group.
                Undo.PerformUndo();

                Assert.AreEqual(0, GameObjectCommands.FindGameObjects(name: "BatchUndo_A").Count,
                    "a single Undo should revert the first op (batch is one group)");
                Assert.AreEqual(0, GameObjectCommands.FindGameObjects(name: "BatchUndo_B").Count,
                    "a single Undo should revert the second op too (batch is one group)");
            }
        }

        [Test]
        public void Batch_DryRun_CatchesErrors_AndMutatesNothing()
        {
            // AC: dry_run catches unknown command, not_batchable, unknown param, and a bad reference,
            // with zero mutation.
            using (var server = new PipelineTestServer())
            {
                var operations = new JArray
                {
                    Op("create_gameobject", new JObject { ["name"] = "BatchDry_A" }),            // valid
                    Op("no_such_command_xyz"),                                                    // unknown command
                    Op("build"),                                                                  // not_batchable
                    Op("create_gameobject", new JObject { ["bogus_param"] = "x" }),               // unknown parameter
                    Op("add_component", new JObject { ["target"] = "$9.instanceId", ["type"] = "Rigidbody" }), // bad ref
                };

                var response = server.Execute("batch", new JObject
                {
                    ["operations"] = operations,
                    ["dry_run"] = true
                });
                Assert.IsTrue(response.IsSuccess, $"dry_run should return HTTP success: {response.RawResponse}");

                var batch = response.JsonResponse["result"];
                Assert.IsTrue(batch["dryRun"]?.ToObject<bool>() ?? false, "result should be marked dryRun");
                Assert.IsFalse(batch["valid"]?.ToObject<bool>() ?? true, "the batch has invalid ops");
                Assert.AreEqual(0, batch["applied"]?.ToObject<int>() ?? -1, "dry_run applies nothing");

                var results = batch["results"] as JArray;
                Assert.IsTrue(results[0]["success"]?.ToObject<bool>() ?? false, "op 0 is valid");
                StringAssert.Contains("unknown command", results[1]["error"]?.ToString());
                StringAssert.Contains("not_batchable", results[2]["error"]?.ToString());
                StringAssert.Contains("unknown parameter", results[3]["error"]?.ToString());
                StringAssert.Contains("unknown operation", results[4]["error"]?.ToString());

                // Zero mutation: the valid create op must NOT have run.
                Assert.AreEqual(0, GameObjectCommands.FindGameObjects(name: "BatchDry_A").Count,
                    "dry_run must not create anything");
            }
        }

        [Test]
        public void Batch_BadReference_ErrorsClearly_AndReverts()
        {
            // AC: a bad reference errors clearly. Here op 1 references a nonexistent op; under the
            // default transactional/abort policy op 0 is reverted.
            using (var server = new PipelineTestServer())
            {
                var operations = new JArray
                {
                    Op("create_gameobject", new JObject { ["name"] = "BatchBadRef_X" }),
                    Op("add_component", new JObject { ["target"] = "$5.instanceId", ["type"] = "Rigidbody" }),
                };

                var response = server.Execute("batch", new JObject { ["operations"] = operations });
                Assert.IsTrue(response.IsSuccess, $"batch should return HTTP success: {response.RawResponse}");

                var batch = response.JsonResponse["result"];
                var results = batch["results"] as JArray;
                Assert.IsFalse(results[1]["success"]?.ToObject<bool>() ?? true, "the referencing op must fail");
                var error = results[1]["error"]?.ToString();
                StringAssert.Contains("$5.instanceId", error, "the error should name the offending reference");
                StringAssert.Contains("unknown operation", error, "and explain why it is invalid");

                Assert.IsTrue(batch["reverted"]?.ToObject<bool>() ?? false, "the prior op must be reverted");
                Assert.AreEqual(0, GameObjectCommands.FindGameObjects(name: "BatchBadRef_X").Count,
                    "op 0 must be reverted after the bad reference");
            }
        }

        [Test]
        public void Batch_OnErrorContinue_AppliesIndependentOps_NoRevert()
        {
            // AC: on_error=continue collects failures, applies independent ops, reports reverted:false.
            using (var server = new PipelineTestServer())
            {
                var operations = new JArray
                {
                    Op("create_gameobject", new JObject { ["name"] = "BatchCont_A" }),
                    Op("add_component", new JObject { ["target"] = "$0.instanceId", ["type"] = "NoSuchTypeXYZ" }), // fails
                    Op("create_gameobject", new JObject { ["name"] = "BatchCont_C" }),                              // independent
                };

                LogAssert.Expect(LogType.Error, new Regex("add_component' failed: Could not resolve component type 'NoSuchTypeXYZ'"));

                var response = server.Execute("batch", new JObject
                {
                    ["operations"] = operations,
                    ["on_error"] = "continue"
                });
                Assert.IsTrue(response.IsSuccess, $"batch should return HTTP success: {response.RawResponse}");

                var batch = response.JsonResponse["result"];
                Assert.IsFalse(batch["reverted"]?.ToObject<bool>() ?? true, "continue must not revert");
                Assert.IsFalse(batch["transactional"]?.ToObject<bool>() ?? true, "continue forces transactional=false");
                Assert.AreEqual(2, batch["applied"]?.ToObject<int>(), "the two independent creates apply");

                var results = batch["results"] as JArray;
                Assert.IsTrue(results[0]["success"]?.ToObject<bool>() ?? false);
                Assert.IsFalse(results[1]["success"]?.ToObject<bool>() ?? true, "the middle op fails");
                Assert.IsTrue(results[2]["success"]?.ToObject<bool>() ?? false, "a later independent op still runs");

                // Both independent objects must survive (no rollback).
                Assert.IsNotNull(ResolveGameObject(results[0]), "op 0's object should survive");
                Assert.IsNotNull(ResolveGameObject(results[2]), "op 2's object should survive");
            }
        }

        [Test]
        public void Batch_ExceedsOperationCap_ReturnsError()
        {
            // AC: the 200-op cap is enforced with a structured error (checked before anything runs).
            using (var server = new PipelineTestServer())
            {
                var operations = new JArray();
                for (int i = 0; i < 201; i++)
                    operations.Add(Op("create_gameobject", new JObject { ["name"] = "BatchCap_" + i }));

                LogAssert.Expect(LogType.Error, new Regex("batch supports at most 200 operations"));

                var response = server.Execute("batch", new JObject
                {
                    ["operations"] = operations,
                    ["dry_run"] = true
                });

                Assert.IsFalse(response.IsSuccess, "a batch over the op cap must be rejected");
                StringAssert.Contains("200", response.RawResponse, "the error should state the 200-op cap");
                Assert.AreEqual(0, GameObjectCommands.FindGameObjects(name: "BatchCap_0").Count,
                    "an over-cap batch must create nothing");
            }
        }

        [Test]
        public void Batch_AsyncCommand_NotBatchable_AtDryRunAndExecution()
        {
            // C1: run_tests/list_tests are async Task commands completed by EditorApplication.update
            // callbacks, which cannot fire while the batch blocks the main thread — awaiting them
            // inline would freeze the editor permanently. They must be rejected, not dispatched.
            using (var server = new PipelineTestServer())
            {
                var operations = new JArray
                {
                    Op("run_tests", new JObject { ["mode"] = "EditMode" }),
                    Op("list_tests"),
                };

                // Dry run flags both without executing anything.
                var response = server.Execute("batch", new JObject
                {
                    ["operations"] = operations,
                    ["dry_run"] = true
                });
                Assert.IsTrue(response.IsSuccess, $"dry_run should return HTTP success: {response.RawResponse}");
                var results = response.JsonResponse["result"]["results"] as JArray;
                foreach (var opResult in results)
                {
                    Assert.IsFalse(opResult["success"]?.ToObject<bool>() ?? true, "async ops must fail validation");
                    StringAssert.Contains("not_batchable", opResult["error"]?.ToString());
                    StringAssert.Contains("async", opResult["error"]?.ToString());
                }

                // Execution rejects them the same way — and returns instead of hanging.
                response = server.Execute("batch", new JObject { ["operations"] = new JArray { Op("run_tests") } });
                Assert.IsTrue(response.IsSuccess, $"batch should return HTTP success: {response.RawResponse}");
                var exec = response.JsonResponse["result"];
                Assert.AreEqual(0, exec["applied"]?.ToObject<int>(), "nothing must be dispatched");
                StringAssert.Contains("not_batchable", exec["results"][0]["error"]?.ToString());
            }
        }

        [Test]
        public void Batch_Transactional_RejectsNonRevertibleCommand_NonTransactionalAllowsIt()
        {
            // C2: delete_asset mutates the AssetDatabase, which Undo cannot roll back — inside a
            // transactional batch "reverted: true" would be a lie, so it is rejected. With
            // transactional:false it runs and reports revertible:false.
            const string assetPath = "Assets/BatchTests_DeleteTarget.txt";
            File.WriteAllText(assetPath, "batch delete target");
            AssetDatabase.ImportAsset(assetPath);
            try
            {
                using (var server = new PipelineTestServer())
                {
                    var operations = new JArray
                    {
                        Op("delete_asset", new JObject { ["asset"] = assetPath, ["confirm"] = true }),
                    };

                    // Dry run under the default transactional=true flags it.
                    var response = server.Execute("batch", new JObject
                    {
                        ["operations"] = operations,
                        ["dry_run"] = true
                    });
                    var dry = response.JsonResponse["result"];
                    Assert.IsFalse(dry["valid"]?.ToObject<bool>() ?? true);
                    StringAssert.Contains("not_batchable_transactional", dry["results"][0]["error"]?.ToString());

                    // Execution under transactional=true rejects it too; the asset survives.
                    response = server.Execute("batch", new JObject { ["operations"] = operations });
                    var exec = response.JsonResponse["result"];
                    Assert.IsFalse(exec["results"][0]["success"]?.ToObject<bool>() ?? true);
                    StringAssert.Contains("not_batchable_transactional", exec["results"][0]["error"]?.ToString());
                    Assert.IsNotNull(AssetDatabase.LoadMainAssetAtPath(assetPath),
                        "a rejected delete_asset must not touch the asset");

                    // transactional:false allows it — with an honest revertible:false on the op.
                    response = server.Execute("batch", new JObject
                    {
                        ["operations"] = operations,
                        ["transactional"] = false
                    });
                    exec = response.JsonResponse["result"];
                    Assert.IsTrue(exec["results"][0]["success"]?.ToObject<bool>() ?? false,
                        $"transactional:false must allow delete_asset: {exec["results"][0]["error"]}");
                    Assert.IsFalse(exec["results"][0]["revertible"]?.ToObject<bool>() ?? true,
                        "the op must report revertible:false");
                    Assert.IsNull(AssetDatabase.LoadMainAssetAtPath(assetPath), "the asset must be deleted");
                }
            }
            finally
            {
                if (AssetDatabase.LoadMainAssetAtPath(assetPath) != null)
                    AssetDatabase.DeleteAsset(assetPath);
            }
        }

        [Test]
        public void Batch_OpenScene_AlwaysRejected_EvenNonTransactional()
        {
            // C2: open_scene/create_scene CLEAR the Editor Undo stack, destroying the batch's ability
            // to revert anything before them — they are rejected regardless of the transactional flag.
            using (var server = new PipelineTestServer())
            {
                var operations = new JArray
                {
                    Op("open_scene", new JObject { ["path"] = "Assets/Nope.unity" }),
                };

                var response = server.Execute("batch", new JObject
                {
                    ["operations"] = operations,
                    ["dry_run"] = true
                });
                var dry = response.JsonResponse["result"];
                StringAssert.Contains("not_batchable", dry["results"][0]["error"]?.ToString());
                StringAssert.Contains("Undo stack", dry["results"][0]["error"]?.ToString());

                response = server.Execute("batch", new JObject
                {
                    ["operations"] = operations,
                    ["transactional"] = false
                });
                var exec = response.JsonResponse["result"];
                Assert.IsFalse(exec["results"][0]["success"]?.ToObject<bool>() ?? true);
                StringAssert.Contains("not_batchable", exec["results"][0]["error"]?.ToString());
            }
        }

        [Test]
        public void Batch_FirstOpPartialMutation_IsRolledBack()
        {
            // I1: an op that mutates and THEN throws leaves partial Undo-registered state even when
            // it is the first (and only) op — the transactional rollback must run with applied == 0.
            // set_transform applies 'position' before it parses the invalid 'rotation'.
            using (var server = new PipelineTestServer())
            {
                var go = Track(new GameObject("BatchPartial_Target"));
                go.transform.localPosition = Vector3.zero;

                var operations = new JArray
                {
                    Op("set_transform", new JObject
                    {
                        // Version-stable id: GetInstanceID() is obsolete-as-error from 6000.4.
                        ["target"] = PipelineUtils.GetObjectId(go).RawValue,
                        ["position"] = new JArray(5f, 6f, 7f),
                        ["rotation"] = new JArray(1f, 2f), // invalid: 2 components -> throws after position applied
                    }),
                };

                LogAssert.Expect(LogType.Error, new Regex("set_transform' failed: 'rotation' must have exactly 3 components"));

                var response = server.Execute("batch", new JObject { ["operations"] = operations });
                Assert.IsTrue(response.IsSuccess, $"batch should return HTTP success: {response.RawResponse}");

                var batch = response.JsonResponse["result"];
                Assert.AreEqual(0, batch["applied"]?.ToObject<int>(), "the only op failed");
                Assert.IsTrue(batch["reverted"]?.ToObject<bool>() ?? false,
                    "a transactional failure must revert even when applied == 0");
                Assert.AreEqual(0f, go.transform.localPosition.magnitude, 0.0001f,
                    "the failing op's partial position change must be reverted");
            }
        }

        [Test]
        public void Batch_TimeBudgetExceeded_SkipsRemainingOps_AndRevertsTransactional()
        {
            // I2: the cooperative time budget is checked before each op after the first. Budget 0 is
            // exhausted immediately after op 0, so ops 1..n are skipped and the transactional batch
            // rolls back with a batch-level error.
            using (var server = new PipelineTestServer())
            {
                var operations = new JArray
                {
                    Op("create_gameobject", new JObject { ["name"] = "BatchBudget_A" }),
                    Op("create_gameobject", new JObject { ["name"] = "BatchBudget_B" }),
                    Op("create_gameobject", new JObject { ["name"] = "BatchBudget_C" }),
                };

                var response = server.Execute("batch", new JObject
                {
                    ["operations"] = operations,
                    ["time_budget_ms"] = 0
                });
                Assert.IsTrue(response.IsSuccess, $"batch should return HTTP success: {response.RawResponse}");

                var batch = response.JsonResponse["result"];
                StringAssert.Contains("batch time budget exceeded", batch["error"]?.ToString());
                Assert.AreEqual(1, batch["applied"]?.ToObject<int>(), "only op 0 runs on a zero budget");
                Assert.IsTrue(batch["reverted"]?.ToObject<bool>() ?? false, "budget abort is a transactional failure");

                var results = batch["results"] as JArray;
                Assert.AreEqual(3, results.Count);
                Assert.IsTrue(results[0]["success"]?.ToObject<bool>() ?? false, "op 0 always gets to run");
                Assert.IsTrue(results[1]["skipped"]?.ToObject<bool>() ?? false, "op 1 must be skipped");
                Assert.IsTrue(results[2]["skipped"]?.ToObject<bool>() ?? false, "op 2 must be skipped");

                Assert.AreEqual(0, GameObjectCommands.FindGameObjects(name: "BatchBudget_A").Count,
                    "op 0 must be reverted by the budget-abort rollback");
                Assert.AreEqual(0, GameObjectCommands.FindGameObjects(name: "BatchBudget_B").Count);
            }
        }

        [Test]
        public void Batch_ReferenceToFailedOp_ErrorsClearly()
        {
            // I3: under on_error=continue an op can fail without stopping the batch; a later $ref
            // into the failed op must error explicitly instead of silently resolving to null.
            using (var server = new PipelineTestServer())
            {
                var operations = new JArray
                {
                    Op("add_component", new JObject { ["target"] = "/NoSuchObjectXYZ_00", ["type"] = "Rigidbody" }), // fails
                    Op("rename_gameobject", new JObject { ["target"] = "$0.instanceId", ["name"] = "Renamed" }),
                };

                LogAssert.Expect(LogType.Error, new Regex("add_component' failed:"));

                var response = server.Execute("batch", new JObject
                {
                    ["operations"] = operations,
                    ["on_error"] = "continue"
                });
                Assert.IsTrue(response.IsSuccess, $"batch should return HTTP success: {response.RawResponse}");

                var results = response.JsonResponse["result"]["results"] as JArray;
                Assert.IsFalse(results[0]["success"]?.ToObject<bool>() ?? true, "op 0 must fail");
                Assert.IsFalse(results[1]["success"]?.ToObject<bool>() ?? true, "the referencing op must fail");
                var error = results[1]["error"]?.ToString();
                StringAssert.Contains("$0.instanceId", error, "the error should name the offending reference");
                StringAssert.Contains("failed; its result cannot be referenced", error,
                    "and say the referenced op failed");
            }
        }

        [Test]
        public void Resolver_ReferenceToVoidResult_Errors_WholeValueAndPath()
        {
            // I3: a SUCCEEDED op with a null result (void command) is distinct from a failed op —
            // referencing it errors with "returned no result", for whole-value and path refs alike.
            var operations = new List<BatchOperationInput>
            {
                new BatchOperationInput { Command = "noop_a" },
                new BatchOperationInput { Command = "noop_b" },
            };
            var outcomes = new List<BatchOperationResult>
            {
                new BatchOperationResult { Command = "noop_a", Success = true },
                new BatchOperationResult { Command = "noop_b" },
            };
            var results = new JToken[] { JValue.CreateNull(), null };
            var idToIndex = new Dictionary<string, int>();

            var wholeRef = new JObject { ["value"] = "$0" };
            var ex = Assert.Throws<ArgumentException>(() =>
                BatchReferenceResolver.Resolve(wholeRef, 1, operations, idToIndex, results, outcomes));
            StringAssert.Contains("returned no result", ex.Message);

            var pathRef = new JObject { ["value"] = "$0.instanceId" };
            ex = Assert.Throws<ArgumentException>(() =>
                BatchReferenceResolver.Resolve(pathRef, 1, operations, idToIndex, results, outcomes));
            StringAssert.Contains("returned no result", ex.Message);
        }

        [Test]
        public void Resolver_ReferenceToFailedOp_Errors_WholeValueAndPath()
        {
            // I3: whole-value refs into a FAILED op must error just like path refs (the end-to-end
            // test above covers the path form; this pins the whole-value form).
            var operations = new List<BatchOperationInput>
            {
                new BatchOperationInput { Command = "noop_a" },
                new BatchOperationInput { Command = "noop_b" },
            };
            var outcomes = new List<BatchOperationResult>
            {
                new BatchOperationResult { Command = "noop_a", Success = false, Error = "boom" },
                new BatchOperationResult { Command = "noop_b" },
            };
            var results = new JToken[] { null, null };
            var idToIndex = new Dictionary<string, int>();

            var wholeRef = new JObject { ["value"] = "$0" };
            var ex = Assert.Throws<ArgumentException>(() =>
                BatchReferenceResolver.Resolve(wholeRef, 1, operations, idToIndex, results, outcomes));
            StringAssert.Contains("failed; its result cannot be referenced", ex.Message);
        }

        [Test]
        public void Batch_RuntimeOnlyCommand_NotBatchable()
        {
            // I5: runtime-only commands (Player server surface) are discoverable via the registry but
            // must not be dispatchable through an editor-server batch.
            using (var server = new PipelineTestServer())
            {
                var response = server.Execute("batch", new JObject
                {
                    ["operations"] = new JArray { Op("set_timescale", new JObject { ["scale"] = 0.5f }) },
                    ["dry_run"] = true
                });

                var dry = response.JsonResponse["result"];
                Assert.IsFalse(dry["valid"]?.ToObject<bool>() ?? true);
                var error = dry["results"][0]["error"]?.ToString();
                StringAssert.Contains("not_batchable", error);
                StringAssert.Contains("runtime-only", error);
            }
        }

        [Test]
        public void Batch_MenuCommand_NotBatchable()
        {
            // I6: menu items can open modal dialogs, which would wedge an unattended batch.
            using (var server = new PipelineTestServer())
            {
                var response = server.Execute("batch", new JObject
                {
                    ["operations"] = new JArray { Op("menu", new JObject { ["path"] = "File/Save" }) },
                    ["dry_run"] = true
                });

                var dry = response.JsonResponse["result"];
                Assert.IsFalse(dry["valid"]?.ToObject<bool>() ?? true);
                StringAssert.Contains("not_batchable", dry["results"][0]["error"]?.ToString());
            }
        }

        [Test]
        public void Batch_NumericOpId_Rejected()
        {
            // M3: a purely numeric id would be ambiguous with a 0-based index selector in "$<id-or-index>".
            using (var server = new PipelineTestServer())
            {
                var operations = new JArray
                {
                    Op("create_gameobject", new JObject { ["name"] = "BatchId_A" }, id: "0"),
                };

                LogAssert.Expect(LogType.Error, new Regex("ids must match"));

                var response = server.Execute("batch", new JObject
                {
                    ["operations"] = operations,
                    ["dry_run"] = true
                });

                Assert.IsFalse(response.IsSuccess, "a numeric op id must be rejected outright");
                StringAssert.Contains("ids must match", response.RawResponse);
            }
        }

        [Test]
        public void Batch_DollarDollar_EscapesToLiteralDollar()
        {
            // M7: "$$..." escapes a literal '$' — the op receives "$literal", not a reference.
            using (var server = new PipelineTestServer())
            {
                var operations = new JArray
                {
                    Op("create_gameobject", new JObject { ["name"] = "$$literal" }),
                };

                var response = server.Execute("batch", new JObject { ["operations"] = operations });
                Assert.IsTrue(response.IsSuccess, $"batch should return HTTP success: {response.RawResponse}");

                var results = response.JsonResponse["result"]["results"] as JArray;
                var go = ResolveGameObject(results[0]);
                Assert.IsNotNull(go, "op 0's GameObject should be resolvable");
                Assert.AreEqual("$literal", go.name, "\"$$literal\" must unescape to the literal \"$literal\"");
            }
        }

        [Test]
        public void Batch_IdBasedReference_Resolves()
        {
            // M7: references can select the target op by its id, not only by index.
            using (var server = new PipelineTestServer())
            {
                var operations = new JArray
                {
                    Op("create_gameobject", new JObject { ["name"] = "BatchIdRef_Root" }, id: "root"),
                    Op("add_component", new JObject { ["target"] = "$root.instanceId", ["type"] = "Rigidbody" }),
                };

                var response = server.Execute("batch", new JObject { ["operations"] = operations });
                Assert.IsTrue(response.IsSuccess, $"batch should return HTTP success: {response.RawResponse}");

                var batch = response.JsonResponse["result"];
                Assert.AreEqual(2, batch["applied"]?.ToObject<int>(),
                    $"both ops should apply: {batch["results"]}");

                var root = ResolveGameObject((batch["results"] as JArray)[0]);
                Assert.IsNotNull(root);
                Assert.IsNotNull(root.GetComponent<Rigidbody>(), "$root.instanceId must resolve by op id");
            }
        }

        [Test]
        public void Batch_ResultFields_ProjectsOpResult()
        {
            // M7: result_fields keeps only the requested result fields for the op (context economy).
            using (var server = new PipelineTestServer())
            {
                var operations = new JArray
                {
                    Op("create_gameobject", new JObject { ["name"] = "BatchProject_A" }),
                };

                var response = server.Execute("batch", new JObject
                {
                    ["operations"] = operations,
                    ["result_fields"] = new JObject { ["0"] = new JArray("instanceId") }
                });
                Assert.IsTrue(response.IsSuccess, $"batch should return HTTP success: {response.RawResponse}");

                var results = response.JsonResponse["result"]["results"] as JArray;
                var projected = results[0]["result"] as JObject;
                Assert.IsNotNull(projected, "the projected result should be an object");
                Assert.IsNotNull(projected["instanceId"], "the requested field must be kept");
                Assert.IsNull(projected["hierarchyPath"], "unrequested fields must be dropped");
                Assert.IsNull(projected["globalId"], "unrequested fields must be dropped");

                // Cleanup: the projection kept instanceId, so the object is still resolvable.
                Assert.IsNotNull(ResolveGameObject(results[0]));
            }
        }

        [Test]
        public void Batch_OversizedOpResult_Truncated_ButReferencesStillResolve()
        {
            // M7: an op result over the per-op cap is replaced by a truncation marker in the envelope,
            // but later $refs resolve against the FULL (untruncated) result.
            const string bigPath = "Assets/BatchTests_BigFile.txt";
            File.WriteAllText(bigPath, new string('x', 20000)); // > 16 KiB serialized
            try
            {
                using (var server = new PipelineTestServer())
                {
                    var operations = new JArray
                    {
                        Op("read_text_file", new JObject { ["path"] = bigPath }),
                        // References a scalar of the oversized result — must still resolve.
                        Op("create_gameobject", new JObject { ["name"] = "$0.assetPath" }),
                    };

                    var response = server.Execute("batch", new JObject { ["operations"] = operations });
                    Assert.IsTrue(response.IsSuccess, $"batch should return HTTP success: {response.RawResponse}");

                    var results = response.JsonResponse["result"]["results"] as JArray;
                    Assert.IsTrue(results[0]["resultTruncated"]?.ToObject<bool>() ?? false,
                        "the oversized read_text_file result must be truncated");
                    Assert.IsTrue(results[0]["result"]?["resultTruncated"]?.ToObject<bool>() ?? false,
                        "the result must be replaced by the truncation marker");

                    Assert.IsTrue(results[1]["success"]?.ToObject<bool>() ?? false,
                        $"the referencing op must still succeed: {results[1]["error"]}");
                    var go = ResolveGameObject(results[1]);
                    Assert.IsNotNull(go);
                    Assert.AreEqual(bigPath, go.name, "$0.assetPath must resolve against the untruncated result");
                }
            }
            finally
            {
                if (File.Exists(bigPath))
                    File.Delete(bigPath);
                if (File.Exists(bigPath + ".meta"))
                    File.Delete(bigPath + ".meta");
            }
        }

        [Test]
        public void Batch_NestedBatch_Rejected()
        {
            // M7: batch-in-batch is excluded (recursion/auditing hazard).
            using (var server = new PipelineTestServer())
            {
                var response = server.Execute("batch", new JObject
                {
                    ["operations"] = new JArray { Op("batch", new JObject { ["operations"] = new JArray() }) },
                    ["dry_run"] = true
                });

                var dry = response.JsonResponse["result"];
                Assert.IsFalse(dry["valid"]?.ToObject<bool>() ?? true);
                StringAssert.Contains("not_batchable", dry["results"][0]["error"]?.ToString());
            }
        }

        [Test]
        public void Batch_NonTransactional_Abort_KeepsAppliedOps_SkipsRest()
        {
            // M7: transactional:false + on_error=abort stops at the failing op but keeps what was
            // already applied (no rollback), and marks the rest skipped.
            using (var server = new PipelineTestServer())
            {
                var operations = new JArray
                {
                    Op("create_gameobject", new JObject { ["name"] = "BatchNoTx_A" }),
                    Op("add_component", new JObject { ["target"] = "$0.instanceId", ["type"] = "NoSuchTypeXYZ" }), // fails
                    Op("create_gameobject", new JObject { ["name"] = "BatchNoTx_C" }),
                };

                LogAssert.Expect(LogType.Error, new Regex("add_component' failed: Could not resolve component type 'NoSuchTypeXYZ'"));

                var response = server.Execute("batch", new JObject
                {
                    ["operations"] = operations,
                    ["transactional"] = false
                });
                Assert.IsTrue(response.IsSuccess, $"batch should return HTTP success: {response.RawResponse}");

                var batch = response.JsonResponse["result"];
                Assert.IsFalse(batch["reverted"]?.ToObject<bool>() ?? true, "transactional:false must not revert");
                Assert.AreEqual(1, batch["applied"]?.ToObject<int>());

                var results = batch["results"] as JArray;
                Assert.IsTrue(results[0]["success"]?.ToObject<bool>() ?? false);
                Assert.IsFalse(results[1]["success"]?.ToObject<bool>() ?? true, "op 1 must fail");
                Assert.IsTrue(results[2]["skipped"]?.ToObject<bool>() ?? false, "op 2 must be skipped (abort)");

                Assert.IsNotNull(ResolveGameObject(results[0]), "op 0's object must survive (no rollback)");
                Assert.AreEqual(0, GameObjectCommands.FindGameObjects(name: "BatchNoTx_C").Count,
                    "op 2 never ran");
            }
        }

        [Test]
        public void Batch_InvalidResultFieldsPath_DoesNotFailTheAppliedOp()
        {
            // Review finding: a malformed result_fields JSONPath threw AFTER the op had mutated
            // state, and the outer catch flipped the op's Success to false — rolling back a
            // succeeded op under on_error=abort. The projection must report the bad path instead.
            using (var server = new PipelineTestServer())
            {
                var operations = new JArray { Op("create_gameobject", new JObject { ["name"] = "BatchProj_BadPath" }) };
                var response = server.Execute("batch", new JObject
                {
                    ["operations"] = operations,
                    ["result_fields"] = new JObject { ["0"] = new JArray("foo[") }
                });
                Assert.IsTrue(response.IsSuccess, $"batch should return HTTP success: {response.RawResponse}");

                var batch = response.JsonResponse["result"];
                var results = batch["results"] as JArray;
                Assert.IsTrue(results[0]["success"]?.ToObject<bool>() ?? false,
                    "a malformed projection path must not flip an already-applied op to failure");
                Assert.IsFalse(batch["reverted"]?.ToObject<bool>() ?? true,
                    "and must not trigger a rollback of the succeeded op");
                StringAssert.Contains("foo[", results[0]["result"]?["invalidResultFields"]?[0]?.ToString(),
                    "the bad path is reported inside the projection");

                var survivors = GameObjectCommands.FindGameObjects(name: "BatchProj_BadPath");
                Assert.AreEqual(1, survivors.Count, "the op's mutation must survive");
                Track(GameObject.Find("BatchProj_BadPath"));
            }
        }

        [Test]
        public void Batch_TransactionalRevert_LeavesUndoStackClean()
        {
            // Review finding: after Undo.RevertAllDownToGroup discarded the batch group, the
            // enclosing AuthoringUndoScope still collapsed that stale group id on dispose. The
            // scope is now canceled after a revert; the contract this pins: the next PerformUndo
            // must undo the USER's previous operation, not be absorbed by a stray batch group.
            using (var server = new PipelineTestServer())
            {
                Undo.IncrementCurrentGroup();
                var marker = Track(new GameObject("BatchUndoStack_Marker"));
                Undo.RegisterCreatedObjectUndo(marker, "create marker");
                Undo.IncrementCurrentGroup();

                var operations = new JArray
                {
                    Op("create_gameobject", new JObject { ["name"] = "BatchUndoStack_Tx" }),
                    Op("add_component", new JObject { ["target"] = "$0.instanceId", ["type"] = "NoSuchTypeXYZ" }),
                };
                LogAssert.Expect(LogType.Error, new Regex("add_component' failed: Could not resolve component type 'NoSuchTypeXYZ'"));
                var response = server.Execute("batch", new JObject { ["operations"] = operations });
                Assert.IsTrue(response.IsSuccess, $"batch should return HTTP success: {response.RawResponse}");
                Assert.IsTrue(response.JsonResponse["result"]["reverted"]?.ToObject<bool>() ?? false,
                    "precondition: the transactional batch reverted");

                Undo.PerformUndo();
                Assert.IsTrue(marker == null,
                    "PerformUndo after a reverted batch must undo the previous user operation " +
                    "(the marker creation) — a surviving marker means a stray batch group absorbed it");
            }
        }

        [Test]
        public void ProjectResult_MeasuresUtf8Bytes_NotUtf16Chars()
        {
            // Review finding: the per-op cap compared UTF-16 char counts while the wire is UTF-8 —
            // a CJK payload at ~12k chars is ~36 KB on the wire and sailed under the 16 KiB cap.
            var op = new BatchOperationInput { Command = "noop" };
            var opResult = new BatchOperationResult();
            var budget = int.MaxValue; // isolate the per-op cap from the aggregate budget
            var cjk = new string('\u597D', 12_000); // 12k chars, ~36 KB UTF-8

            var projected = BatchCommand.ProjectResult(cjk, JToken.FromObject(cjk), op, 0, null, opResult, ref budget);

            Assert.IsTrue(opResult.ResultTruncated == true,
                "a payload under the char count but over the UTF-8 byte cap must be truncated");
            var marker = (JObject)JToken.FromObject(projected);
            Assert.Greater(marker["length"]?.ToObject<int>() ?? 0, 16 * 1024, "length reports wire bytes");
        }

        [Test]
        public void ProjectResult_AggregateBudget_ElidesLaterResults()
        {
            // Review finding: nothing bounded the SUM of per-op results (200 ops x 16 KiB each is a
            // ~3.2 MB reply). Once the aggregate budget is exhausted, later results become markers.
            var op = new BatchOperationInput { Command = "noop" };
            var budget = BatchCommand.MaxBatchResultBytes;
            var big = new string('a', 15_000); // under the per-op cap; ~17 of these exhaust the budget

            object last = null;
            BatchOperationResult lastResult = null;
            var truncatedAt = -1;
            for (var i = 0; i < 30; i++)
            {
                lastResult = new BatchOperationResult();
                last = BatchCommand.ProjectResult(big, JToken.FromObject(big), op, i, null, lastResult, ref budget);
                if (lastResult.ResultTruncated == true) { truncatedAt = i; break; }
            }

            Assert.GreaterOrEqual(truncatedAt, 2, "several results must fit before the budget trips");
            Assert.AreNotEqual(-1, truncatedAt, "the aggregate budget must eventually trip");
            StringAssert.Contains("aggregate result budget", ((JObject)JToken.FromObject(last))["error"]?.ToString(),
                "the marker explains the aggregate elision");
        }
    }
}