import { describe, expect, it } from "@effect/vitest";
import { Effect, Encoding, Layer, Option } from "effect";
import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";

import { recoverSlackConnectFile } from "./slack-connect-file";

const ACCESS_TOKEN = "xoxp-test-token";
const FILE_ID = "F012ABC3456";
const IMAGE_BYTES = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);

const httpClientLayer = (
  respond: (request: Request) => Response,
): Layer.Layer<HttpClient.HttpClient> =>
  Layer.succeed(HttpClient.HttpClient)(
    HttpClient.make((request: HttpClientRequest.HttpClientRequest) => {
      const url = new URL(request.url);
      for (const [name, value] of request.urlParams) url.searchParams.append(name, value);
      return Effect.succeed(
        HttpClientResponse.fromWeb(
          request,
          respond(new Request(url, { method: request.method, headers: request.headers })),
        ),
      );
    }),
  );

const recover = (
  layer: Layer.Layer<HttpClient.HttpClient>,
  overrides: Partial<Parameters<typeof recoverSlackConnectFile>[0]> = {},
) =>
  recoverSlackConnectFile({
    endpoint: "https://mcp.slack.com/mcp",
    toolName: "slack_read_file",
    args: { file_id: FILE_ID },
    accessToken: ACCESS_TOKEN,
    upstreamErrorMessage: "execution_failed: file_not_found",
    ...overrides,
  }).pipe(Effect.provide(layer));

describe("recoverSlackConnectFile", () => {
  it.effect("resolves and downloads a Slack Connect image with the existing OAuth token", () =>
    Effect.gen(function* () {
      const requests: Request[] = [];
      const layer = httpClientLayer((request) => {
        requests.push(request);
        const url = new URL(request.url);
        if (url.hostname === "slack.com") {
          return Response.json({
            ok: true,
            file: {
              id: FILE_ID,
              name: "screenshot.png",
              title: "screenshot.png",
              mimetype: "image/png",
              size: IMAGE_BYTES.byteLength,
              url_private_download: `https://files.slack.com/files-pri/T000-${FILE_ID}/download/screenshot.png`,
            },
          });
        }
        return new Response(IMAGE_BYTES, {
          status: 200,
          headers: { "content-type": "image/png" },
        });
      });

      const result = yield* recover(layer);

      expect(Option.isSome(result)).toBe(true);
      const recovered = Option.getOrThrow(result);
      expect(recovered.content).toEqual([
        {
          type: "text",
          text: `File ID: ${FILE_ID}\nTitle: screenshot.png\nMIME Type: image/png\nSize: 8 bytes\n`,
        },
        {
          type: "image",
          data: Encoding.encodeBase64(IMAGE_BYTES),
          mimeType: "image/png",
        },
      ]);
      expect(requests).toHaveLength(2);
      expect(requests.map((request) => new URL(request.url).searchParams.get("file"))).toEqual([
        FILE_ID,
        null,
      ]);
      expect(requests.map((request) => request.headers.get("authorization"))).toEqual([
        `Bearer ${ACCESS_TOKEN}`,
        `Bearer ${ACCESS_TOKEN}`,
      ]);
    }),
  );

  it.effect("does not call Slack for unrelated MCP failures", () =>
    Effect.gen(function* () {
      let requestCount = 0;
      const layer = httpClientLayer(() => {
        requestCount += 1;
        return new Response("unexpected", { status: 500 });
      });

      const results = yield* Effect.all([
        recover(layer, { endpoint: "https://example.com/mcp" }),
        recover(layer, { toolName: "another_tool" }),
        recover(layer, { upstreamErrorMessage: "execution_failed: permission_denied" }),
        recover(layer, { accessToken: null }),
        recover(layer, { args: { file_id: "../not-a-file-id" } }),
      ]);

      expect(results.every(Option.isNone)).toBe(true);
      expect(requestCount).toBe(0);
    }),
  );

  it.effect("rejects non-image and untrusted download responses", () =>
    Effect.gen(function* () {
      const nonImage = yield* recover(
        httpClientLayer(() =>
          Response.json({
            ok: true,
            file: {
              id: FILE_ID,
              name: "notes.txt",
              mimetype: "text/plain",
              size: 10,
              url_private_download: "https://files.slack.com/files-pri/file",
            },
          }),
        ),
      );
      const untrusted = yield* recover(
        httpClientLayer(() =>
          Response.json({
            ok: true,
            file: {
              id: FILE_ID,
              name: "screenshot.png",
              mimetype: "image/png",
              size: 10,
              url_private_download: "https://example.com/screenshot.png",
            },
          }),
        ),
      );
      let requestCount = 0;
      const wrongResponseType = yield* recover(
        httpClientLayer(() => {
          requestCount += 1;
          return requestCount === 1
            ? Response.json({
                ok: true,
                file: {
                  id: FILE_ID,
                  name: "screenshot.png",
                  mimetype: "image/png",
                  size: 10,
                  url_private_download: "https://files.slack.com/files-pri/file",
                },
              })
            : new Response("not an image", {
                status: 200,
                headers: { "content-type": "text/html" },
              });
        }),
      );

      expect(Option.isNone(nonImage)).toBe(true);
      expect(Option.isNone(untrusted)).toBe(true);
      expect(Option.isNone(wrongResponseType)).toBe(true);
    }),
  );
});