import { describe, expect, it } from "@suaveplan/testing/runner";
import type { EventBusLike, LoggerLike } from "@suaveplan/types";
import {
    JOB_SCHEDULER_CODES,
    JobSchedulerError,
} from "../errors/job-scheduler-error.js";
import {
    type ExecutionTimers,
    executeJob,
    type JobContext,
} from "./job-execution.js";

interface CapturedEvent {
    type: string;
    payload: unknown;
}

function makeBus(): {
    bus: EventBusLike<Record<string, unknown>>;
    events: CapturedEvent[];
} {
    const events: CapturedEvent[] = [];
    const bus: EventBusLike<Record<string, unknown>> = {
        on: () => () => undefined,
        emit: (type, payload) => {
            events.push({ type: type as string, payload });
        },
    };
    return { bus, events };
}

function makeLogger(): LoggerLike {
    return {
        debug: () => undefined,
        info: () => undefined,
        warn: () => undefined,
        error: () => undefined,
    };
}

interface FakeTimerState {
    now: number;
    nextId: number;
    pending: Map<number, { fireAt: number; cb: () => void }>;
}

function makeFakeTimers(state: FakeTimerState): {
    timers: ExecutionTimers;
    advance: (delta: number) => Promise<void>;
    pending: () => number;
} {
    const timers: ExecutionTimers = {
        setTimer: (cb, ms) => {
            const id = state.nextId++;
            state.pending.set(id, { fireAt: state.now + ms, cb });
            return id;
        },
        clearTimer: (h) => {
            state.pending.delete(h as number);
        },
    };
    const advance = async (delta: number): Promise<void> => {
        const target = state.now + delta;
        for (;;) {
            let nextId: number | undefined;
            let nextAt = Number.POSITIVE_INFINITY;
            for (const [id, t] of state.pending) {
                if (t.fireAt <= target && t.fireAt < nextAt) {
                    nextId = id;
                    nextAt = t.fireAt;
                }
            }
            if (nextId === undefined) break;
            const entry = state.pending.get(nextId);
            if (entry === undefined) break;
            state.pending.delete(nextId);
            state.now = entry.fireAt;
            entry.cb();
            await Promise.resolve();
        }
        state.now = target;
    };
    return { timers, advance, pending: () => state.pending.size };
}

describe("executeJob", () => {
    it("emits start + complete on first-try success", async () => {
        const state: FakeTimerState = {
            now: 0,
            nextId: 1,
            pending: new Map(),
        };
        const { timers } = makeFakeTimers(state);
        const { bus, events } = makeBus();
        const handler = async (ctx: JobContext): Promise<void> => {
            expect(ctx.attempt).toBe(1);
        };
        await executeJob({
            jobId: "j-1",
            kind: "queued",
            handler,
            scheduledAt: 0,
            retries: 0,
            retryDelayMs: 0,
            cancelSignal: new AbortController().signal,
            clock: () => state.now,
            logger: makeLogger(),
            events: bus,
            timers,
        });
        expect(events.map((e) => e.type)).toEqual([
            "job:start",
            "job:complete",
        ]);
    });

    it("retries then succeeds, emitting one start per attempt", async () => {
        const state: FakeTimerState = {
            now: 0,
            nextId: 1,
            pending: new Map(),
        };
        const { timers, advance } = makeFakeTimers(state);
        const { bus, events } = makeBus();
        let attempts = 0;
        const handler = async (ctx: JobContext): Promise<void> => {
            attempts = ctx.attempt;
            if (ctx.attempt < 3) throw new Error("transient");
        };
        const promise = executeJob({
            jobId: "j-2",
            kind: "queued",
            handler,
            scheduledAt: 0,
            retries: 5,
            retryDelayMs: 100,
            cancelSignal: new AbortController().signal,
            clock: () => state.now,
            logger: makeLogger(),
            events: bus,
            timers,
        });
        // Drain inter-attempt sleeps.
        for (let i = 0; i < 10; i++) {
            await Promise.resolve();
            await Promise.resolve();
            await advance(100);
        }
        await promise;
        expect(attempts).toBe(3);
        const starts = events.filter((e) => e.type === "job:start").length;
        const completes = events.filter(
            (e) => e.type === "job:complete"
        ).length;
        const fails = events.filter((e) => e.type === "job:fail").length;
        expect(starts).toBe(3);
        expect(completes).toBe(1);
        expect(fails).toBe(2);
    });

    it("exhausts retries and throws JOB_SCHEDULER.EXECUTION_FAILED", async () => {
        const state: FakeTimerState = {
            now: 0,
            nextId: 1,
            pending: new Map(),
        };
        const { timers, advance } = makeFakeTimers(state);
        const { bus } = makeBus();
        const handler = async (): Promise<void> => {
            throw new Error("always fails");
        };
        const promise = executeJob({
            jobId: "j-3",
            kind: "queued",
            handler,
            scheduledAt: 0,
            retries: 2,
            retryDelayMs: 50,
            cancelSignal: new AbortController().signal,
            clock: () => state.now,
            logger: makeLogger(),
            events: bus,
            timers,
        }).catch((e: unknown) => e);
        for (let i = 0; i < 10; i++) {
            await Promise.resolve();
            await Promise.resolve();
            await advance(50);
        }
        const err = await promise;
        expect(err).toBeInstanceOf(JobSchedulerError);
        expect((err as JobSchedulerError).code).toBe(
            JOB_SCHEDULER_CODES.EXECUTION_FAILED
        );
    });

    it("times out a handler that never resolves", async () => {
        const state: FakeTimerState = {
            now: 0,
            nextId: 1,
            pending: new Map(),
        };
        const { timers, advance } = makeFakeTimers(state);
        const { bus } = makeBus();
        const handler = (ctx: JobContext): Promise<void> =>
            new Promise<void>((resolve, reject) => {
                ctx.signal.addEventListener("abort", () => {
                    reject(ctx.signal.reason);
                });
            });
        const promise = executeJob({
            jobId: "j-4",
            kind: "queued",
            handler,
            scheduledAt: 0,
            retries: 0,
            retryDelayMs: 0,
            timeoutMs: 100,
            cancelSignal: new AbortController().signal,
            clock: () => state.now,
            logger: makeLogger(),
            events: bus,
            timers,
        }).catch((e: unknown) => e);
        await Promise.resolve();
        await advance(100);
        const err = await promise;
        expect(err).toBeInstanceOf(JobSchedulerError);
        expect((err as JobSchedulerError).code).toBe(
            JOB_SCHEDULER_CODES.TIMEOUT
        );
    });

    it("propagates an externally-aborted cancel signal", async () => {
        const state: FakeTimerState = {
            now: 0,
            nextId: 1,
            pending: new Map(),
        };
        const { timers } = makeFakeTimers(state);
        const { bus } = makeBus();
        const outer = new AbortController();
        outer.abort(new Error("cancelled by scheduler"));
        const handler = (ctx: JobContext): Promise<void> =>
            new Promise<void>((_resolve, reject) => {
                if (ctx.signal.aborted) {
                    reject(ctx.signal.reason);
                    return;
                }
                ctx.signal.addEventListener("abort", () => {
                    reject(ctx.signal.reason);
                });
            });
        const promise = executeJob({
            jobId: "j-5",
            kind: "queued",
            handler,
            scheduledAt: 0,
            retries: 0,
            retryDelayMs: 0,
            cancelSignal: outer.signal,
            clock: () => state.now,
            logger: makeLogger(),
            events: bus,
            timers,
        }).catch((e: unknown) => e);
        const err = await promise;
        expect(err).toBeInstanceOf(JobSchedulerError);
        expect((err as JobSchedulerError).code).toBe(
            JOB_SCHEDULER_CODES.EXECUTION_FAILED
        );
    });

    it("exposes the active per-attempt controller via onAttemptController", async () => {
        const state: FakeTimerState = {
            now: 0,
            nextId: 1,
            pending: new Map(),
        };
        const { timers } = makeFakeTimers(state);
        const { bus } = makeBus();
        const controllers: AbortController[] = [];
        const handler = async (): Promise<void> => undefined;
        await executeJob({
            jobId: "j-6",
            kind: "cron",
            handler,
            scheduledAt: 0,
            retries: 0,
            retryDelayMs: 0,
            cancelSignal: new AbortController().signal,
            clock: () => state.now,
            logger: makeLogger(),
            events: bus,
            timers,
            onAttemptController: (c) => controllers.push(c),
        });
        expect(controllers).toHaveLength(1);
    });

    it("breaks the retry loop when cancel is requested mid-sleep", async () => {
        const state: FakeTimerState = {
            now: 0,
            nextId: 1,
            pending: new Map(),
        };
        const { timers, advance } = makeFakeTimers(state);
        const { bus } = makeBus();
        const outer = new AbortController();
        let attempts = 0;
        const handler = async (): Promise<void> => {
            attempts += 1;
            throw new Error("fail");
        };
        const promise = executeJob({
            jobId: "j-7",
            kind: "queued",
            handler,
            scheduledAt: 0,
            retries: 5,
            retryDelayMs: 100,
            cancelSignal: outer.signal,
            clock: () => state.now,
            logger: makeLogger(),
            events: bus,
            timers,
        }).catch((e: unknown) => e);
        // Let the first attempt fail.
        await Promise.resolve();
        // Cancel mid-sleep.
        outer.abort(new Error("stop"));
        // The sleep's abort listener resolves; the loop sees the aborted
        // signal and bails.
        await advance(0);
        const err = await promise;
        expect(err).toBeInstanceOf(JobSchedulerError);
        expect(attempts).toBe(1);
    });
});