import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { join } from 'node:path';
import { newFixture, type Fixture } from '../helpers/fixture.js';
import { gameEvent } from '../helpers/telemetry.js';

vi.mock('../../src/lib/server/integrations/komodo.js', () => ({
    komodoRestart: vi.fn(), komodoRuntimeAction: vi.fn(), komodoInspectHealthy: vi.fn(),
    komodoCreateDeployment: vi.fn(), komodoDeploy: vi.fn(), komodoDestroyDeployment: vi.fn(), komodoDeleteDeployment: vi.fn(),
    komodoEnsureTag: vi.fn(), komodoUpdateTagsOnResource: vi.fn()
}));
vi.mock('../../src/lib/server/integrations/rcon.js', () => ({ rconGetPlayerCount: vi.fn(), rconStatusResult: vi.fn() }));
vi.mock('../../src/lib/server/pipeline/worker.js', () => ({ kick: vi.fn(async () => {}) }));

let fixture: Fixture;
const server = 't5_zombie_theater_1';
const status = (map = 'zombie_theater') => ({ ok: true as const, endpoint: { host: 'test', port: 28960 }, rawReply: '',
    status: { players: 0, map, gametype: 'zom', roster: [] } });

beforeEach(async () => {
    vi.resetModules(); vi.resetAllMocks();
    vi.useFakeTimers({ toFake: ['Date'] });
    vi.setSystemTime(new Date('2026-09-28T12:00:00Z'));
    fixture = await newFixture([server]);
    for (const [key, value] of Object.entries({ KOMODO_ADDRESS: 'http://komodo.test', KOMODO_API_KEY: 'test', KOMODO_API_SECRET: 'test',
        KOMODO_TARGET_SERVER: 'host', RCON_PASSWORD: 'test', DEPLOYMENT_CREATE_CONCURRENCY: '1', DEPLOYMENT_RESTART_CONCURRENCY: '1',
        SERVER_PORT_MIN: '28960', SERVER_PORT_MAX: '28970' })) vi.stubEnv(key, value);
    const komodo = await import('../../src/lib/server/integrations/komodo.js');
    for (const name of ['komodoRestart', 'komodoRuntimeAction', 'komodoCreateDeployment', 'komodoDeploy', 'komodoDestroyDeployment', 'komodoDeleteDeployment'] as const) {
        vi.mocked(komodo[name]).mockResolvedValue({ ok: true });
    }
    vi.mocked(komodo.komodoInspectHealthy).mockResolvedValue({ ok: true, state: 'running' });
    vi.mocked(komodo.komodoEnsureTag).mockImplementation(async name => ({ ok: true, id: name }));
    vi.mocked(komodo.komodoUpdateTagsOnResource).mockResolvedValue({ ok: true });
    const rcon = await import('../../src/lib/server/integrations/rcon.js');
    vi.mocked(rcon.rconGetPlayerCount).mockResolvedValue(0);
    vi.mocked(rcon.rconStatusResult).mockResolvedValue(status());
});
afterEach(async () => { await fixture.cleanup(); vi.useRealTimers(); vi.unstubAllEnvs(); });

async function register() {
    const { db } = await import('../../src/lib/server/db/index.js');
    db().prepare(`INSERT INTO servers (name,komodo_type,komodo_name,game,map,game_mode,map_slug,game_port,host_dir)
        VALUES (?, 'deployment', ?, 't5','zombie_theater','zombie','theater',28960,?)`).run(server, server, join(fixture.t5, server));
    const { saveServerKey } = await import('../../src/lib/server/fleet/server-keys.js');
    saveServerKey(server, 'saved-key');
}
async function detail(id: string) {
    const { getDeployment } = await import('../../src/lib/server/provisioning/history.js');
    return getDeployment(id)!;
}
async function telemetry(players: number, map = 'zombie_theater') {
    const { db } = await import('../../src/lib/server/db/index.js');
    const receivedAt = new Date().toISOString();
    db().prepare(`INSERT INTO server_telemetry (server,round,players,received_at,payload) VALUES (?,1,?,?,?)
        ON CONFLICT(server) DO UPDATE SET players=excluded.players,received_at=excluded.received_at,payload=excluded.payload`)
        .run(server, players, receivedAt, JSON.stringify({ ...gameEvent('heartbeat', 1, players, server, map), receivedAt }));
    return receivedAt;
}

describe('provisioning decision evidence', () => {
    it('distinguishes queued recipes, attempted files, transient map checks, and telemetry completion without replaying startup', async () => {
        const { queueCreateServer, processCreations } = await import('../../src/lib/server/provisioning/instances.js');
        const { komodoCreateDeployment, komodoDeploy, komodoInspectHealthy } = await import('../../src/lib/server/integrations/komodo.js');
        const { rconStatusResult } = await import('../../src/lib/server/integrations/rcon.js');
        const job = queueCreateServer({ gameMode: 'zombie', mapSlug: 'theater', plutoKey: 'saved-key' });
        if (!job.ok) throw new Error(job.message);
        expect((await detail(job.deploymentId)).progress).toMatchObject({ phase: 'startup-queue', recipeStatus: 'queued', observedAt: null });

        const { createScript, getLatestVersion } = await import('../../src/lib/server/fleet/scripts.js');
        const { db } = await import('../../src/lib/server/db/index.js');
        const { script } = createScript({ name: 'New promotion', targetRelPath: 'promoted.gsc', scopeType: 'game', scopeValue: 't5', content: Buffer.from('promoted while queued') });
        db().prepare('UPDATE scripts SET current_version_id = ? WHERE id = ?').run(getLatestVersion(script.id)!.id, script.id);
        await processCreations();
        expect((await detail(job.deploymentId)).progress?.recipeStatus).toBe('attempted');
        expect((await detail(job.deploymentId)).recipe?.files.some(file => file.path === 'promoted.gsc')).toBe(true);

        vi.mocked(rconStatusResult).mockResolvedValueOnce(status('zombie_moon'));
        vi.setSystemTime(Date.now() + 1000);
        await processCreations();
        expect((await detail(job.deploymentId)).progress).toMatchObject({ phase: 'verify-map', blocker: { code: 'map-mismatch' },
            checks: [{ key: 'container', result: 'pass' }, { key: 'game', result: 'pass' }, { key: 'map', result: 'waiting', expected: 'zombie_theater', actual: 'zombie_moon' }] });
        vi.mocked(komodoInspectHealthy).mockResolvedValueOnce({ ok: false, reason: 'container recovering' });
        await processCreations();
        expect((await detail(job.deploymentId)).progress?.checks).toEqual([expect.objectContaining({ key: 'container', result: 'waiting' })]);

        vi.setSystemTime(Date.now() + 1000);
        const receivedAt = await telemetry(0);
        await processCreations();
        const completed = await detail(job.deploymentId);
        expect(completed.deployment.state).toBe('done');
        expect(completed.progress?.checks).toContainEqual(expect.objectContaining({ key: 'game', source: 'telemetry', result: 'pass', receivedAt }));
        expect(completed.progress?.checkpoints).toContainEqual(expect.objectContaining({ key: 'verify-map' }));
        expect(komodoCreateDeployment).toHaveBeenCalledTimes(1);
        expect(komodoDeploy).toHaveBeenCalledTimes(1);
    });

    it('keeps an uncertain failed request immutable while observing and releasing its exact recovery slot', async () => {
        await register();
        const { requestLifecycle } = await import('../../src/lib/server/provisioning/requests.js');
        const { processProvisioning } = await import('../../src/lib/server/provisioning/worker.js');
        const { komodoRestart } = await import('../../src/lib/server/integrations/komodo.js');
        vi.mocked(komodoRestart).mockResolvedValueOnce({ ok: false, kind: 'unreachable', message: 'response lost' });
        const job = requestLifecycle(server, 'restart');
        if (!job.ok) throw new Error(job.error);
        await processProvisioning();
        const failed = await detail(job.deploymentId);
        expect(failed.progress).toMatchObject({ command: { state: 'uncertain' }, recovery: { state: 'held', operationId: job.deploymentId } });
        const failureEvents = failed.events.filter(event => event.kind === 'outcome');
        vi.setSystemTime(Date.now() + 15_000);
        await telemetry(0);
        await processProvisioning();
        const recovered = await detail(job.deploymentId);
        expect(recovered.deployment).toMatchObject({ state: 'failed', finished_at: failed.deployment.finished_at });
        expect(recovered.progress).toMatchObject({ command: { state: 'uncertain' }, recovery: { state: 'released', operationId: job.deploymentId } });
        expect(recovered.events.filter(event => event.kind === 'outcome')).toEqual(failureEvents);
        expect(komodoRestart).toHaveBeenCalledTimes(1);
    });

    it('records occupied and unknown evidence without treating either as zero or resetting eligibility timing', async () => {
        await register();
        const { requestLifecycle } = await import('../../src/lib/server/provisioning/requests.js');
        const { processProvisioning } = await import('../../src/lib/server/provisioning/worker.js');
        const { rconGetPlayerCount } = await import('../../src/lib/server/integrations/rcon.js');
        const { komodoRestart } = await import('../../src/lib/server/integrations/komodo.js');
        const job = requestLifecycle(server, 'restart');
        if (!job.ok) throw new Error(job.error);
        vi.mocked(rconGetPlayerCount).mockResolvedValueOnce(null);
        await processProvisioning();
        const unknown = await detail(job.deploymentId);
        expect(unknown.progress?.checks).toEqual([expect.objectContaining({ key: 'occupancy', actual: null, source: null, result: 'unknown' })]);
        vi.setSystemTime(Date.now() + 1000);
        await telemetry(3);
        await processProvisioning();
        expect((await detail(job.deploymentId)).progress).toMatchObject({ phaseStartedAt: unknown.progress?.phaseStartedAt,
            blocker: { code: 'players-present' }, checks: [{ key: 'occupancy', actual: 3, source: 'telemetry' }] });
        vi.setSystemTime(Date.now() + 1000);
        await telemetry(2);
        await processProvisioning();
        expect((await detail(job.deploymentId)).progress?.phaseStartedAt).toBe(unknown.progress?.phaseStartedAt);
        expect(komodoRestart).not.toHaveBeenCalled();
    });

    it('preserves failed cleanup evidence through same-ID resume without another destructive command', async () => {
        await register();
        const { db } = await import('../../src/lib/server/db/index.js');
        const { destroyServer, processDestructions } = await import('../../src/lib/server/provisioning/instances.js');
        const { resumeCleanup } = await import('../../src/lib/server/provisioning/history.js');
        const { komodoInspectHealthy, komodoDestroyDeployment, komodoDeleteDeployment } = await import('../../src/lib/server/integrations/komodo.js');
        vi.mocked(komodoInspectHealthy).mockResolvedValue({ ok: false, state: 'exited', reason: 'stopped' });
        db().exec("CREATE TRIGGER fail_cleanup BEFORE DELETE ON servers BEGIN SELECT RAISE(ABORT, 'cleanup interrupted'); END");
        const job = destroyServer(server);
        if (!job.ok || !job.deploymentId) throw new Error('Could not queue removal');
        await processDestructions();
        const failed = await detail(job.deploymentId);
        expect(failed.deployment.state).toBe('failed');
        expect(failed.progress?.checkpoints).toContainEqual(expect.objectContaining({ key: 'delete-deployment' }));
        expect(failed.progress?.checkpoints.some(point => point.key === 'cleanup')).toBe(false);
        const failure = failed.events.find(event => event.kind === 'outcome')!;
        db().exec('DROP TRIGGER fail_cleanup');
        vi.setSystemTime(Date.now() + 1000);
        expect(resumeCleanup(job.deploymentId)).toBe(true);
        await processDestructions();
        const completed = await detail(job.deploymentId);
        expect(completed.deployment).toMatchObject({ id: job.deploymentId, state: 'done', server_exists: 0 });
        expect(completed.events).toContainEqual(failure);
        expect(completed.events.some(event => event.kind === 'resumed')).toBe(true);
        expect(completed.progress?.checkpoints).toContainEqual(expect.objectContaining({ key: 'cleanup' }));
        expect(komodoDestroyDeployment).toHaveBeenCalledTimes(1);
        expect(komodoDeleteDeployment).toHaveBeenCalledTimes(1);
    });

    it('links the actual removal dependency while later eligible creation bypasses it', async () => {
        const { db } = await import('../../src/lib/server/db/index.js');
        const { beginDeployment } = await import('../../src/lib/server/provisioning/history.js');
        const { queueCreateServer, processCreations } = await import('../../src/lib/server/provisioning/instances.js');
        const input = { gameMode: 'zombie' as const, mapSlug: 'theater', plutoKey: 'saved-key' };
        const first = queueCreateServer(input), second = queueCreateServer(input);
        if (!first.ok || !second.ok) throw new Error('Could not queue creation');
        const removal = beginDeployment('old-instance', 'destroy');
        db().prepare('INSERT INTO server_creation_dependencies VALUES (?, ?)').run(first.deploymentId, removal);
        await processCreations();
        expect((await detail(first.deploymentId)).progress?.blocker).toMatchObject({ code: 'removal-dependency', href: `/provisioning/${removal}` });
        expect((await detail(first.deploymentId)).deployment.state).toBe('queued');
        expect((await detail(second.deploymentId)).deployment.state).toBe('awaiting-health');
    });

    it.each(['create', 'delete'] as const)('records uncertainty when the %s reply throws without inventing a successful checkpoint', async command => {
        const komodo = await import('../../src/lib/server/integrations/komodo.js');
        const { queueCreateServer, processCreations, destroyServer, processDestructions } = await import('../../src/lib/server/provisioning/instances.js');
        let id: string;
        if (command === 'create') {
            vi.mocked(komodo.komodoCreateDeployment).mockRejectedValueOnce(new Error('reply lost'));
            const job = queueCreateServer({ gameMode: 'zombie', mapSlug: 'theater', plutoKey: 'saved-key' });
            if (!job.ok) throw new Error(job.message);
            id = job.deploymentId;
            await processCreations();
            expect(komodo.komodoCreateDeployment).toHaveBeenCalledTimes(1);
        } else {
            await register();
            vi.mocked(komodo.komodoInspectHealthy).mockResolvedValue({ ok: false, state: 'exited', reason: 'stopped' });
            vi.mocked(komodo.komodoDeleteDeployment).mockRejectedValueOnce(new Error('reply lost'));
            const job = destroyServer(server);
            if (!job.ok || !job.deploymentId) throw new Error('Could not queue removal');
            id = job.deploymentId;
            await processDestructions();
            expect(komodo.komodoDeleteDeployment).toHaveBeenCalledTimes(1);
        }
        const failed = await detail(id);
        expect(failed.deployment.state).toBe('failed');
        expect(failed.progress?.command).toMatchObject({ state: 'uncertain', message: expect.stringContaining('reply lost') });
        expect(failed.progress?.checkpoints.some(point => point.key === (command === 'create' ? 'create-deployment' : 'delete-deployment'))).toBe(false);
    });

    it.each(['destroy', 'rebuild'] as const)('retains the resumable %s checkpoint when a beta arrives after confirmed remote deletion', async action => {
        await register();
        const { db } = await import('../../src/lib/server/db/index.js');
        const { createScript } = await import('../../src/lib/server/fleet/scripts.js');
        const { destroyServer, processDestructions } = await import('../../src/lib/server/provisioning/instances.js');
        const { requestLifecycle } = await import('../../src/lib/server/provisioning/requests.js');
        const { processProvisioning } = await import('../../src/lib/server/provisioning/worker.js');
        const { resumeCleanup, resumeRebuild, REMOVING_SERVER } = await import('../../src/lib/server/provisioning/history.js');
        const { komodoInspectHealthy, komodoDestroyDeployment, komodoDeleteDeployment } = await import('../../src/lib/server/integrations/komodo.js');
        vi.mocked(komodoInspectHealthy).mockResolvedValue({ ok: false, state: 'exited', reason: 'stopped' });
        vi.mocked(komodoDeleteDeployment).mockImplementationOnce(async () => {
            const { script, version } = createScript({ name: 'Late beta', targetRelPath: 'beta.gsc', scopeType: 'game', scopeValue: 't5', content: Buffer.from('beta') });
            const beta = db().prepare("INSERT INTO betas (script_id,script_version_id,trigger_kind,state) VALUES (?,?,'manual','running')").run(script.id, version.id).lastInsertRowid;
            db().prepare("INSERT INTO beta_servers (beta_id,server,had_original,stage) VALUES (?,?,0,'ready')").run(beta, server);
            return { ok: true };
        });
        const job = action === 'destroy' ? destroyServer(server) : requestLifecycle(server, 'rebuild');
        if (!job.ok || !job.deploymentId) throw new Error('Could not queue removal');
        await (action === 'destroy' ? processDestructions() : processProvisioning());
        const failed = await detail(job.deploymentId);
        expect(failed.deployment).toMatchObject({ state: 'failed', stage: REMOVING_SERVER });
        expect(failed.progress?.checkpoints).toContainEqual(expect.objectContaining({ key: 'delete-deployment' }));
        expect(action === 'destroy' ? failed.canResumeCleanup : failed.canResumeRebuild).toBe(true);
        db().prepare("UPDATE betas SET state = 'rolled-back'").run();
        expect(action === 'destroy' ? resumeCleanup(job.deploymentId) : resumeRebuild(job.deploymentId)).toBe(true);
        await (action === 'destroy' ? processDestructions() : processProvisioning());
        expect((await detail(job.deploymentId)).deployment.state).toBe(action === 'destroy' ? 'done' : 'queued');
        expect(komodoDestroyDeployment).toHaveBeenCalledTimes(1);
        expect(komodoDeleteDeployment).toHaveBeenCalledTimes(1);
    });

    it('ignores occupancy evidence that returns after the request was cancelled', async () => {
        await register();
        const { requestLifecycle, cancelProvisioning } = await import('../../src/lib/server/provisioning/requests.js');
        const { processProvisioning } = await import('../../src/lib/server/provisioning/worker.js');
        const { rconGetPlayerCount } = await import('../../src/lib/server/integrations/rcon.js');
        const { komodoRestart } = await import('../../src/lib/server/integrations/komodo.js');
        const job = requestLifecycle(server, 'restart');
        if (!job.ok) throw new Error(job.error);
        vi.mocked(rconGetPlayerCount).mockImplementationOnce(async () => {
            expect(cancelProvisioning(job.deploymentId)).toBe(true);
            return 4;
        });
        await processProvisioning();
        const cancelled = await detail(job.deploymentId);
        expect(cancelled.deployment.state).toBe('cancelled');
        expect(cancelled.progress).toMatchObject({ checks: [], blocker: null });
        expect(komodoRestart).not.toHaveBeenCalled();
    });

    it('does not attach replacement health to a deleted creation after a delayed probe', async () => {
        const { db } = await import('../../src/lib/server/db/index.js');
        const { queueCreateServer, processCreations } = await import('../../src/lib/server/provisioning/instances.js');
        const { komodoInspectHealthy } = await import('../../src/lib/server/integrations/komodo.js');
        const { rconStatusResult } = await import('../../src/lib/server/integrations/rcon.js');
        const job = queueCreateServer({ gameMode: 'zombie', mapSlug: 'theater', plutoKey: 'saved-key' });
        if (!job.ok) throw new Error(job.message);
        await processCreations();
        vi.mocked(komodoInspectHealthy).mockImplementationOnce(async () => {
            db().prepare('DELETE FROM servers WHERE name = ?').run(server);
            await register();
            return { ok: true, state: 'running' };
        });
        await processCreations();
        const old = await detail(job.deploymentId);
        expect(old.deployment.server_deleted_at).toBeTruthy();
        expect(old.progress?.checks).toEqual([]);
        expect(old.progress?.checkpoints.some(point => point.key.startsWith('verify-'))).toBe(false);
        expect(rconStatusResult).not.toHaveBeenCalled();
    });
});