import { json } from '@sveltejs/kit';
import { serverTitle } from '$lib/ui/server-labels.js';
import { db } from '$lib/server/db/index.js';

export async function GET({ url }: { url: URL }) {
    const activeOnly = url.searchParams.get('active') === 'true';
    const historyOnly = url.searchParams.get('view') === 'history';
    const server = url.searchParams.get('server');
    const query = (url.searchParams.get('q') ?? '').slice(0, 100).toLowerCase();
    const limit = Math.min(500, Math.max(1, Math.floor(Number(url.searchParams.get('limit')) || 25)));
    const offset = Math.min(1_000_000, Math.max(0, Math.floor(Number(url.searchParams.get('offset')) || 0)));
    const active = `EXISTS (SELECT 1 FROM deployment_servers a WHERE a.deployment_id=d.id AND a.server_deleted_at IS NULL AND a.restart_state IN ('pending','failed'))`;
    const names = query ? (db().prepare('SELECT DISTINCT server FROM deployment_servers').all() as { server: string }[])
        .map(row => row.server).filter(name => `${name} ${serverTitle(name)}`.toLowerCase().includes(query)) : [];
    const where = `(? IS NULL OR EXISTS (SELECT 1 FROM deployment_servers target WHERE target.deployment_id=d.id AND target.server=?))
        ${activeOnly ? `AND ${active}` : historyOnly ? `AND NOT ${active}` : ''}
        ${query ? `AND EXISTS (SELECT 1 FROM deployment_servers target WHERE target.deployment_id=d.id AND target.server IN (${names.map(() => '?').join(',') || 'NULL'}))` : ''}`;
    const parameters = [server, server, ...names];
    const { total } = db().prepare(`SELECT COUNT(*) AS total FROM deployments d WHERE ${where}`).get(...parameters) as { total: number };

    const deployments = db()
        .prepare(
            `SELECT d.id, d.action, d.started_at, d.finished_at, d.triggered_by,
                    d.script_id, d.script_version_id, d.prior_version_id, d.beta_id, d.rolled_back_by,
                    s.name AS script_name, sv.version AS script_version,
                    pv.version AS prior_version
             FROM deployments d
             LEFT JOIN scripts s ON s.id = d.script_id
             LEFT JOIN script_versions sv ON sv.id = d.script_version_id
             LEFT JOIN script_versions pv ON pv.id = d.prior_version_id
             WHERE ${where}
             ORDER BY d.started_at DESC, d.rowid DESC
             LIMIT ? OFFSET ?`
        )
        .all(...parameters, limit, offset) as Array<{
        id: string;
        action: string;
        started_at: string;
        finished_at: string | null;
        triggered_by: string | null;
        script_id: number | null;
        script_version_id: number | null;
        prior_version_id: number | null;
        beta_id: number | null;
        rolled_back_by: string | null;
        script_name: string | null;
        script_version: number | null;
        prior_version: number | null;
    }>;

    const ids = deployments.map(deployment => deployment.id);
    if (!ids.length) return json({ deployments: [], total, limit, offset });
    const placeholders = ids.map(() => '?').join(',');
    const serversByDep = db()
        .prepare(
            `SELECT deployment_id, server, server_deleted_at, files_changed, restart_state, players, checked_at, restarted_at, attempts, error
             FROM deployment_servers WHERE deployment_id IN (${placeholders})`
        )
        .all(...ids) as Array<{
        deployment_id: string;
        server: string;
        server_deleted_at: string | null;
        files_changed: number;
        restart_state: string;
        players: number | null;
        checked_at: string | null;
        restarted_at: string | null;
        attempts: number;
        error: string | null;
    }>;

    const grouped = new Map<string, typeof serversByDep>();
    for (const s of serversByDep) {
        const arr = grouped.get(s.deployment_id) ?? [];
        arr.push(s);
        grouped.set(s.deployment_id, arr);
    }

    const scriptRows = db()
        .prepare(
            `SELECT ds.deployment_id, ds.script_id, s.name AS script_name,
                    sv.version AS script_version, pv.version AS prior_version
             FROM deployment_scripts ds
             LEFT JOIN scripts s ON s.id = ds.script_id
             LEFT JOIN script_versions sv ON sv.id = ds.script_version_id
             LEFT JOIN script_versions pv ON pv.id = ds.prior_version_id
             WHERE ds.deployment_id IN (${placeholders})`
        )
        .all(...ids) as Array<{
        deployment_id: string;
        script_id: number;
        script_name: string | null;
        script_version: number | null;
        prior_version: number | null;
    }>;
    const scriptsByDep = new Map<string, typeof scriptRows>();
    for (const s of scriptRows) {
        const arr = scriptsByDep.get(s.deployment_id) ?? [];
        arr.push(s);
        scriptsByDep.set(s.deployment_id, arr);
    }

    const rows = deployments
        .map((d) => ({
            ...d,
            servers: grouped.get(d.id) ?? [],
            scripts: scriptsByDep.get(d.id) ?? []
        }))
        .filter((d) => (activeOnly ? d.servers.some((s) => !s.server_deleted_at && (s.restart_state === 'pending' || s.restart_state === 'failed')) : true));

    return json({ deployments: rows, total, limit, offset });
}