import { selectServerObservation } from '$lib/server-observation.js';
import { derived, writable } from 'svelte/store';
import { browser } from '$app/environment';
import { statusByServer, statusReceivedAt, syncServerTime, matchEventsByServer, telemetryByServer, uiNow } from './servers.js';
import { type FleetServer, type FleetOperation } from '$lib/fleet-overview.js';

export const fleet = writable<{ servers: FleetServer[]; operations: FleetOperation[]; receivedAt: number }>({
    servers: [], operations: [], receivedAt: 0
});
export const fleetError = writable('');
export const fleetRefreshing = writable(false);
export const fleetIntegrations = writable<{ rcon: boolean; komodo: boolean; rconTimeoutMs: number; defaultRconHost: string } | null>(null);

export const fleetServers = derived([fleet, statusByServer, statusReceivedAt, matchEventsByServer, telemetryByServer, uiNow], ([snapshot, live, received, matches, reports, now]) =>
    snapshot.servers.map(server => {
        const status = received > snapshot.receivedAt ? live.get(server.name) : undefined;
        const base = status ? { ...server, last_players: status.players, last_map: status.map,
            last_gametype: status.gametype, last_seen_at: status.lastSeenAt, last_error: status.lastError,
            roster: status.roster, health: status.health, endpoint: status.endpoint, replySnippet: status.replySnippet, active_since: status.activeSince,
            inactive_since: status.inactiveSince, game_started_at: status.gameStartedAt,
            game_ended_at: status.gameEndedAt, container_state: status.containerState ?? server.container_state,
            container_checked_at: status.containerCheckedAt ?? server.container_checked_at,
            telemetry_after: status.telemetryAfter ?? server.telemetry_after, rcon_status: status.rconStatus,
            telemetry: status.telemetry ?? server.telemetry } : server;
        const current = selectServerObservation(base, reports.get(server.name), now);
        const match = matches.get(server.name);
        // Apply lifecycle events immediately, until a newer status observes them
        // or confirms that the lobby has emptied.
        if (!match || current.health !== 'online'
            || (current.telemetry_after && Date.parse(match.receivedAt) <= Date.parse(current.telemetry_after))
            || Date.parse(match.receivedAt) <= Date.parse(current.last_seen_at ?? '')
            || match.receivedAt < (current.game_started_at ?? '')
            || match.receivedAt < (current.game_ended_at ?? '')) return current;
        return { ...current, game_started_at: match.event === 'game_start' ? match.receivedAt : current.game_started_at,
            game_ended_at: match.event === 'game_end' ? match.receivedAt : null };
    }));

let inFlight: Promise<void> | null = null;
export function refreshFleet(): Promise<void> {
    if (!browser) return Promise.resolve();
    if (inFlight) return inFlight;
    inFlight = (async () => {
        fleetRefreshing.set(true);
        const controller = new AbortController();
        const timeout = setTimeout(() => controller.abort(), 12_000);
        const requestedAt = Date.now();
        try {
            const responses = await Promise.all([
                fetch('/api/servers', { signal: controller.signal }),
                fetch('/api/fleet', { signal: controller.signal })
            ]);
            if (responses.some(response => !response.ok)) throw new Error('Could not refresh Fleet. Retrying automatically.');
            const [servers, operations] = await Promise.all(responses.map(response => response.json()));
            syncServerTime(servers.serverNow);
            fleetError.set('');
            fleetIntegrations.set(servers.integrations);
            fleet.set({ servers: servers.servers, operations: operations.operations, receivedAt: requestedAt });
        } catch (error) {
            fleetError.set(error instanceof Error && error.name !== 'AbortError'
                ? error.message : 'Fleet refresh timed out. Retrying automatically.');
        } finally {
            clearTimeout(timeout);
            fleetRefreshing.set(false);
        }
    })().finally(() => { inFlight = null; });
    return inFlight;
}

let stop: (() => void) | null = null;
export function startFleetMonitor(): () => void {
    if (!browser || stop) return () => {};
    void refreshFleet();
    const interval = setInterval(() => {
        if (document.visibilityState !== 'hidden') void refreshFleet();
    }, 10_000);
    const onFocus = () => { if (document.visibilityState === 'visible') void refreshFleet(); };
    document.addEventListener('visibilitychange', onFocus);
    stop = () => {
        clearInterval(interval);
        document.removeEventListener('visibilitychange', onFocus);
        stop = null;
    };
    return stop;
}