import { describe, expect, it } from "@effect/vitest";
import { Data, Effect } from "effect";

import type { ExecutionEngine } from "@executor-js/execution";

import { makeExecutionRateLimiter } from "./execution-rate-limit";
import { RATE_LIMIT_BLOCKED_MESSAGE } from "./execution-limit-messages";

const ORG = "org_test";

/** Stands in for whatever the real lookups fail with (Autumn down, DO down). */
class UpstreamDownError extends Data.TaggedError("UpstreamDownError")<{
  readonly which: string;
}> {}

// A stand-in engine: `execute` resolves to a marker, so a test tells an allowed
// execution (marker) from a blocked one (the gate's error result) by which of
// the two came back. A blocked decision never reaches the engine at all.
const engineStub: ExecutionEngine = {
  execute: () => Effect.succeed({ result: "ran" }),
  executeWithPause: () => Effect.succeed({ status: "completed", result: { result: "ran" } }),
  resume: () => Effect.succeed(null),
  getPausedExecution: () => Effect.succeed(null),
  pausedExecutionCount: () => Effect.succeed(0),
  hasPausedExecutions: () => Effect.succeed(false),
  getDescription: Effect.succeed("stub"),
};

/** Counter that hands out a caller-controlled sequence of counts. */
const countingIncrement = (counts: ReadonlyArray<number>) => {
  let calls = 0;
  return () => Effect.succeed(counts[Math.min(calls++, counts.length - 1)] ?? 0);
};

const runExecute = (limiter: ReturnType<typeof makeExecutionRateLimiter>) =>
  Effect.runPromise(
    limiter.decorate(ORG, engineStub).execute("code", {
      // Never invoked: the stub ignores it, and a blocked execution never runs.
      onElicitation: () => Effect.die("elicitation is not exercised here"),
    }),
  );

describe("execution rate limiter — paid exemption", () => {
  it("allows executions under the cap without consulting the exemption", async () => {
    let exemptionCalls = 0;
    const limiter = makeExecutionRateLimiter(countingIncrement([1]), {
      limit: 10,
      isExempt: () => {
        exemptionCalls += 1;
        return Effect.succeed(false);
      },
    });

    expect(await runExecute(limiter)).toMatchObject({ result: "ran" });
    // The whole point of resolving lazily: the common path costs no lookup.
    expect(exemptionCalls).toBe(0);
  });

  it("blocks a non-exempt org over the cap", async () => {
    const limiter = makeExecutionRateLimiter(countingIncrement([11]), {
      limit: 10,
      isExempt: () => Effect.succeed(false),
    });

    expect(await runExecute(limiter)).toMatchObject({
      result: null,
      error: RATE_LIMIT_BLOCKED_MESSAGE,
    });
  });

  it("allows an exempt org over the cap", async () => {
    const limiter = makeExecutionRateLimiter(countingIncrement([11]), {
      limit: 10,
      isExempt: () => Effect.succeed(true),
    });

    expect(await runExecute(limiter)).toMatchObject({ result: "ran" });
  });

  it("caches the exemption so a paid org past the cap looks it up once", async () => {
    let exemptionCalls = 0;
    const limiter = makeExecutionRateLimiter(countingIncrement([11, 12, 13]), {
      limit: 10,
      exemptionTtlMs: 60_000,
      now: () => 1_000,
      isExempt: () => {
        exemptionCalls += 1;
        return Effect.succeed(true);
      },
    });

    for (let i = 0; i < 3; i += 1)
      expect(await runExecute(limiter)).toMatchObject({ result: "ran" });
    expect(exemptionCalls).toBe(1);
  });

  it("re-resolves once the cached exemption expires", async () => {
    let exemptionCalls = 0;
    let clock = 1_000;
    const limiter = makeExecutionRateLimiter(countingIncrement([11, 12]), {
      limit: 10,
      exemptionTtlMs: 1_000,
      now: () => clock,
      isExempt: () => {
        exemptionCalls += 1;
        return Effect.succeed(true);
      },
    });

    await runExecute(limiter);
    clock += 5_000;
    await runExecute(limiter);
    expect(exemptionCalls).toBe(2);
  });

  it("blocks when the exemption cannot be resolved and nothing is cached", async () => {
    // Deliberately NOT fail-open: an unresolvable exemption during an Autumn
    // outage must not switch the backstop off, which is the one scenario it
    // exists to cover.
    const limiter = makeExecutionRateLimiter(countingIncrement([11]), {
      limit: 10,
      isExempt: () => Effect.fail(new UpstreamDownError({ which: "autumn" })),
    });

    expect(await runExecute(limiter)).toMatchObject({
      result: null,
      error: RATE_LIMIT_BLOCKED_MESSAGE,
    });
  });

  it("honours a stale exemption when a later lookup fails", async () => {
    let clock = 1_000;
    let shouldFail = false;
    const limiter = makeExecutionRateLimiter(countingIncrement([11, 12]), {
      limit: 10,
      exemptionTtlMs: 1_000,
      now: () => clock,
      isExempt: () =>
        shouldFail ? Effect.fail(new UpstreamDownError({ which: "autumn" })) : Effect.succeed(true),
    });

    expect(await runExecute(limiter)).toMatchObject({ result: "ran" });

    // Cache expires and Autumn is now unreachable: the known-paid org keeps
    // running rather than getting blocked mid-workload by a blip.
    clock += 5_000;
    shouldFail = true;
    expect(await runExecute(limiter)).toMatchObject({ result: "ran" });
  });

  it("fails open when the counter itself is unreachable", async () => {
    const limiter = makeExecutionRateLimiter(
      () => Effect.fail(new UpstreamDownError({ which: "counter DO" })),
      {
        limit: 10,
        isExempt: () => Effect.succeed(false),
      },
    );

    expect(await runExecute(limiter)).toMatchObject({ result: "ran" });
  });

  it("applies the cap when no exemption predicate is wired", async () => {
    const limiter = makeExecutionRateLimiter(countingIncrement([11]), { limit: 10 });

    expect(await runExecute(limiter)).toMatchObject({
      result: null,
      error: RATE_LIMIT_BLOCKED_MESSAGE,
    });
  });
});