import { describe, expect, it } from "@effect/vitest";
import { Cause, Effect } from "effect";
import type * as Tracer from "effect/Tracer";

import type { ErrorEvent } from "@sentry/cloudflare";

import {
  addCurrentOtelCorrelationTags,
  beforeSendWithOtelCorrelation,
  DO_CAUSE_OWNER_TAG,
  DO_CAUSE_OWNER_VALUE,
  OTEL_SPAN_ID_TAG,
  OTEL_TRACE_ID_TAG,
  sentryPayloadForCause,
} from "./index";

// Mirrors Sentry core's `is.isError`: it picks the proper-Error path iff
// `Object.prototype.toString.call(x) === "[object Error]"`. Anything that
// fails this check goes down the synthetic "<className> captured as exception
// with keys: ..." path that produced the original CauseImpl Sentry issue.
const looksLikeErrorToSentry = (value: unknown): boolean =>
  Object.prototype.toString.call(value) === "[object Error]";

const traceId = "4268a606000000000000000000000000";
const spanId = "1234567890abcdef";

const makeFixedTracer = (): Tracer.Tracer => ({
  span: (options) => {
    const attributes = new Map<string, unknown>();
    let status: Tracer.SpanStatus = { _tag: "Started", startTime: options.startTime };
    return {
      _tag: "Span",
      name: options.name,
      spanId,
      traceId,
      parent: options.parent,
      annotations: options.annotations,
      get status() {
        return status;
      },
      attributes,
      links: options.links,
      sampled: options.sampled,
      kind: options.kind,
      end: (endTime, exit) => {
        status = { _tag: "Ended", startTime: options.startTime, endTime, exit };
      },
      attribute: (key, value) => {
        attributes.set(key, value);
      },
      event: () => undefined,
      addLinks: () => undefined,
    };
  },
});

describe("sentryPayloadForCause", () => {
  it("hands Sentry a real Error when the defect is itself a Cause", () => {
    // Reproduces the production chain: an inner runPromise rejects with a
    // CauseImpl (from Effect v4's causeSquash), Effect.promise re-wraps it
    // as Die(CauseImpl), and the outer catchCause receives this shape.
    // oxlint-disable-next-line executor/no-error-constructor -- boundary: observability test must build a real Error for Sentry-compatible payload assertions
    const innerCause = Cause.fail(new Error("inner failure"));
    const outerCause = Cause.die(innerCause);

    const { primary, pretty } = sentryPayloadForCause(outerCause);

    expect(looksLikeErrorToSentry(primary)).toBe(true);
    expect(pretty).not.toBeNull();
  });

  it("hands Sentry a real Error for an ordinary failed Cause", () => {
    // oxlint-disable-next-line executor/no-error-constructor -- boundary: observability test must build a real Error for Sentry-compatible payload assertions
    const { primary } = sentryPayloadForCause(Cause.fail(new Error("plain failure")));
    expect(looksLikeErrorToSentry(primary)).toBe(true);
  });

  it("forwards non-Cause inputs as-is with no pretty cause attached", () => {
    // oxlint-disable-next-line executor/no-error-constructor -- boundary: observability test must build a real Error for Sentry-compatible payload assertions
    const err = new Error("raw");
    const { primary, pretty } = sentryPayloadForCause(err);
    expect(primary).toBe(err);
    expect(pretty).toBeNull();
  });
});

describe("Sentry OTel correlation", () => {
  it.effect("adds tags from the active Effect span", () =>
    Effect.gen(function* () {
      const baseEvent: { readonly tags: Record<string, unknown> } = { tags: { existing: "tag" } };
      const event = yield* addCurrentOtelCorrelationTags(baseEvent);

      expect(event.tags.existing).toBe("tag");
      expect(event.tags[OTEL_TRACE_ID_TAG]).toBe(traceId);
      expect(event.tags[OTEL_SPAN_ID_TAG]).toBe(spanId);
    }).pipe(Effect.withSpan("test.sentry_capture"), Effect.withTracer(makeFixedTracer())),
  );
});

// One Durable Object failure used to open two Sentry issues: the DO's own
// `captureCause` seam reported it (mechanism `generic`), and then
// `instrumentDurableObjectWithSentry` reported the very same rejection again as
// it escaped the method (mechanism `auto.faas.cloudflare.durable_object`). The
// DO is the owner — it has the session, the classification and the OTel
// correlation — so its claim suppresses the echo and nothing else.
describe("Durable Object capture ownership", () => {
  const doEcho = (overrides: Partial<ErrorEvent> = {}): ErrorEvent => ({
    type: undefined,
    tags: { [DO_CAUSE_OWNER_TAG]: DO_CAUSE_OWNER_VALUE },
    exception: {
      values: [
        {
          type: "Error",
          value: "Durable Object reset because its code was updated.",
          mechanism: { type: "auto.faas.cloudflare.durable_object", handled: false },
        },
      ],
    },
    ...overrides,
  });

  it("drops the auto-instrumentation's copy of a cause the DO already claimed", () => {
    expect(beforeSendWithOtelCorrelation(doEcho())).toBeNull();
  });

  it("keeps the DO's own report, which carries no auto mechanism", () => {
    const own = doEcho({
      exception: {
        values: [
          {
            type: "Error",
            value: "Durable Object reset because its code was updated.",
            mechanism: { type: "generic", handled: true },
          },
        ],
      },
    });
    expect(beforeSendWithOtelCorrelation(own)).not.toBeNull();
  });

  // An alarm crash or a transport fault is never claimed by the DO seam, and
  // the auto-instrumentation is the ONLY thing that reports it. Dropping those
  // would trade duplicate noise for silence.
  it("keeps an unclaimed Durable Object failure", () => {
    const unclaimed = doEcho({ tags: {} });
    expect(beforeSendWithOtelCorrelation(unclaimed)).not.toBeNull();
  });

  it("keeps ordinary worker events untouched", () => {
    const workerEvent: ErrorEvent = {
      type: undefined,
      tags: { [OTEL_TRACE_ID_TAG]: traceId },
      exception: {
        values: [
          {
            type: "TypeError",
            value: "x is not a function",
            mechanism: { type: "auto.http.cloudflare", handled: false },
          },
        ],
      },
    };
    expect(beforeSendWithOtelCorrelation(workerEvent)).not.toBeNull();
  });
});