import { describe, expect, it } from 'vitest';
import type { CollectionPreview, LaunchAvailability } from '../../src/lib/deployment-plan.js';
import { zombieMapBySlug, type ZombieGame } from '../../src/lib/map-aliases.js';
import { collectionCapacitySummary, collectionKeyCoverage, collectionMapGroups } from '../../src/lib/ui/collection-summary.js';

function entry(game: ZombieGame, mapSlug: string, count: number, existingServers: string[] = []): CollectionPreview['entries'][number] {
    const map = zombieMapBySlug(game, mapSlug)!;
    return { count, existing: existingServers.length, missing: Math.max(0, count - existingServers.length), existingServers,
        coverage: existingServers.map(name => ({ name, health: 'stopped', href: `/servers/${name}` })),
        recipe: { game, mapSlug, mapName: map.friendly, expectedMap: map.canonical, capturedAt: '', image: 'runtime:latest',
            configFile: 'server.cfg', configSource: 'Current setup', files: [], fingerprint: '' } };
}

function preview(overrides: Partial<CollectionPreview> = {}): CollectionPreview {
    return { id: 'preview', expiresAt: '2030-01-01T00:00:00Z', blueprintName: 'Collection', launchConcurrency: 1,
        mode: 'fill', retainedServers: [], removals: [], entries: [], servers: [], blockers: [], ready: true, ...overrides };
}

function capacity(overrides: Partial<LaunchAvailability> = {}): LaunchAvailability {
    return { requested: 5, estimatedAvailable: null, updatedAt: null, portsAvailable: null, cpuCoresAvailable: null,
        memoryBytesAvailable: null, startupSlots: null, startupLimit: null, queued: null, ...overrides };
}

describe('collection key coverage', () => {
    it('counts coverage separately by game without treating removals as available keys', () => {
        const plan = preview({ mode: 'exact', entries: [entry('t5', 'theater', 2), entry('t6', 'town', 1)],
            removals: [{ name: 't5_zombie_moon_1', reason: 'Outside collection' }], servers: [
                { entryIndex: 0, name: 't5_zombie_theater_1', hasSavedKey: true, port: null },
                { entryIndex: 0, name: 't5_zombie_theater_2', hasSavedKey: false, port: null },
                { entryIndex: 1, name: 't6_zombie_town_1', hasSavedKey: true, port: null },
            ] });
        expect(collectionKeyCoverage(plan)).toEqual([
            { game: 't5', label: 'Black Ops I', required: 2, available: 1, unassigned: 0 },
            { game: 't6', label: 'Black Ops II', required: 1, available: 1, unassigned: 0 },
        ]);
    });

    it('counts an unavailable lobby as required but never covered, and omits games without creations', () => {
        expect(collectionKeyCoverage(preview({ entries: [entry('t5', 'theater', 1), entry('t6', 'town', 1)],
            servers: [{ entryIndex: 1, name: null, hasSavedKey: true, port: null }] }))).toEqual([
            { game: 't6', label: 'Black Ops II', required: 1, available: 0, unassigned: 1 },
        ]);
        expect(collectionKeyCoverage(preview({ mode: 'exact', removals: [{ name: 't5_zombie_theater_1', reason: 'Remove' }] }))).toEqual([]);
    });

    it('distinguishes known key shortages from creations waiting for a lobby', () => {
        const [pool] = collectionKeyCoverage(preview({ entries: [entry('t5', 'theater', 3)], servers: [
            { entryIndex: 0, name: 't5_zombie_theater_19', hasSavedKey: true, port: null },
            { entryIndex: 0, name: 't5_zombie_theater_20', hasSavedKey: false, port: null },
            { entryIndex: 0, name: null, hasSavedKey: false, port: null },
        ] }));
        expect(pool).toMatchObject({ required: 3, available: 1, unassigned: 1 });
        expect(pool.required - pool.unassigned - pool.available).toBe(1);
    });
});

describe('collection map summaries', () => {
    it('preserves full existing counts in fill mode, including stopped inventory and excess lobbies', () => {
        const plan = preview({ entries: [entry('t5', 'theater', 1, ['t5_zombie_theater_1', 't5_zombie_theater_2']), entry('t5', 'moon', 2)] });
        expect(collectionMapGroups(plan)).toEqual([{ game: 't5', label: 'Black Ops I', rows: [
            { key: 't5:theater', mapName: 'Kino Der Toten', target: 1, existing: 2, create: 0, remove: 0 },
            { key: 't5:moon', mapName: 'Moon', target: 2, existing: 0, create: 2, remove: 0 },
        ] }]);
    });

    it('counts ordinary excess once and adds already-pending removals missing from backend coverage', () => {
        const plan = preview({ mode: 'exact', entries: [entry('t5', 'theater', 1, ['t5_zombie_theater_1', 't5_zombie_theater_2'])],
            retainedServers: ['t5_zombie_theater_1'], removals: [
                { name: 't5_zombie_theater_2', reason: 'Excess' },
                { name: 't5_zombie_theater_3', reason: 'Already awaiting removal' },
            ] });
        expect(collectionMapGroups(plan)[0].rows).toEqual([
            { key: 't5:theater', mapName: 'Kino Der Toten', target: 1, existing: 3, create: 0, remove: 2 },
        ]);
    });

    it('shows outside maps with target zero across both games without combining T6 variants', () => {
        const plan = preview({ mode: 'exact', entries: [entry('t6', 'town', 1, ['t6_zombie_town_1'])],
            retainedServers: ['t6_zombie_town_1'], removals: [
                { name: 't5_zombie_moon_1', reason: 'Outside collection' },
                { name: 't6_zombie_farm_1', reason: 'Outside collection' },
                { name: 't6_zombie_bus_depot_survival_1', reason: 'Outside collection' },
            ] });
        expect(collectionMapGroups(plan)).toEqual([
            { game: 't5', label: 'Black Ops I', rows: [{ key: 't5:moon', mapName: 'Moon', target: 0, existing: 1, create: 0, remove: 1 }] },
            { game: 't6', label: 'Black Ops II', rows: [
                { key: 't6:town', mapName: 'Town Survival', target: 1, existing: 1, create: 0, remove: 0 },
                { key: 't6:farm', mapName: 'Farm Survival', target: 0, existing: 1, create: 0, remove: 1 },
                { key: 't6:busdepot', mapName: 'Bus Depot Survival', target: 0, existing: 1, create: 0, remove: 1 },
            ] },
        ]);
    });

    it('uses authoritative coverage before names and resolves friendly legacy aliases', () => {
        const plan = preview({ mode: 'exact', entries: [entry('t6', 'town', 1, ['custom-town', 't6_zombie_town_1']), entry('t5', 'theater', 1, ['t5_zombie_theater_1'])],
            removals: [{ name: 'custom-town', reason: 'Excess' }, { name: 'T5_ZOMBIE_KINO_DER_TOTEN_2', reason: 'Awaiting removal' }] });
        expect(collectionMapGroups(plan).map(group => group.rows)).toEqual([
            [{ key: 't5:theater', mapName: 'Kino Der Toten', target: 1, existing: 2, create: 0, remove: 1 }],
            [{ key: 't6:town', mapName: 'Town Survival', target: 1, existing: 2, create: 0, remove: 1 }],
        ]);
    });

    it('keeps unknown removals visible without guessing a shared engine-map variant', () => {
        const plan = preview({ mode: 'exact', removals: [
            { name: 't6_zombie_zm_transit_1', reason: 'Unknown variant' },
            { name: 'custom-instance', reason: 'Outside collection' },
        ] });
        expect(collectionMapGroups(plan)).toEqual([
            { game: 't6', label: 'Black Ops II', rows: [{ key: 't6:server:t6_zombie_zm_transit_1', mapName: 't6_zombie_zm_transit_1', target: 0, existing: 1, create: 0, remove: 1 }] },
            { game: null, label: 'Other servers', rows: [{ key: 'other:server:custom-instance', mapName: 'custom-instance', target: 0, existing: 1, create: 0, remove: 1 }] },
        ]);
    });
});

describe('collection capacity summary', () => {
    it('keeps unknown and insufficient capacity queueable', () => {
        expect(collectionCapacitySummary()).toBe('Capacity estimate unavailable; launches can wait for capacity.');
        expect(collectionCapacitySummary(capacity())).toBe('Capacity estimate unavailable; launches can wait for capacity.');
        expect(collectionCapacitySummary(capacity({ estimatedAvailable: 0 }))).toBe('Estimated capacity for 0 of 5 servers; launches can wait for capacity.');
        expect(collectionCapacitySummary(capacity({ estimatedAvailable: 2 }))).toBe('Estimated capacity for 2 of 5 servers; launches can wait for capacity.');
        expect(collectionCapacitySummary(capacity({ requested: 1, estimatedAvailable: 0 }))).toBe('Estimated capacity for 0 of 1 server; launches can wait for capacity.');
    });

    it('uses requested counts when enough capacity exists and handles plans without creations', () => {
        expect(collectionCapacitySummary(capacity({ estimatedAvailable: 20 }))).toBe('Estimated capacity for all 5 servers.');
        expect(collectionCapacitySummary(capacity({ requested: 1, estimatedAvailable: 1 }))).toBe('Estimated capacity for 1 server.');
        expect(collectionCapacitySummary(capacity({ requested: 0 }))).toBe('No new server capacity needed.');
    });
});