import { describe, expect, it, vi } from 'vitest';
import { render } from 'svelte/server';
import { writable } from 'svelte/store';
import type { ProvisioningDetail, RecoveryObservation } from '../../src/lib/provisioning-detail.js';
import { provisioningNeedsRefresh } from '../../src/lib/ui/provisioning-presentation.js';
import ProvisioningPage from '../../src/routes/provisioning/[id]/+page.svelte';

vi.mock('$app/stores', () => ({
    page: writable({
        url: new URL('http://localhost/provisioning/operation-a'),
        data: { user: null }
    })
}));
vi.mock('$app/navigation', () => ({ goto: vi.fn() }));

const start = '2026-10-09T12:00:00Z';
const finish = '2026-10-09T12:01:00Z';
function fixture(state = 'done', recovery: RecoveryObservation | null = null): ProvisioningDetail {
    return {
        deployment: {
            id: 'operation-a',
            server: 't5_zombie_theater_1',
            action: 'restart',
            state,
            stage: 'Completed',
            server_deleted_at: null,
            server_exists: 1,
            started_at: start,
            finished_at: finish,
            triggered_by: 'watchdog:incident-a',
            requested_by: 'Maxis',
            error: null,
            warnings: '[]'
        },
        generatedAt: finish,
        events: [],
        activity: { total: 0, latestId: null, failureExcerpt: null },
        sources: [
            {
                kind: 'watchdog',
                source_id: 'incident-a',
                label: 'Deleted watchdog incident',
                href: null
            }
        ],
        recipe: null,
        blueprintName: null,
        canResumeCleanup: false,
        canResumeRebuild: false,
        canResumeVerification: false,
        canCancelRemoval: false,
        collection: { id: 'collection-a', name: 'Evening lobbies' },
        progress: {
            version: 1,
            phase: 'verify-game',
            phaseStartedAt: '2026-10-09T12:00:50Z',
            observedAt: finish,
            blocker: null,
            checks: [],
            checkpoints: [],
            command: null,
            recovery,
            recipeStatus: null
        },
        agentOperation: {
            id: 'command-a',
            hostId: 'host-a',
            state: 'completed',
            createdAt: start,
            updatedAt: finish,
            error: null
        },
        capacity: { evaluatedAt: finish, pools: [] },
        warningMessages: []
    };
}
function pageBody(detail: ProvisioningDetail) {
    return render(ProvisioningPage, {
        props: { data: { detail, user: null, setupRequired: false } }
    }).body;
}
function recovery(state: RecoveryObservation['state']): RecoveryObservation {
    return {
        state,
        at: finish,
        message: 'Recovery status updated',
        ...(state === 'transferred' ? { operationId: 'rebuild-a' } : {})
    };
}

describe('provisioning detail summary and technical details', () => {
    it('puts requester, absolute start and one duration above the outcome', () => {
        const body = pageBody(fixture());
        const summary = body.match(/<p\b[^>]*class="operation-summary[^>]*>[\s\S]*?<\/p>/)?.[0];
        expect(summary).toBeDefined();
        expect(summary).toContain('Requested by Maxis');
        expect(summary).toContain('datetime="2026-10-09T12:00:00.000Z"');
        expect(summary).toContain('Oct 9, 2026');
        expect(summary).toContain('took 1m 0s');
        expect(body.indexOf(summary!)).toBeLessThan(body.indexOf('id="outcome-title"'));
        expect(body.match(/1m 0s/g)).toHaveLength(1);
        expect(body).not.toContain('Recorded duration');
        expect(body).not.toContain('Operation outcome');
        expect(body).not.toContain('Updates every 5 seconds');
    });

    it('keeps operation, command and source IDs and copy controls in closed Technical details', () => {
        const body = pageBody(fixture());
        const technical = body.match(
            /<details\b[^>]*class="technical-details[^>]*>[\s\S]*?<\/details>/
        )?.[0];
        expect(technical).toBeDefined();
        expect(technical).toContain('Technical details</summary>');
        expect(technical!.split('>')[0]).not.toMatch(/\bopen\b/);
        const outside = body.replace(technical!, '');
        for (const [value, label] of [
            ['operation-a', 'operation ID'],
            ['command-a', 'agent command ID'],
            ['collection-a', 'collection launch ID'],
            ['incident-a', 'Deleted watchdog incident source ID']
        ]) {
            const code = new RegExp(`<code\\b[^>]*>${value}</code>`);
            expect(technical).toMatch(code);
            expect(outside).not.toMatch(code);
            expect(technical).toContain(`aria-label="Copy ${label}"`);
            expect(outside).not.toContain(`aria-label="Copy ${label}"`);
        }
        expect(technical).toContain('Copy link');
        expect(outside).not.toContain('Copy link');
        expect(technical).toContain('datetime="2026-10-09T12:01:00.000Z"');
        expect(outside).toContain('href="/collections/launches/collection-a"');
        expect(outside).toContain('Source record no longer available');
    });

    it('shows one elapsed duration for active work and preserves phase timing and freshness', () => {
        const detail = fixture('running');
        detail.deployment.finished_at = null;
        const body = pageBody(detail);
        expect(body).toContain('1m 0s elapsed');
        expect(body.match(/1m 0s/g)).toHaveLength(1);
        expect(body).not.toContain('Total elapsed');
        expect(body).toContain('Time in phase');
        expect(body).toContain('10s');
        expect(body).toContain('Last evaluated');
        expect(body).toContain('Updates every 5 seconds');
    });

    it('does not invent a duration when the finish time is missing', () => {
        const detail = fixture('interrupted');
        detail.deployment.finished_at = null;
        const body = pageBody(detail);
        expect(body).toContain('Duration: Not recorded');
        expect(body).not.toContain('took ');
        expect(body).not.toContain(' elapsed');
        expect(body).not.toContain('Updates every 5 seconds');
    });
});

describe('provisioning refresh policy', () => {
    it.each(['queued', 'waiting', 'running', 'awaiting-health'])(
        'refreshes %s operations',
        (state) => {
            expect(provisioningNeedsRefresh(fixture(state))).toBe(true);
        }
    );

    it.each(['done', 'failed', 'interrupted', 'warning', 'cancelled'])(
        'stops refreshing %s operations without held recovery',
        (state) => {
            const detail = fixture(state);
            expect(provisioningNeedsRefresh(detail)).toBe(false);
            for (const value of ['released', 'transferred', 'unknown'] as const) {
                detail.progress!.recovery = recovery(value);
                expect(provisioningNeedsRefresh(detail)).toBe(false);
            }
            detail.progress = null;
            expect(provisioningNeedsRefresh(detail)).toBe(false);
        }
    );

    it.each(['released', 'transferred'] as const)(
        'keeps failed restart recovery refreshing until %s without marking it live',
        (state) => {
            const detail = fixture('failed', recovery('held'));
            expect(provisioningNeedsRefresh(detail)).toBe(true);
            const held = pageBody(detail);
            expect(held).toContain('Recovery capacity held');
            expect(held).not.toContain('Updates every 5 seconds');
            expect(held).not.toContain('View recovery operation');

            detail.progress!.recovery = recovery(state);
            expect(provisioningNeedsRefresh(detail)).toBe(false);
            const settled = pageBody(detail);
            expect(settled).not.toContain('Recovery capacity held');
            expect(settled).not.toContain('Updates every 5 seconds');
            expect(settled).toContain(
                state === 'released' ? 'Recovery capacity released' : 'Recovery transferred'
            );
            if (state === 'transferred') {
                expect(settled).toContain('href="/provisioning/rebuild-a"');
                expect(settled).toContain('View recovery operation');
            }
        }
    );
});