import test from "node:test";
import assert from "node:assert/strict";
import { parseActorExecutionResultFromModelOutput } from "../src/agents/provider-executor.js";

test("parseActorExecutionResultFromModelOutput parses strict JSON payload", () => {
  const parsed = parseActorExecutionResultFromModelOutput({
    rawText: JSON.stringify({
      status: "validation_fail",
      payload: {
        summary: "missing test",
      },
      stateFlags: {
        needs_fix: true,
      },
      stateMetadata: {
        stage: "qa",
      },
      events: [
        {
          type: "validation_failed",
          payload: {
            summary: "failed",
          },
        },
      ],
      failureKind: "soft",
      failureCode: "missing_test",
    }),
  });

  assert.equal(parsed.status, "validation_fail");
  assert.equal(parsed.payload?.summary, "missing test");
  assert.equal(parsed.stateFlags?.needs_fix, true);
  assert.equal(parsed.stateMetadata?.stage, "qa");
  assert.equal(parsed.events?.[0]?.type, "validation_failed");
  assert.equal(parsed.failureKind, "soft");
  assert.equal(parsed.failureCode, "missing_test");
});

test("parseActorExecutionResultFromModelOutput parses fenced JSON", () => {
  const parsed = parseActorExecutionResultFromModelOutput({
    rawText: [
      "Here is the result",
      "```json",
      JSON.stringify({
        status: "success",
        payload: {
          code: "done",
        },
      }),
      "```",
    ].join("\n"),
  });

  assert.equal(parsed.status, "success");
  assert.equal(parsed.payload?.code, "done");
});

test("parseActorExecutionResultFromModelOutput falls back when response is not JSON", () => {
  const parsed = parseActorExecutionResultFromModelOutput({
    rawText: "Implemented update successfully.",
  });

  assert.equal(parsed.status, "success");
  assert.equal(parsed.payload?.assistantResponse, "Implemented update successfully.");
});

test("parseActorExecutionResultFromModelOutput preserves status when optional fields are malformed", () => {
  const parsed = parseActorExecutionResultFromModelOutput({
    rawText: JSON.stringify({
      status: "failure",
      payload: {
        reason: "hard failure",
      },
      stateFlags: {
        retryable: false,
        invalid_flag: "nope",
      },
      stateMetadata: "not-an-object",
      events: [
        {
          type: "validation_failed",
          payload: {
            summary: "failed",
          },
        },
        {
          type: 123,
        },
      ],
      failureKind: "not-valid",
      failureCode: 403,
    }),
  });

  assert.equal(parsed.status, "failure");
  assert.equal(parsed.payload?.reason, "hard failure");
  assert.equal(parsed.stateFlags?.retryable, false);
  assert.equal(parsed.stateFlags && "invalid_flag" in parsed.stateFlags, false);
  assert.equal(parsed.stateMetadata, undefined);
  assert.equal(parsed.events?.length, 1);
  assert.equal(parsed.events?.[0]?.type, "validation_failed");
  assert.equal(parsed.failureKind, undefined);
  assert.equal(parsed.failureCode, undefined);
});