import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { mkdir, readFile, writeFile } from 'node:fs/promises';
import { existsSync } from 'node:fs';
import { dirname, join } from 'node:path';
import { newFixture, type Fixture } from '../helpers/fixture.js';
import { activateFiles } from '../helpers/staged-files.js';
import { defaultPlan, requirement } from '../../src/lib/beta-plan.js';

vi.mock('../../src/lib/server/pipeline/worker.js', () => ({ kick: vi.fn() }));
let fixture: Fixture;
const names = ['t5_zombie_theater_1', 't5_zombie_theater_2'];
beforeEach(async () => {
    vi.resetModules();
    fixture = await newFixture(names);
    const { seedServerRegistry } = await import('../../src/lib/server/fleet/servers.js');
    await seedServerRegistry();
});
afterEach(async () => {
    await fixture.cleanup();
    vi.useRealTimers();
});

async function setup(
    options: {
        original?: string;
        waveSize?: number;
        kind?: 'script' | 'baseline';
        legacy?: boolean;
    } = {}
) {
    const scripts = await import('../../src/lib/server/fleet/scripts.js');
    const beta = await import('../../src/lib/server/fleet/beta.js');
    const { db } = await import('../../src/lib/server/db/index.js');
    const { destOfKind, configFileOf } = await import('../../src/lib/server/config.js');
    const kind = options.kind ?? 'script';
    const path = join(
        destOfKind(names[0], kind),
        kind === 'script' ? 'revision.gsc' : configFileOf(names[0])
    );
    if (options.original !== undefined) {
        await mkdir(dirname(path), { recursive: true });
        await writeFile(path, options.original);
    }
    const { script, version } = scripts.createScript({
        name: 'Revision test',
        targetRelPath: kind === 'script' ? 'revision.gsc' : undefined,
        kind,
        scopeType: 'game',
        scopeValue: 't5',
        content: Buffer.from(kind === 'script' ? 'revision one' : 'set sv_voice "1"\n')
    });
    const plan = {
        ...defaultPlan(),
        waveSize: options.waveSize ?? 0,
        requirements: [requirement('manual', 'review')]
    };
    const { betaId } = await beta.openBeta({
        scripts: [{ scriptId: script.id, scriptVersionId: version.id }],
        servers: options.waveSize ? names : [names[0]],
        waitForHealth: true,
        waitForMatch: false,
        ...(options.legacy ? {} : { testPlan: plan })
    });
    // Pause while arranging test state; revision submission explicitly starts testing.
    if (!options.legacy)
        db().prepare("UPDATE beta_test_plans SET outcome = 'paused' WHERE beta_id = ?").run(betaId);
    return { ...scripts, ...beta, db: db(), script, version, betaId, path, plan };
}

describe('beta revisions', () => {
    it('keeps the beta identity and archives files, sign-offs and evidence while resetting tests and the deadline', async () => {
        const x = await setup();
        await activateFiles('beta', x.betaId);
        const { prepareRun, saveMetrics, readMetrics, evidence, testView } =
            await import('../../src/lib/server/fleet/beta-tests.js');
        const { currentBetaRevision, betaRevisionHistory } =
            await import('../../src/lib/server/fleet/beta-revisions.js');
        const run = await prepareRun(x.betaId, names[0]);
        const metrics = readMetrics(run);
        metrics.manual.review = 'Josh: verified';
        saveMetrics(run, metrics);
        evidence(run, 'old-signoff', 'manual-sign-off', { note: 'Josh: verified' });
        x.db.prepare("UPDATE beta_servers SET stage = 'ready' WHERE beta_id = ?").run(x.betaId);
        x.db.prepare("UPDATE betas SET state = 'ready-promote' WHERE id = ?").run(x.betaId);
        const opened = x.getBeta(x.betaId)!.opened_at;
        vi.useFakeTimers({ toFake: ['Date'] });
        vi.setSystemTime(Date.parse(opened) + 60_000);
        await expect(
            x.reviseBeta(
                x.betaId,
                1,
                [{ scriptId: x.script.id, content: Buffer.from('revision two') }],
                'Small fix'
            )
        ).resolves.toEqual({ revision: 2 });
        expect(x.getBeta(x.betaId)).toMatchObject({ state: 'running', opened_at: opened });
        expect(currentBetaRevision(x.betaId)).toEqual({
            revision: 2,
            started_at: new Date().toISOString()
        });
        expect(testView(x.betaId)).toMatchObject({ outcome: 'active', servers: [], evidence: [] });
        expect(x.listBetaServers(x.betaId)[0]).toMatchObject({
            stage: 'awaiting-empty',
            restarted_at: null,
            deployed_at: null,
            provisioning_id: null
        });
        const history = betaRevisionHistory(x.betaId);
        expect(history[0]).toMatchObject({ revision: 2, notes: 'Small fix', results: null });
        expect(history[1].results?.test?.servers[0].passed).toBe(true);
        expect(history[1].results?.test?.evidence).toHaveLength(1);
        expect(
            x.db
                .prepare(
                    'SELECT (SELECT content FROM file_blobs WHERE sha256=content_hash) AS content FROM beta_revision_files WHERE beta_id = ? AND revision = 1'
                )
                .get(x.betaId)
        ).toEqual({ content: Buffer.from('revision one') });
        expect(await readFile(x.path, 'utf8')).toBe('revision one');
        await expect(x.promoteBeta(x.betaId)).rejects.toThrow('has not passed');
        const nextRun = x.db
            .prepare('SELECT revision, metrics FROM beta_test_runs WHERE retired_at IS NULL')
            .get() as { revision: number; metrics: string };
        expect(nextRun.revision).toBe(2);
        expect(JSON.parse(nextRun.metrics).manual).toEqual({});
    });

    it.each(['original bytes', undefined])(
        'restores the pre-beta state after multiple revisions (original=%s)',
        async (original) => {
            const x = await setup({ original });
            await activateFiles('beta', x.betaId);
            for (let revision = 2; revision <= 3; revision++) {
                await x.reviseBeta(x.betaId, revision - 1, [
                    { scriptId: x.script.id, content: Buffer.from(`revision ${revision}`) }
                ]);
                await activateFiles('beta', x.betaId);
            }
            expect(await readFile(x.path, 'utf8')).toBe('revision 3');
            expect(
                x.db.prepare('SELECT had_original, prior_version_id FROM beta_server_scripts').get()
            ).toEqual({ had_original: original === undefined ? 0 : 1, prior_version_id: null });
            const result = await x.rollbackBeta(x.betaId);
            await activateFiles('campaign', result.deploymentId!);
            if (original === undefined) expect(existsSync(x.path)).toBe(false);
            else expect(await readFile(x.path, 'utf8')).toBe(original);
        }
    );

    it.each([false, true])(
        'rolls back a prior activation while its replacement is still queued (waves=%s)',
        async (waves) => {
            const x = await setup({ original: 'before beta', waveSize: waves ? 1 : 0 });
            await activateFiles('beta', x.betaId);
            if (waves) {
                await x.deployBetaServers(x.betaId, [names[1]]);
                await activateFiles('beta', x.betaId);
            }
            await x.reviseBeta(x.betaId, 1, [
                { scriptId: x.script.id, content: Buffer.from('pending replacement') }
            ]);
            if (waves)
                expect(x.listBetaServers(x.betaId).map((row) => row.stage)).toEqual([
                    'awaiting-empty',
                    'queued'
                ]);
            const result = await x.rollbackBeta(x.betaId);
            expect(result.restored).toContain(names[0]);
            if (waves) expect(result.dropped).toContain(names[1]);
            await activateFiles('campaign', result.deploymentId!);
            expect(await readFile(x.path, 'utf8')).toBe('before beta');
        }
    );

    it('does not restore or delete files when no revision was ever activated', async () => {
        const x = await setup({ original: 'untouched' });
        await x.reviseBeta(x.betaId, 1, [{ scriptId: x.script.id, content: Buffer.from('new') }]);
        expect(await x.rollbackBeta(x.betaId)).toMatchObject({ deploymentId: null });
        expect(await readFile(x.path, 'utf8')).toBe('untouched');
    });

    it('preserves the original tracked inventory version across revisions', async () => {
        const x = await setup({ original: 'tracked original' });
        const { recordScript, getServerScript } =
            await import('../../src/lib/server/fleet/inventory.js');
        const prior = x.uploadNewVersion(x.script.id, Buffer.from('tracked original'));
        recordScript(names[0], 'revision.gsc', prior.id, prior.sha256, prior.size, 'test');
        await activateFiles('beta', x.betaId);
        await x.reviseBeta(x.betaId, 1, [
            { scriptId: x.script.id, content: Buffer.from('replacement') }
        ]);
        await activateFiles('beta', x.betaId);
        expect(x.db.prepare('SELECT prior_version_id FROM beta_server_scripts').get()).toEqual({
            prior_version_id: prior.id
        });
        const result = await x.rollbackBeta(x.betaId);
        await activateFiles('campaign', result.deploymentId!);
        expect(getServerScript(names[0], 'revision.gsc')?.script_version_id).toBe(prior.id);
    });

    it('starts a revision with the same original canary selection', async () => {
        const x = await setup({ waveSize: 1 });
        await x.rollbackBeta(x.betaId);
        const { betaId } = await x.openBeta({
            scripts: [{ scriptId: x.script.id, scriptVersionId: x.version.id }],
            servers: [...names].reverse(),
            waitForHealth: true,
            waitForMatch: false,
            testPlan: x.plan
        });
        x.db.prepare("UPDATE beta_test_plans SET outcome = 'paused' WHERE beta_id = ?").run(betaId);
        await x.reviseBeta(betaId, 1, [
            { scriptId: x.script.id, content: Buffer.from('replacement') }
        ]);
        expect(x.listBetaServers(betaId).map((row) => [row.server, row.stage])).toEqual([
            [names[0], 'queued'],
            [names[1], 'awaiting-empty']
        ]);
    });

    it('allows updates after an interrupted attempt was superseded', async () => {
        const x = await setup();
        const { requestRestart, releaseRestartRequest } =
            await import('../../src/lib/server/provisioning/requests.js');
        const job = requestRestart(names[0], { kind: 'beta', id: String(x.betaId) });
        x.db
            .prepare("UPDATE server_deployments SET state = 'interrupted' WHERE id = ?")
            .run(job.id);
        releaseRestartRequest(names[0], { kind: 'beta', id: String(x.betaId) });
        await expect(
            x.reviseBeta(x.betaId, 1, [
                { scriptId: x.script.id, content: Buffer.from('replacement') }
            ])
        ).resolves.toEqual({ revision: 2 });
    });

    it('recomposes config revisions and preserves the original shared file', async () => {
        const x = await setup({ original: 'original config', kind: 'baseline' });
        await activateFiles('beta', x.betaId);
        await x.reviseBeta(x.betaId, 1, [
            { scriptId: x.script.id, content: Buffer.from('set sv_voice "0"\n') }
        ]);
        await activateFiles('beta', x.betaId);
        expect(await readFile(x.path, 'utf8')).toContain('set sv_voice "0"');
        const result = await x.rollbackBeta(x.betaId);
        await activateFiles('campaign', result.deploymentId!);
        expect(await readFile(x.path, 'utf8')).toBe('original config');
    });

    it.each([
        'stale',
        'identical',
        'empty',
        'unbundled',
        'duplicate',
        'closed',
        'deleted',
        'interrupted',
        'activating'
    ])('rejects %s updates without saving a revision', async (reason) => {
        const x = await setup();
        const upload = { scriptId: x.script.id, content: Buffer.from('changed') };
        if (reason === 'identical')
            upload.content = Buffer.from(
                (await import('../../src/lib/server/fleet/scripts.js')).getVersionContent(
                    x.version.id
                )
            );
        if (reason === 'empty') upload.content = Buffer.alloc(0);
        if (reason === 'unbundled') upload.scriptId = 999;
        if (reason === 'closed')
            x.db.prepare("UPDATE betas SET state = 'promoted' WHERE id = ?").run(x.betaId);
        if (reason === 'deleted')
            x.db
                .prepare('UPDATE beta_servers SET server_deleted_at = ? WHERE beta_id = ?')
                .run(new Date().toISOString(), x.betaId);
        if (reason === 'interrupted')
            x.db.prepare("UPDATE staged_file_changes SET state = 'applying'").run();
        if (reason === 'activating') {
            const { requestRestart } =
                await import('../../src/lib/server/provisioning/requests.js');
            const job = requestRestart(names[0], { kind: 'beta', id: String(x.betaId) });
            x.db
                .prepare("UPDATE server_deployments SET state = 'running' WHERE id = ?")
                .run(job.id);
        }
        await expect(
            x.reviseBeta(
                x.betaId,
                reason === 'stale' ? 2 : 1,
                reason === 'duplicate' ? [upload, upload] : [upload]
            )
        ).rejects.toThrow();
        expect(x.db.prepare('SELECT * FROM beta_revisions').all()).toEqual([]);
        expect(x.listVersions(x.script.id)).toHaveLength(1);
        expect(x.listBetaScripts(x.betaId)[0].script_version_id).toBe(x.version.id);
    });

    it('keeps the new revision through reload, and uses its deadline rather than the beta opening time', async () => {
        const x = await setup();
        x.db.prepare('UPDATE betas SET opened_at = ?').run('2000-01-01T00:00:00Z');
        x.db.prepare("UPDATE beta_test_plans SET outcome = 'inconclusive'").run();
        await x.reviseBeta(x.betaId, 1, [
            { scriptId: x.script.id, content: Buffer.from('changed') }
        ]);
        const { closeDb } = await import('../../src/lib/server/db/index.js');
        closeDb();
        const { plannedBetaTick } =
            await import('../../src/lib/server/pipeline/beta-plan-runner.js');
        const { testView } = await import('../../src/lib/server/fleet/beta-tests.js');
        await plannedBetaTick();
        expect(testView(x.betaId)?.outcome).toBe('active');
        const { GET } = await import('../../src/routes/api/betas/[id]/+server.js');
        const body = await (await GET({ params: { id: String(x.betaId) } })).json();
        expect(body.revision.revision).toBe(2);
        expect(body.revisions).toHaveLength(2);
    });

    it('supports legacy betas without a test plan', async () => {
        const x = await setup({ legacy: true });
        await activateFiles('beta', x.betaId);
        await x.reviseBeta(x.betaId, 1, [
            { scriptId: x.script.id, content: Buffer.from('changed') }
        ]);
        expect(x.listBetaServers(x.betaId)[0]).toMatchObject({
            stage: 'awaiting-empty',
            match_seen_at: null,
            healthy_at: null
        });
        expect(x.db.prepare('SELECT * FROM beta_test_plans').all()).toHaveLength(0);
    });

    it('rolls back the entire revision when a later upload fails validation', async () => {
        const x = await setup();
        const overlay = x.createScript({
            name: 'Overlay',
            kind: 'config',
            content: Buffer.from('set sv_voice "1"\n'),
            scopeType: 'game',
            scopeValue: 't5'
        });
        x.db
            .prepare(
                "INSERT INTO beta_scripts (beta_id, script_id, script_version_id, kind) VALUES (?, ?, ?, 'config')"
            )
            .run(x.betaId, overlay.script.id, overlay.version.id);
        await expect(
            x.reviseBeta(x.betaId, 1, [
                { scriptId: x.script.id, content: Buffer.from('valid new version') },
                { scriptId: overlay.script.id, content: Buffer.from('invalid config') }
            ])
        ).rejects.toThrow('at least one');
        expect(x.listVersions(x.script.id)).toHaveLength(1);
        expect(x.listVersions(overlay.script.id)).toHaveLength(1);
        expect(x.db.prepare('SELECT * FROM beta_revisions').all()).toEqual([]);
        expect(
            x.listBetaScripts(x.betaId).find((file) => file.script_id === x.script.id)
                ?.script_version_id
        ).toBe(x.version.id);
    });

    it('accepts reviewed multipart updates and downloads immutable revision files', async () => {
        const x = await setup();
        const { POST } = await import('../../src/routes/api/betas/[id]/revisions/+server.js');
        const form = new FormData();
        form.set('expectedRevision', '1');
        form.set('notes', 'Fix scoring');
        form.set(`file:${x.script.id}`, new File(['changed'], 'revision.gsc'));
        const post = () =>
            POST({
                params: { id: String(x.betaId) },
                request: new Request('http://test/revisions', { method: 'POST', body: form })
            });
        expect((await post()).status).toBe(200);
        expect((await post()).status).toBe(409);
        const { GET } =
            await import('../../src/routes/api/betas/[id]/revisions/[revision]/files/[scriptId]/+server.js');
        const download = await GET({
            params: { id: String(x.betaId), revision: '1', scriptId: String(x.script.id) }
        });
        expect(await download.text()).toBe('revision one');
    });
});