import fs from "node:fs/promises";
import path from "node:path";
import { describe, expect, it, vi } from "vitest";
import { setReplyPayloadMetadata, type ReplyPayload } from "../../auto-reply/reply-payload.js";
import {
  loadTranscriptEvents,
  replaceSessionEntry,
} from "../../config/sessions/session-accessor.js";
import {
  readTranscriptEventId,
  readTranscriptEventMessage,
} from "../../config/sessions/session-accessor.sqlite-read.js";
import {
  MANAGED_OUTGOING_IMAGE_ARTIFACT_ID_PREFIX,
  resolveManagedOutgoingMediaArtifactDownload,
} from "../../gateway/managed-image-attachments.js";
import { listManagedImageRecordEntries } from "../../gateway/managed-image-record-store.js";
import {
  beginSessionWorkAdmission,
  getActiveSessionLifecycleMutationCount,
} from "../../sessions/session-lifecycle-admission.js";
import { onSessionTranscriptUpdate } from "../../sessions/transcript-events.js";
import { readAssistantDisplayContent } from "../../shared/assistant-display-content.js";
import { openOpenClawStateDatabase } from "../../state/openclaw-state-db.js";
import {
  withOpenClawTestState,
  type OpenClawTestState,
} from "../../test-utils/openclaw-test-state.js";
import { resolveCronDeliveryPlan } from "../delivery-plan.js";
import { makeCronJob } from "../delivery.test-helpers.js";
import { createCliDeps } from "../isolated-agent.delivery.test-helpers.js";
import { commitCurrentSessionCronCompletion } from "./current-session-completion.js";
import type { DispatchCronDeliveryParams } from "./delivery-dispatch-types.js";
import { dispatchCronDelivery } from "./delivery-dispatch.js";

const PNG = Buffer.from(
  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAusB9Y9ZQmcAAAAASUVORK5CYII=",
  "base64",
);

async function createCompletionFixture(state: OpenClawTestState) {
  const sessionKey = "agent:main:webchat:direct:report";
  const sessionId = "report-session";
  const scope = {
    agentId: "main",
    sessionKey,
    sessionId,
    storePath: path.join(state.stateDir, "agents", "main", "sessions", "sessions.json"),
  };
  const generation = { sessionId, lifecycleRevision: "report-generation" };
  await replaceSessionEntry(scope, { ...generation, updatedAt: 1 });
  await fs.mkdir(state.workspaceDir, { recursive: true });
  const imagePath = path.join(state.workspaceDir, "report.png");
  await fs.writeFile(imagePath, PNG);
  const cfg = {
    agents: { entries: { main: { workspace: state.workspaceDir } } },
    session: { store: scope.storePath },
  };
  const payload: ReplyPayload = { text: "Example report", mediaUrl: imagePath };
  const job = makeCronJob({ id: "report-job", sessionTarget: "current", sessionKey });
  const params: DispatchCronDeliveryParams = {
    cfg,
    cfgWithAgentDefaults: cfg,
    deps: createCliDeps(),
    job,
    agentId: "main",
    agentSessionKey: "agent:main:cron:report-job",
    sourceSessionKey: sessionKey,
    sourceSessionGeneration: generation,
    runSessionKey: "agent:main:cron:report-job:run:report-run",
    sessionId: "report-run",
    lifecycleRevision: "run-generation",
    sessionUpdatedAt: 1000,
    runStartedAt: 1000,
    runEndedAt: 2000,
    timeoutMs: 30000,
    resolvedDelivery: { ok: false, mode: "implicit", error: new Error("No external channel") },
    deliveryPlan: resolveCronDeliveryPlan(job),
    deliveryRequested: true,
    undeliveredRunStatus: "ok",
    spawnOnlyHandoff: false,
    sourceDeliveryOutcome: {
      visibleDeliveries: [],
      verifiedMessageToolDelivery: false,
      satisfiesSourceDelivery: false,
      unverifiedMessageToolDelivery: false,
    },
    deliveryBestEffort: false,
    deliveryPayloadHasStructuredContent: true,
    deliveryPayloads: [payload],
    isAborted: () => false,
    abortReason: () => "aborted",
    withRunSession: (result) => ({ ...result, sessionId: "report-run" }),
  };
  const records = () => listManagedImageRecordEntries({ stateDir: state.stateDir, sessionKey });
  const downloads: Array<ReturnType<typeof resolveManagedOutgoingMediaArtifactDownload>> = [];
  let updates = 0;
  const unsubscribe = onSessionTranscriptUpdate((update) => {
    if (update.target.sessionId !== sessionId) {
      return;
    }
    updates += 1;
    for (const { record } of records()) {
      downloads.push(
        resolveManagedOutgoingMediaArtifactDownload({
          sessionKey,
          agentId: "main",
          stateDir: state.stateDir,
          artifactId: `${MANAGED_OUTGOING_IMAGE_ARTIFACT_ID_PREFIX}${record.attachmentId}`,
        }),
      );
    }
  });
  return {
    payload,
    params,
    scope,
    records,
    downloads,
    updates: () => updates,
    unsubscribe,
    commit: () => commitCurrentSessionCronCompletion(params),
    messages: async () =>
      (await loadTranscriptEvents(scope)).filter(
        (event) => readTranscriptEventMessage(event)?.role === "assistant",
      ),
  };
}

describe("current-session completion delivery", () => {
  it.each(["leading-token", "silent-media-caption"] as const)(
    "normalizes %s output before committing the conversation",
    async (mode) => {
      await withOpenClawTestState({ layout: "state-only" }, async (state) => {
        const fixture = await createCompletionFixture(state);
        try {
          const hasMedia = mode === "silent-media-caption";
          const text = hasMedia ? "Report complete.\nNO_REPLY" : "NO_REPLY\nReport complete.";
          fixture.params.deliveryPayloads = [
            { text, ...(hasMedia ? { mediaUrl: fixture.payload.mediaUrl } : {}) },
          ];
          fixture.params.deliveryPayloadHasStructuredContent = hasMedia;
          fixture.params.synthesizedText = text;
          fixture.params.outputText = text;
          fixture.params.summary = text;

          const delivery = await dispatchCronDelivery(fixture.params);
          expect(delivery.delivered).toBe(true);
          const messages = await fixture.messages();
          expect(messages).toHaveLength(1);
          const message = readTranscriptEventMessage(messages[0]);
          expect(message?.content).toEqual([
            { type: "text", text: hasMedia ? "report.png" : "Report complete." },
          ]);
          if (hasMedia) {
            expect(readAssistantDisplayContent(message)).toEqual([
              expect.objectContaining({ type: "image" }),
            ]);
            expect(fixture.records()).toHaveLength(1);
          }
        } finally {
          fixture.unsubscribe();
        }
      });
    },
  );

  it.each([{ to: "recipient" }, { accountId: "work" }, { threadId: 0 }])(
    "preserves the committed report and reports unresolved explicit intent %j",
    async (coordinates) => {
      await withOpenClawTestState({ layout: "state-only" }, async (state) => {
        const fixture = await createCompletionFixture(state);
        try {
          fixture.params.job.delivery = { mode: "announce", ...coordinates };
          fixture.params.deliveryPlan = resolveCronDeliveryPlan(fixture.params.job);
          fixture.params.deliveryPayloads = [{ text: "Final report" }];
          const completion = await fixture.commit();
          const messages = await fixture.messages();
          expect(messages).toHaveLength(1);
          expect(readTranscriptEventMessage(messages[0])?.content).toEqual([
            { type: "text", text: "Final report" },
          ]);
          expect(completion).toEqual({
            ok: true,
            requiresExternalDelivery: false,
            deliveryError: "No external channel",
          });
        } finally {
          fixture.unsubscribe();
        }
      });
    },
  );
});

describe("current-session completion media", () => {
  it.each(["ordinary", "promotion-failure"] as const)(
    "publishes downloadable media and replays the original message after %s",
    async (mode) => {
      await withOpenClawTestState({ layout: "state-only" }, async (state) => {
        const fixture = await createCompletionFixture(state);
        const database = openOpenClawStateDatabase({ env: state.env });
        try {
          if (mode === "promotion-failure") {
            database.db.exec(`CREATE TEMP TRIGGER fail_report_promotion
              BEFORE UPDATE OF message_id ON managed_outgoing_image_records
              BEGIN SELECT RAISE(ABORT, 'report promotion failed'); END`);
            await expect(fixture.commit()).rejects.toThrow("report promotion failed");
            expect(fixture.updates()).toBe(0);
            database.db.exec("DROP TRIGGER fail_report_promotion");
          } else {
            await expect(fixture.commit()).resolves.toMatchObject({ ok: true });
          }
          const original = await fixture.messages();
          const originalIds = fixture.records().map(({ record }) => record.attachmentId);
          expect(original).toHaveLength(1);
          await expect(fixture.commit()).resolves.toMatchObject({ ok: true });
          expect(await fixture.messages()).toEqual(original);
          expect(fixture.records().map(({ record }) => record.attachmentId)).toEqual(originalIds);
          expect(fixture.updates()).toBeGreaterThan(0);
          for (const { record } of fixture.records()) {
            expect(record).toMatchObject({
              messageId: readTranscriptEventId(original[0]),
              retentionClass: "history",
            });
            await expect(
              fs.readFile(
                path.join(
                  record.original.mediaRoot,
                  record.original.mediaSubdir,
                  record.original.mediaId,
                ),
              ),
            ).resolves.toEqual(PNG);
          }
          expect(fixture.downloads.length).toBeGreaterThan(0);
          for (const download of await Promise.all(fixture.downloads)) {
            expect(download).toMatchObject({ type: "image" });
          }
        } finally {
          database.db.exec("DROP TRIGGER IF EXISTS fail_report_promotion");
          fixture.unsubscribe();
        }
      });
    },
  );

  it("keeps structured report text in both model and display history", async () => {
    await withOpenClawTestState({ layout: "state-only" }, async (state) => {
      const fixture = await createCompletionFixture(state);
      try {
        fixture.payload.presentation = {
          blocks: [
            {
              type: "table",
              caption: "Revenue",
              headers: ["Quarter", "Revenue"],
              rows: [["Q1", 10]],
            },
          ],
        };
        await fixture.commit();
        const message = readTranscriptEventMessage((await fixture.messages())[0]);
        expect(message?.content).toEqual([
          {
            type: "text",
            text: "Example report\nRevenue (table)\n- Quarter: Q1; Revenue: 10\nreport.png",
          },
        ]);
        expect(readAssistantDisplayContent(message)).toEqual([
          { type: "text", text: "Example report\nRevenue (table)\n- Quarter: Q1; Revenue: 10" },
          expect.objectContaining({ type: "image" }),
        ]);
      } finally {
        fixture.unsubscribe();
      }
    });
  });

  it.each(["text-only", "missing-image", "media-only"] as const)(
    "preserves the completed result for %s output",
    async (mode) => {
      await withOpenClawTestState({ layout: "state-only" }, async (state) => {
        const fixture = await createCompletionFixture(state);
        try {
          if (mode === "text-only") {
            fixture.params.deliveryPayloads = [{ text: "Final report" }];
          } else if (mode === "missing-image") {
            await fs.unlink(path.join(state.workspaceDir, "report.png"));
          } else {
            fixture.payload.text = undefined;
          }
          await expect(fixture.commit()).resolves.toMatchObject({ ok: true });
          const message = readTranscriptEventMessage((await fixture.messages())[0]);
          if (mode === "media-only") {
            expect(readAssistantDisplayContent(message)).toEqual([
              expect.objectContaining({ type: "image" }),
            ]);
            expect(fixture.records()).toHaveLength(1);
          } else {
            expect(message?.content).toEqual([
              {
                type: "text",
                text: mode === "text-only" ? "Final report" : "Example report\nreport.png",
              },
            ]);
            if (mode === "missing-image") {
              expect(readAssistantDisplayContent(message)).toEqual([
                { type: "text", text: "Example report" },
                expect.objectContaining({
                  type: "attachment_error",
                  attachment: expect.objectContaining({
                    label: "report.png",
                    code: "delivery-failed",
                  }),
                }),
              ]);
            } else {
              expect(message).not.toHaveProperty("openclawDisplayContent");
            }
            expect(fixture.records()).toEqual([]);
          }
        } finally {
          fixture.unsubscribe();
        }
      });
    },
  );

  it("preserves interleaved report text, media, and spoken-payload failure metadata", async () => {
    await withOpenClawTestState({ layout: "state-only" }, async (state) => {
      const fixture = await createCompletionFixture(state);
      try {
        const secondImage = path.join(state.workspaceDir, "second.png");
        await fs.writeFile(secondImage, PNG);
        fixture.params.deliveryPayloads.push(
          setReplyPayloadMetadata(
            {
              spokenText: "Second report",
              mediaUrl: secondImage,
            },
            {
              assistantMediaFailures: [
                { code: "file-not-found", kind: "image", label: "missing.png" },
              ],
            },
          ),
        );
        await fixture.commit();
        const message = readTranscriptEventMessage((await fixture.messages())[0]);
        expect(readAssistantDisplayContent(message)).toEqual([
          { type: "text", text: "Example report" },
          expect.objectContaining({ type: "image", alt: "report.png" }),
          { type: "text", text: "Second report" },
          expect.objectContaining({ type: "image", alt: "second.png" }),
          expect.objectContaining({
            type: "attachment_error",
            attachment: expect.objectContaining({ label: "missing.png" }),
          }),
        ]);
      } finally {
        fixture.unsubscribe();
      }
    });
  });

  it.each([true, false])(
    "obeys workspaceOnly=%s for images beside the session store",
    async (workspaceOnly) => {
      await withOpenClawTestState({ layout: "state-only" }, async (state) => {
        const fixture = await createCompletionFixture(state);
        try {
          const privateImage = path.join(path.dirname(fixture.scope.storePath), "private.png");
          await fs.mkdir(path.dirname(privateImage), { recursive: true });
          await fs.writeFile(privateImage, PNG);
          fixture.params.cfgWithAgentDefaults.tools = { profile: "full", fs: { workspaceOnly } };
          fixture.params.deliveryPayloads = [{ text: "Report", mediaUrl: privateImage }];
          await expect(fixture.commit()).resolves.toMatchObject({ ok: true });
          const message = readTranscriptEventMessage((await fixture.messages())[0]);
          const content = readAssistantDisplayContent(message);
          expect(content).toEqual([
            { type: "text", text: "Report" },
            expect.objectContaining({ type: workspaceOnly ? "attachment_error" : "image" }),
          ]);
          expect(fixture.records()).toHaveLength(workspaceOnly ? 0 : 1);
        } finally {
          fixture.unsubscribe();
        }
      });
    },
  );

  it("does not prepare media when the source generation changes while waiting", async () => {
    await withOpenClawTestState({ layout: "state-only" }, async (state) => {
      const fixture = await createCompletionFixture(state);
      const admission = await beginSessionWorkAdmission({
        scope: fixture.scope.storePath,
        identities: [fixture.scope.sessionKey, fixture.scope.sessionId],
        assertAllowed: () => {},
      });
      const commit = fixture.commit();
      try {
        await vi.waitFor(() => expect(getActiveSessionLifecycleMutationCount()).toBe(1));
        expect(fixture.records()).toEqual([]);
        await replaceSessionEntry(fixture.scope, {
          sessionId: "replacement-session",
          lifecycleRevision: "replacement-generation",
          updatedAt: 3000,
        });
        admission.release();
        await expect(commit).resolves.toMatchObject({ ok: false });
        expect(fixture.records()).toEqual([]);
        expect(await fixture.messages()).toEqual([]);
        expect(fixture.updates()).toBe(0);
      } finally {
        admission.release();
        await commit;
        fixture.unsubscribe();
      }
    });
  });
});