import { API_VERSION_PATH } from "./constants.js";

import { ApiError, type CliError } from "./errors.js";

import type { AuthenticatedApi } from "./repository-client.js";

import { asRecord, asRows, asText, makeTrackerRequest } from "./tracker-request.js";

import { asNumber, asRecord, asRows, asText, makeTrackerRequest } from "./tracker-request.js";

export interface BoxRecord {

  readonly box_id: string;

  readonly runId: string;

}

export interface BoxRunOutput {

  readonly run_id: string;

  readonly output: string;

  /** The offset to pass to the next read to resume where this one stopped. */

  readonly next_offset: number;

  /** True when the box dropped bytes before the requested offset. */

  readonly truncated: boolean;

}

export interface BoxRunOutputInput extends AuthenticatedApi {

  readonly conversationId?: string;

  readonly boxId: string;

  readonly startRun: (input: BoxRunCreateInput) => Effect.Effect<BoxRunRecord, CliError>;

  readonly listRuns: (input: BoxRunListInput) => Effect.Effect<ReadonlyArray<BoxRunRecord>, CliError>;

  readonly viewRun: (input: BoxRunViewInput) => Effect.Effect<BoxRunRecord, CliError>;

  readonly runOutput: (input: BoxRunOutputInput) => Effect.Effect<{ run_id: string; output: string }, CliError>;

  readonly runOutput: (input: BoxRunOutputInput) => Effect.Effect<BoxRunOutput, CliError>;

  readonly cancelRun: (input: BoxRunCancelInput) => Effect.Effect<BoxRunRecord, CliError>;

  readonly fanout: (input: BoxFanoutInput) => Effect.Effect<BoxFanoutPlan, CliError>;

  readonly viewFanout: (input: BoxFanoutViewInput) => Effect.Effect<BoxFanoutPlan, CliError>;

    const transport = yield* ApiTransport;

    const request = makeTrackerRequest(transport);

    // No deployed endpoint resolves the account's conversation yet. `GET

    // /api/v1/user` answers the forge identity and never carries a

    // `conversation_id`, and it sits behind `forge:write` rather than the

    // `box:control` scope a box token carries, so this probe fails twice over

    // against production. The probe stays because a deployment that grows the

    // field should start working without a client release, but the refusal

    // now names the flag that actually gets the caller unblocked instead of

    // claiming the account has no conversation.

    const resolveConversationId = Effect.fn("BoxClient.resolveConversationId")(function* (

      input: AuthenticatedApi,

    ) {

      return yield* new ApiError({

        operation: "resolve user conversation",

        status: response.status,

        message: "Could not find an active conversation for this account.",

        message:

          "This deployment does not report a conversation for the account. " +

          "Pass --conversation <conversation_id> to name the conversation to use.",

      });

    });

        path: `${API_VERSION_PATH}/conversations/${encodeURIComponent(convId)}/boxes/${encodeURIComponent(input.boxId)}/runs/${encodeURIComponent(input.runId)}/output${query}`,

        acceptedStatuses: [200],

      });

      // The server nests the read under `output`: the envelope is

      // `{"run_id": …, "output": {"output": …, "next_offset": …, "truncated": …}}`,

      // so reading the envelope's `output` as text yielded an empty string and

      // `box runs output` printed nothing. Read the nested record, and fall

      // back to a bare string for any older deployment still answering flat.

      const res = asRecord(body);

      const nested = asRecord(res["output"]);

      const flat = asText(res["output"]);

      return {

        run_id: asText(res["run_id"]) ?? input.runId,

        output: asText(res["output"]) ?? "",

        output: flat ?? asText(nested["output"]) ?? "",

        next_offset: asNumber(nested["next_offset"]) ?? input.offset ?? 0,

        truncated: nested["truncated"] === true,

      };

    });

        yield* output.write(

          {

            value: result,

            human: [result.output],

            human: [

              // The box keeps a bounded log, so a read that starts before the

              // retained window silently begins mid-stream. Say so rather than

              // letting the gap read as the run's first line.

              ...(result.truncated ? ["[EARLIER OUTPUT DROPPED BY THE BOX]"] : []),

              result.output.trimEnd(),

            ],

          },

          outputMode(flags.json),

        );

    const human = written[0]!.document.human;

    expect(human.some((line) => line.includes("Stopped Box bx_test123"))).toBe(true);

  });

  // The server nests the read one level down, under `output.output`. Reading

  // the envelope's `output` as text made `box runs output` print an empty

  // line against production while every record was durable server-side.

  it("renders the nested run output envelope the server sends", async () => {

    const { layer, written } = harness((req) => {

      if (req.path === "/api/v1/user") {

        return Effect.succeed({

          status: 200,

          body: { conversation_id: "conv-123" },

        });

      }

      if (req.path === "/api/v1/conversations/conv-123/boxes/bx_test123/runs/run-9/output") {

        return Effect.succeed({

          status: 200,

          body: {

            run_id: "run-9",

            output: {

              output: "cloned openagents.com at 40dbd832\n",

              offset: 0,

              next_offset: 34,

              output_base_offset: 0,

              truncated: false,

            },

          },

        });

      }

      return Effect.succeed({ status: 404, body: {} });

    });

    await Effect.runPromise(

      runCliWith(["box", "runs", "output", "bx_test123", "run-9"]).pipe(Effect.provide(layer)),

    );

    expect(written.length).toBe(1);

    const human = written[0]!.document.human;

    expect(human.some((line) => line.includes("cloned openagents.com at 40dbd832"))).toBe(true);

    expect(human.some((line) => line.includes("EARLIER OUTPUT DROPPED"))).toBe(false);

    expect(written[0]!.document.value).toMatchObject({

      run_id: "run-9",

      next_offset: 34,

      truncated: false,

    });

  });

  it("reports output the box dropped before the requested offset", async () => {

    const { layer, written } = harness((req) => {

      if (req.path === "/api/v1/user") {

        return Effect.succeed({

          status: 200,

          body: { conversation_id: "conv-123" },

        });

      }

      if (

        req.path === "/api/v1/conversations/conv-123/boxes/bx_test123/runs/run-9/output?offset=10"

      ) {

        return Effect.succeed({

          status: 200,

          body: {

            run_id: "run-9",

            output: {

              output: "resumed\n",

              offset: 10,

              next_offset: 4108,

              output_base_offset: 4100,

              truncated: true,

            },

          },

        });

      }

      return Effect.succeed({ status: 404, body: {} });

    });

    await Effect.runPromise(

      runCliWith([

        "box",

        "runs",

        "output",

        "bx_test123",

        "run-9",

        "--offset",

        "10",

      ]).pipe(Effect.provide(layer)),

    );

    const human = written[0]!.document.human;

    expect(human.some((line) => line.includes("EARLIER OUTPUT DROPPED"))).toBe(true);

    expect(human.some((line) => line.includes("resumed"))).toBe(true);

  });

  // Kept so a deployment still answering the older flat shape keeps working

  // while the fix rolls out.

  it("still renders a flat run output body", async () => {

    const { layer, written } = harness((req) => {

      if (req.path === "/api/v1/user") {

        return Effect.succeed({

          status: 200,

          body: { conversation_id: "conv-123" },

        });

      }

      if (req.path === "/api/v1/conversations/conv-123/boxes/bx_test123/runs/run-9/output") {

        return Effect.succeed({

          status: 200,

          body: { run_id: "run-9", output: "flat body output\n" },

        });

      }

      return Effect.succeed({ status: 404, body: {} });

    });

    await Effect.runPromise(

      runCliWith(["box", "runs", "output", "bx_test123", "run-9"]).pipe(Effect.provide(layer)),

    );

    const human = written[0]!.document.human;

    expect(human.some((line) => line.includes("flat body output"))).toBe(true);

  });

  // Production's `GET /api/v1/user` answers the forge identity and no

  // conversation, so the refusal has to point at the flag that works rather

  // than at an account state the caller cannot change.

  it("names --conversation when the deployment reports no conversation", async () => {

    const { layer } = harness((req) => {

      if (req.path === "/api/v1/user") {

        return Effect.succeed({

          status: 200,

          body: { id: 1, login: "operator", namespaces: [] },

        });

      }

      return Effect.succeed({ status: 404, body: {} });

    });

    // `Effect.flip` turns the refusal into the success value, so a run that

    // wrongly succeeded rejects the promise and fails the test.

    const failure = await Effect.runPromise(

      runCliWith(["box", "list"]).pipe(Effect.provide(layer), Effect.flip),

    );

    expect(JSON.stringify(failure)).toContain("--conversation");

  });

  it("skips the conversation probe when --conversation is given", async () => {

    const seen: Array<string> = [];

    const { layer, written } = harness((req) => {

      seen.push(req.path);

      if (req.path === "/api/v1/conversations/conv-explicit/boxes") {

        return Effect.succeed({ status: 200, body: { boxes: [] } });

      }

      return Effect.succeed({ status: 404, body: {} });

    });

    await Effect.runPromise(

      runCliWith(["box", "list", "--conversation", "conv-explicit"]).pipe(Effect.provide(layer)),

    );

    expect(seen).toEqual(["/api/v1/conversations/conv-explicit/boxes"]);

    expect(written.length).toBe(1);

  });

});