import { describe, expect, it, vi } from "vitest";

import {
  createTelemetryAdapter,
  safeTraceparent,
} from "../../src/adapters/telemetry/best-effort-telemetry.js";
import {
  TELEMETRY_REGISTRY,
  projectTelemetryEvent,
} from "../../src/contracts/telemetry.js";

const validAttributes = {
  error_kind: "SERVER_FAILURE",
  http_status_group: "5xx",
  attempt_count_bucket: "3",
  route_id: "SAMPLE_RESOURCE_LIST",
};

describe("telemetry registry and redaction", () => {
  it("defines all event contract fields", () => {
    for (const definition of Object.values(TELEMETRY_REGISTRY)) {
      expect(definition).toEqual(
        expect.objectContaining({
          eventName: expect.any(String),
          trigger: expect.any(String),
          requiredAttributes: expect.any(Array),
          optionalAttributes: expect.any(Array),
          forbiddenAttributes: expect.any(Array),
          sampling: expect.any(String),
          delivery: "best-effort",
        }),
      );
    }
  });

  it("uses a default-deny attribute projection", () => {
    const projected = projectTelemetryEvent("api.request.failed", {
      ...validAttributes,
      raw_url: "https://api.test/path?token=secret",
      unregistered: "private",
    });

    expect(projected.success).toBe(true);
    expect(JSON.stringify(projected)).not.toMatch(/raw_url|token|secret|unregistered/);
  });

  it("validates traceparent without exposing invalid values", () => {
    expect(
      safeTraceparent(
        "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
      ),
    ).toBe("00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01");
    expect(safeTraceparent("Bearer secret")).toBeNull();
  });
});

describe("best-effort telemetry adapter", () => {
  it("bounds the queue using oldest-drop without blocking callers", () => {
    const scheduled = [];
    const adapter = createTelemetryAdapter({
      enabled: true,
      endpoint: "https://telemetry.test/events",
      maxQueue: 2,
      schedule: (callback) => scheduled.push(callback),
      fetcher: vi.fn(),
    });

    adapter.emit("api.request.failed", validAttributes);
    adapter.emit("api.request.failed", validAttributes);
    adapter.emit("api.request.failed", validAttributes);

    expect(adapter.pendingCount()).toBe(2);
    expect(adapter.droppedCount()).toBe(1);
    expect(scheduled).toHaveLength(1);
  });

  it("degrades on sink failure without throwing or recursive events", async () => {
    const adapter = createTelemetryAdapter({
      enabled: true,
      endpoint: "https://telemetry.test/events",
      schedule: () => {},
      fetcher: async () => {
        throw new Error("sink unavailable");
      },
    });
    expect(() => adapter.emit("api.request.failed", validAttributes)).not.toThrow();
    await expect(adapter.flush()).resolves.toBeUndefined();
    expect(adapter.droppedCount()).toBe(1);
    expect(adapter.pendingCount()).toBe(0);
  });

  it("performs no network or queue work when disabled", async () => {
    const fetcher = vi.fn();
    const adapter = createTelemetryAdapter({
      enabled: false,
      endpoint: "https://telemetry.test/events",
      fetcher,
    });
    adapter.emit("api.request.failed", validAttributes);
    await adapter.flush();

    expect(fetcher).not.toHaveBeenCalled();
    expect(adapter.pendingCount()).toBe(0);
  });
});