import { randomUUID } from 'node:crypto';
import { db } from '../db/index.js';

type KeyGame = 't5' | 't6';
export interface ServerKey {
    id: string;
    game: KeyGame;
    label: string;
    updated_at: string;
    assigned_servers: string[];
}

function validGame(game: unknown): asserts game is KeyGame {
    if (game !== 't5' && game !== 't6') throw new Error('Choose T5 or T6 for the server key');
}

function normalizedKey(key: unknown): string {
    if (
        typeof key !== 'string' ||
        !key.trim() ||
        key.trim().length > 512 ||
        /\s/.test(key.trim())
    ) {
        throw new Error('Enter a server key without whitespace (maximum 512 characters)');
    }
    return key.trim();
}

function normalizedLabel(label: unknown): string {
    if (typeof label !== 'string' || label.trim().length > 160 || /[\r\n]/.test(label)) {
        throw new Error('Enter a key label with at most 160 characters');
    }
    return label.trim();
}

export function listServerKeys(): ServerKey[] {
    const rows = db()
        .prepare('SELECT id,game,label,updated_at FROM server_keys ORDER BY game,label,id')
        .all() as Omit<ServerKey, 'assigned_servers'>[];
    const assignments = db()
        .prepare(
            `SELECT DISTINCT k.id AS key_id,l.server_id FROM server_keys k
        JOIN server_keys occupied ON occupied.pluto_key=k.pluto_key JOIN server_key_leases l ON l.key_id=occupied.id
        ORDER BY l.server_id`
        )
        .all() as { key_id: string; server_id: string }[];
    const byKey = new Map<string, string[]>();
    for (const lease of assignments) {
        const servers = byKey.get(lease.key_id) ?? [];
        servers.push(lease.server_id);
        byKey.set(lease.key_id, servers);
    }
    return rows.map((row) => ({ ...row, assigned_servers: byKey.get(row.id) ?? [] }));
}

export function getServerKey(serverId: string): string | undefined {
    return (
        db()
            .prepare(
                `SELECT k.pluto_key FROM server_key_leases l
        JOIN server_keys k ON k.id=l.key_id WHERE l.server_id=? AND l.is_current=1`
            )
            .get(serverId) as { pluto_key: string } | undefined
    )?.pluto_key;
}

/** Saving a credential twice cannot increase available capacity. */
export function saveServerKey(game: unknown, key: unknown, label?: unknown): string {
    validGame(game);
    const credential = normalizedKey(key);
    const keyLabel = label === undefined ? undefined : normalizedLabel(label);
    return db()
        .transaction(() => {
            const existing = db()
                .prepare('SELECT id FROM server_keys WHERE game=? AND pluto_key=?')
                .get(game, credential) as { id: string } | undefined;
            if (existing) {
                if (keyLabel !== undefined)
                    db()
                        .prepare(
                            "UPDATE server_keys SET label=?,updated_at=datetime('now') WHERE id=?"
                        )
                        .run(keyLabel, existing.id);
                return existing.id;
            }
            const id = randomUUID();
            db()
                .prepare('INSERT INTO server_keys(id,game,label,pluto_key) VALUES(?,?,?,?)')
                .run(id, game, keyLabel ?? '', credential);
            return id;
        })
        .immediate();
}

// Compare the credential as well as its row: a mistakenly imported copy in
// another game's pool must not permit simultaneous use of the same key.
const availableKey = `NOT EXISTS (SELECT 1 FROM server_key_leases l
    JOIN server_keys occupied ON occupied.id=l.key_id
    WHERE occupied.pluto_key=k.pluto_key AND (l.server_id!=@server OR l.is_current=0))`;

export function serverKeyPool(
    game: KeyGame,
    serverId?: string
): { total: number; available: number } {
    validGame(game);
    return db()
        .prepare(
            `SELECT COUNT(*) AS total,
        COALESCE(SUM(CASE WHEN ${availableKey} THEN 1 ELSE 0 END),0) AS available
        FROM server_keys k WHERE k.game=@game`
        )
        .get({ game, server: serverId ?? '' }) as { total: number; available: number };
}

export function availableServerKeyCount(game: KeyGame): number {
    return serverKeyPool(game).available;
}

/** Called within launch admission; the write lock prevents competing launches sharing a key. */
export function reserveServerKey(serverId: string, game: KeyGame, suppliedKey?: unknown): string {
    validGame(game);
    if (!serverId) throw new Error('Choose a server for the key reservation');
    const credential =
        suppliedKey === undefined ||
        suppliedKey === null ||
        (typeof suppliedKey === 'string' && !suppliedKey.trim())
            ? undefined
            : normalizedKey(suppliedKey);
    return db()
        .transaction(() => {
            const existing = db()
                .prepare(
                    `SELECT k.game,k.pluto_key FROM server_key_leases l
            JOIN server_keys k ON k.id=l.key_id WHERE l.server_id=? AND l.is_current=1`
                )
                .get(serverId) as { game: KeyGame; pluto_key: string } | undefined;
            if (existing) {
                if (existing.game !== game)
                    throw new Error('This server already has a key reserved for another game');
                if (credential && credential !== existing.pluto_key)
                    throw new Error(
                        'This server already has a reserved key; destroy it before changing its key'
                    );
                return existing.pluto_key;
            }
            const requestedId = credential ? saveServerKey(game, credential) : null;
            const key = db()
                .prepare(
                    `SELECT k.id,k.pluto_key FROM server_keys k WHERE k.game=@game
            AND (@requestedId IS NULL OR k.id=@requestedId) AND ${availableKey}
            ORDER BY k.updated_at,k.id LIMIT 1`
                )
                .get({ game, server: serverId, requestedId }) as
                { id: string; pluto_key: string } | undefined;
            if (!key)
                throw new Error(
                    credential
                        ? 'This server key is already reserved by another server'
                        : `No available ${game.toUpperCase()} server keys. Add a key or destroy a server to release one.`
                );
            db()
                .prepare('INSERT INTO server_key_leases(server_id,key_id) VALUES(?,?)')
                .run(serverId, key.id);
            return key.pluto_key;
        })
        .immediate();
}

/** Only after confirmed destruction or a creation cancelled before any host mutation. */
export function releaseServerKey(serverId: string): boolean {
    return (
        db().prepare('DELETE FROM server_key_leases WHERE server_id=?').run(serverId).changes > 0
    );
}

export function removeServerKey(id: string): boolean {
    return db()
        .transaction(() => {
            if (
                db()
                    .prepare(
                        `SELECT 1 FROM server_keys k JOIN server_keys occupied ON occupied.pluto_key=k.pluto_key
            JOIN server_key_leases l ON l.key_id=occupied.id WHERE k.id=?`
                    )
                    .get(id)
            ) {
                throw new Error(
                    'This key is reserved by a server. Destroy that server before removing its key.'
                );
            }
            return db().prepare('DELETE FROM server_keys WHERE id=?').run(id).changes > 0;
        })
        .immediate();
}