import { describe, expect, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import * as RpcClientError from "effect/unstable/rpc/RpcClientError";

import * as AcpSchema from "./_generated/schema.gen.ts";
import { callRpc, runHandler } from "./_internal/shared.ts";
import * as AcpError from "./errors.ts";

const decodeNestedNumberPayload = Schema.decodeUnknownEffect(
  Schema.Struct({ profile: Schema.Struct({ token: Schema.Number }) }),
);
const encodeUnknownJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));

describe("effect-acp errors", () => {
  it.effect("retains RPC method and cause without deriving the message from the cause", () => {
    const rootCause = new Error("connection details that must not become the public message");
    const failure = new RpcClientError.RpcClientError({
      reason: new RpcClientError.RpcClientDefect({
        message: rootCause.message,
        cause: rootCause,
      }),
    });

    return Effect.gen(function* () {
      const error = yield* callRpc("session/new", Effect.fail(failure)).pipe(Effect.flip);

      expect(error).toMatchObject({
        _tag: "AcpTransportError",
        operation: "call-rpc",
        method: "session/new",
        cause: failure,
      });
      expect(error.message).toBe("ACP transport operation call-rpc failed for method session/new.");
      expect(error.message).not.toContain(rootCause.message);
    });
  });

  it.effect("preserves typed ACP failures carried by the RPC protocol", () => {
    const original = new AcpError.AcpTransportError({
      detail: "Sign in to the agent.",
      cause: undefined,
    });
    const failure = new RpcClientError.RpcClientError({
      reason: new RpcClientError.RpcClientDefect({
        message: "ACP protocol terminated.",
        cause: original,
      }),
    });

    return Effect.gen(function* () {
      const error = yield* callRpc("initialize", Effect.fail(failure)).pipe(Effect.flip);
      expect(error).toBe(original);
    });
  });

  it.effect("preserves protocol request errors as request errors", () => {
    const failure = AcpSchema.Error.make({
      code: -32602,
      message: "Invalid params",
      data: { field: "sessionId" },
    });

    return Effect.gen(function* () {
      const error = yield* callRpc("session/load", Effect.fail(failure)).pipe(Effect.flip);

      expect(error).toMatchObject({
        _tag: "AcpRequestError",
        code: -32602,
        errorMessage: "Invalid params",
        data: { field: "sessionId" },
        method: "session/load",
        operation: "receive-response",
      });
    });
  });

  it("does not expose legacy diagnostic detail as the transport message", () => {
    const cause = new Error("connection refused at a private endpoint");
    const error = new AcpError.AcpTransportError({
      detail: cause.message,
      cause,
    });

    expect(error.message).toBe("ACP transport operation failed.");
    expect(error.cause).toBe(cause);
  });

  it("preserves structured extension handler failures behind stable request errors", () => {
    const cause = new AcpError.AcpTransportError({
      operation: "read-input-stream",
      cause: new Error("private transport diagnostics"),
    });
    const error = AcpError.AcpRequestError.fromExtensionHandlerError(cause, "x/test");

    expect(error).toMatchObject({
      code: -32603,
      method: "x/test",
      operation: "handle-extension-request",
      cause,
    });
    expect(error.message).toBe("ACP extension request handler failed for method 'x/test'");
    expect(error.message).not.toContain(cause.message);
  });

  it.effect("uses the structured mapper for core handler failures", () => {
    const cause = new AcpError.AcpTransportError({
      operation: "read-input-stream",
      cause: new Error("private transport diagnostics"),
    });

    return Effect.gen(function* () {
      const error = yield* runHandler(() => Effect.fail(cause), {}, "fs/read_text_file").pipe(
        Effect.flip,
      );

      expect(error).toMatchObject({
        code: -32603,
        message: "ACP request handler failed for method 'fs/read_text_file'",
      });
      expect(error.message).not.toContain(cause.message);
    });
  });

  it.effect("keeps invalid extension payload values only in the exact schema cause", () =>
    Effect.gen(function* () {
      const secret = "acp-schema-payload-secret";
      const cause = yield* decodeNestedNumberPayload({ profile: { token: secret } }).pipe(
        Effect.flip,
      );
      const error = AcpError.AcpRequestError.invalidExtensionPayload("x/private", cause);
      const { cause: directCause, ...directDiagnostics } = error;

      expect(directCause).toBe(cause);
      expect(error).toMatchObject({
        method: "x/private",
        operation: "decode-extension-request-payload",
        maximumPathDepth: 2,
      });
      expect(error.issueCount).toBeGreaterThan(0);
      expect(error.issueKinds).toContain("Pointer");
      expect(error.message).toBe("Invalid payload for ACP extension method 'x/private'.");
      expect(error.message).not.toContain(secret);
      expect(encodeUnknownJson(directDiagnostics)).not.toContain(secret);
      expect(encodeUnknownJson(error.toProtocolError())).not.toContain(secret);

      const protocolError = AcpError.AcpProtocolParseError.fromSchemaError(
        "decode-notification-payload",
        "x/private",
        cause,
      );
      const { cause: protocolCause, ...protocolDiagnostics } = protocolError;
      expect(protocolCause).toBe(cause);
      expect(protocolError).toMatchObject({
        method: "x/private",
        operation: "decode-notification-payload",
        maximumPathDepth: 2,
      });
      expect(protocolError.message).not.toContain(secret);
      expect(encodeUnknownJson(protocolDiagnostics)).not.toContain(secret);
      expect("detail" in protocolError).toBe(false);
    }),
  );
});