import { createHash, randomBytes, randomUUID } from 'node:crypto';
import type Database from 'better-sqlite3';
import { getMediaFile } from './content.js';
import { getDatabase } from './database.js';
import { renderMarkdown } from './markdown.js';
import { buildEmbedUrl, fetchPresentationImage, type PresentationContent } from './presentation.js';
import {
	getShow,
	movePieceUsage,
	type MovePieceUsageInput,
	type PieceUsage,
	type ShowSection
} from './shows.js';

type LiveStateRow = {
	show_id: string;
	revision: number;
	current_usage_id: string | null;
	started_at_utc: string | null;
	ended_at_utc: string | null;
	presentation_usage_id: string | null;
	presentation_revision: number;
	updated_at_utc: string;
};

type OrderedUsageRow = {
	id: string;
	section_id: string;
	section_name: string;
	section_position: number;
	position: number;
	status: PieceUsage['status'];
};

export type LiveUsage = PieceUsage & {
	sectionId: string;
	sectionName: string;
	actualDurationSeconds: number;
	introHtml: string;
	researchHtml: string;
	moderationHtml: string;
	transitionHtml: string;
};

export type LiveSection = Omit<ShowSection, 'usages'> & { usages: LiveUsage[] };

export type LiveView = {
	show: {
		id: string;
		title: string;
		status: string;
		revision: number;
		totalDurationSeconds: number;
	};
	liveRevision: number;
	startedAtUtc: string | null;
	updatedAtUtc: string;
	presentationUsageId: string | null;
	presentationRevision: number;
	sections: LiveSection[];
	reserve: LiveUsage[];
	current: LiveUsage | null;
	next: LiveUsage | null;
	completedCount: number;
	totalCount: number;
};

export type PresentationView = {
	revision: number;
	content: null | {
		mode: PresentationContent['mode'];
		title: string;
		html: string;
		source: PresentationContent['source'];
		previewTitle: string;
		description: string;
		imageUrl: string;
		siteName: string;
		provider: PresentationContent['provider'];
		providerId: string;
		embedUrl: string;
		sources: { label: string; url: string; timecodeSeconds: number | null }[];
		images: { id: string; altText: string }[];
	};
};

function hashToken(token: string) {
	return createHash('sha256').update(token).digest('hex');
}

function nowIso(now?: Date) {
	return (now ?? new Date()).toISOString();
}

function requireCommandId(commandId: string) {
	if (!commandId || commandId.length > 200) throw new Error('INVALID_COMMAND');
}

function ensureLiveState(database: Database.Database, showId: string, now: string): LiveStateRow {
	const show = database.prepare('SELECT 1 FROM shows WHERE id = ?').get(showId);
	if (!show) throw new Error('NOT_FOUND');
	database
		.prepare(
			`INSERT OR IGNORE INTO show_live_states (show_id, updated_at_utc)
			 VALUES (?, ?)`
		)
		.run(showId, now);
	return database
		.prepare('SELECT * FROM show_live_states WHERE show_id = ?')
		.get(showId) as LiveStateRow;
}

function orderedUsages(database: Database.Database, showId: string): OrderedUsageRow[] {
	return database
		.prepare(
			`SELECT u.id, s.id AS section_id, s.name AS section_name,
			 s.position AS section_position, u.position, u.status
			 FROM piece_usages u JOIN show_sections s ON s.id = u.show_section_id
			 WHERE s.show_id = ? AND s.is_reserve_bank = 0
			 ORDER BY s.position, u.position`
		)
		.all(showId) as OrderedUsageRow[];
}

function usageBelongsToShow(database: Database.Database, showId: string, usageId: string) {
	const row = database
		.prepare(
			`SELECT s.is_reserve_bank FROM piece_usages u
			 JOIN show_sections s ON s.id = u.show_section_id
			 WHERE u.id = ? AND s.show_id = ?`
		)
		.get(usageId, showId) as { is_reserve_bank: number } | undefined;
	if (!row || row.is_reserve_bank) throw new Error('NOT_FOUND');
}

function closeActiveRun(database: Database.Database, showId: string, now: string) {
	database
		.prepare(
			`UPDATE live_usage_runs SET ended_at_utc = ?
			 WHERE show_id = ? AND ended_at_utc IS NULL`
		)
		.run(now, showId);
}

function activateUsage(database: Database.Database, showId: string, usageId: string, now: string) {
	usageBelongsToShow(database, showId, usageId);
	database
		.prepare(
			`UPDATE piece_usages SET status = 'open'
			 WHERE status = 'current' AND id != ? AND id IN (
				SELECT u.id FROM piece_usages u JOIN show_sections s ON s.id = u.show_section_id
				WHERE s.show_id = ?
			 )`
		)
		.run(usageId, showId);
	database.prepare(`UPDATE piece_usages SET status = 'current' WHERE id = ?`).run(usageId);
	database
		.prepare(
			`INSERT INTO live_usage_runs (id, show_id, usage_id, started_at_utc)
			 VALUES (?, ?, ?, ?)`
		)
		.run(randomUUID(), showId, usageId, now);
	database
		.prepare(
			'UPDATE show_live_states SET current_usage_id = ?, ended_at_utc = NULL WHERE show_id = ?'
		)
		.run(usageId, showId);
}

function executeCommand(
	showId: string,
	commandId: string,
	expectedRevision: number,
	action: string,
	operation: (database: Database.Database, state: LiveStateRow, now: string) => void,
	nowValue?: Date
) {
	requireCommandId(commandId);
	const database = getDatabase();
	return database.transaction(() => {
		const duplicate = database
			.prepare('SELECT result_revision FROM live_commands WHERE show_id = ? AND command_id = ?')
			.get(showId, commandId) as { result_revision: number } | undefined;
		if (duplicate) return { revision: duplicate.result_revision, duplicate: true };
		const now = nowIso(nowValue);
		const state = ensureLiveState(database, showId, now);
		const show = database.prepare('SELECT status FROM shows WHERE id = ?').get(showId) as {
			status: string;
		};
		if (show.status === 'completed') throw new Error('SHOW_COMPLETED');
		if (state.revision !== expectedRevision) throw new Error('CONFLICT');
		operation(database, state, now);
		const updated = database
			.prepare(
				`UPDATE show_live_states SET revision = revision + 1, updated_at_utc = ?
				 WHERE show_id = ? AND revision = ?`
			)
			.run(now, showId, expectedRevision);
		if (updated.changes !== 1) throw new Error('CONFLICT');
		const revision = expectedRevision + 1;
		database
			.prepare(
				`INSERT INTO live_commands (show_id, command_id, action, result_revision, created_at_utc)
				 VALUES (?, ?, ?, ?, ?)`
			)
			.run(showId, commandId, action, revision, now);
		return { revision, duplicate: false };
	})();
}

function actualDurations(database: Database.Database, showId: string, now: string) {
	const rows = database
		.prepare(
			`SELECT usage_id, started_at_utc, ended_at_utc
			 FROM live_usage_runs WHERE show_id = ?`
		)
		.all(showId) as { usage_id: string; started_at_utc: string; ended_at_utc: string | null }[];
	const durations = new Map<string, number>();
	for (const row of rows) {
		const seconds = Math.max(
			0,
			Math.floor(
				(new Date(row.ended_at_utc ?? now).getTime() - new Date(row.started_at_utc).getTime()) /
					1000
			)
		);
		durations.set(row.usage_id, (durations.get(row.usage_id) ?? 0) + seconds);
	}
	return durations;
}

function liveUsage(
	usage: PieceUsage,
	sectionId: string,
	sectionName: string,
	actualSeconds: number
) {
	return {
		...usage,
		sectionId,
		sectionName,
		actualDurationSeconds: actualSeconds,
		introHtml: renderMarkdown(usage.intro),
		researchHtml: renderMarkdown(usage.research),
		moderationHtml: renderMarkdown(usage.moderation),
		transitionHtml: renderMarkdown(usage.transition)
	};
}

export function getLiveView(showId: string, nowValue?: Date): LiveView {
	const database = getDatabase();
	const now = nowIso(nowValue);
	const state = ensureLiveState(database, showId, now);
	const show = getShow(showId);
	if (!show) throw new Error('NOT_FOUND');
	const durations = actualDurations(database, showId, now);
	const sections = show.sections.map((section) => ({
		...section,
		usages: section.usages.map((usage) =>
			liveUsage(usage, section.id, section.name, durations.get(usage.id) ?? 0)
		)
	}));
	const reserve = show.reserve.map((usage) =>
		liveUsage(usage, '', 'Reservebank', durations.get(usage.id) ?? 0)
	);
	const usages = sections.flatMap((section) => section.usages);
	const current = usages.find((usage) => usage.id === state.current_usage_id) ?? null;
	const currentIndex = current ? usages.findIndex((usage) => usage.id === current.id) : -1;
	const next =
		usages.slice(currentIndex + 1).find((usage) => usage.status === 'open') ??
		(current ? null : (usages.find((usage) => usage.status === 'open') ?? null));
	return {
		show: {
			id: show.id,
			title: show.title,
			status: show.status,
			revision: show.revision,
			totalDurationSeconds: show.totalDurationSeconds
		},
		liveRevision: state.revision,
		startedAtUtc: state.started_at_utc,
		updatedAtUtc: state.updated_at_utc,
		presentationUsageId: state.presentation_usage_id,
		presentationRevision: state.presentation_revision,
		sections,
		reserve,
		current,
		next,
		completedCount: usages.filter((usage) => usage.status === 'done' || usage.status === 'skipped')
			.length,
		totalCount: usages.length
	};
}

export function startOrResumeLive(
	showId: string,
	commandId: string,
	expectedRevision: number,
	nowValue?: Date
) {
	return executeCommand(
		showId,
		commandId,
		expectedRevision,
		'start',
		(database, state, now) => {
			database
				.prepare(
					`UPDATE shows SET status = 'live', updated_at_utc = ?
					 WHERE id = ? AND status != 'completed'`
				)
				.run(now, showId);
			database
				.prepare(
					`UPDATE show_live_states SET started_at_utc = COALESCE(started_at_utc, ?), ended_at_utc = NULL
					 WHERE show_id = ?`
				)
				.run(now, showId);
			const activeRun = database
				.prepare('SELECT 1 FROM live_usage_runs WHERE show_id = ? AND ended_at_utc IS NULL')
				.get(showId);
			if (state.current_usage_id && activeRun) return;
			const current = state.current_usage_id
				? orderedUsages(database, showId).find((usage) => usage.id === state.current_usage_id)
				: undefined;
			const target =
				current ?? orderedUsages(database, showId).find((usage) => usage.status === 'open');
			if (target) activateUsage(database, showId, target.id, now);
		},
		nowValue
	);
}

function advanceCurrent(
	showId: string,
	commandId: string,
	expectedRevision: number,
	status: 'done' | 'skipped',
	nowValue?: Date
) {
	return executeCommand(
		showId,
		commandId,
		expectedRevision,
		status,
		(database, state, now) => {
			if (!state.current_usage_id) throw new Error('NO_CURRENT');
			const ordered = orderedUsages(database, showId);
			const currentIndex = ordered.findIndex((usage) => usage.id === state.current_usage_id);
			if (currentIndex < 0) throw new Error('NOT_FOUND');
			closeActiveRun(database, showId, now);
			database
				.prepare('UPDATE piece_usages SET status = ? WHERE id = ?')
				.run(status, state.current_usage_id);
			const next = ordered.slice(currentIndex + 1).find((usage) => usage.status === 'open');
			if (next) activateUsage(database, showId, next.id, now);
			else
				database
					.prepare('UPDATE show_live_states SET current_usage_id = NULL WHERE show_id = ?')
					.run(showId);
		},
		nowValue
	);
}

export function completeCurrent(
	showId: string,
	commandId: string,
	expectedRevision: number,
	nowValue?: Date
) {
	return advanceCurrent(showId, commandId, expectedRevision, 'done', nowValue);
}

export function skipCurrent(
	showId: string,
	commandId: string,
	expectedRevision: number,
	nowValue?: Date
) {
	return advanceCurrent(showId, commandId, expectedRevision, 'skipped', nowValue);
}

export function goBack(
	showId: string,
	commandId: string,
	expectedRevision: number,
	nowValue?: Date
) {
	return executeCommand(
		showId,
		commandId,
		expectedRevision,
		'back',
		(database, state, now) => {
			const ordered = orderedUsages(database, showId);
			const currentIndex = state.current_usage_id
				? ordered.findIndex((usage) => usage.id === state.current_usage_id)
				: ordered.length;
			const previous = ordered
				.slice(0, Math.max(0, currentIndex))
				.reverse()
				.find((usage) => usage.status === 'done' || usage.status === 'skipped');
			if (!previous) throw new Error('NO_PREVIOUS');
			if (state.current_usage_id) {
				closeActiveRun(database, showId, now);
				database
					.prepare(`UPDATE piece_usages SET status = 'open' WHERE id = ?`)
					.run(state.current_usage_id);
			}
			activateUsage(database, showId, previous.id, now);
		},
		nowValue
	);
}

export function presentUsage(
	showId: string,
	usageId: string | null,
	commandId: string,
	expectedRevision: number,
	nowValue?: Date
) {
	return executeCommand(
		showId,
		commandId,
		expectedRevision,
		usageId ? 'present' : 'clear-presentation',
		(database, _state, now) => {
			if (usageId) usageBelongsToShow(database, showId, usageId);
			database
				.prepare(
					`UPDATE show_live_states SET presentation_usage_id = ?,
					 presentation_revision = presentation_revision + 1, updated_at_utc = ?
					 WHERE show_id = ?`
				)
				.run(usageId, now, showId);
		},
		nowValue
	);
}

export function moveOpenUsage(
	showId: string,
	usageId: string,
	expectedShowRevision: number,
	input: MovePieceUsageInput
) {
	const database = getDatabase();
	const usage = database
		.prepare(
			`SELECT u.status FROM piece_usages u JOIN show_sections s ON s.id = u.show_section_id
			 WHERE u.id = ? AND s.show_id = ?`
		)
		.get(usageId, showId) as { status: PieceUsage['status'] } | undefined;
	if (!usage) throw new Error('NOT_FOUND');
	if (usage.status !== 'open') throw new Error('LIVE_ORDER_LOCKED');
	if (input.sectionId) {
		const target = database
			.prepare(
				`SELECT u.id, u.status FROM piece_usages u JOIN show_sections s ON s.id = u.show_section_id
				 WHERE s.id = ? AND s.show_id = ? AND s.is_reserve_bank = 0 ORDER BY u.position`
			)
			.all(input.sectionId, showId) as { id: string; status: PieceUsage['status'] }[];
		if (!target.length) {
			const section = database
				.prepare('SELECT 1 FROM show_sections WHERE id = ? AND show_id = ? AND is_reserve_bank = 0')
				.get(input.sectionId, showId);
			if (!section) throw new Error('NOT_FOUND');
		}
		const withoutMoved = target.filter((item) => item.id !== usageId);
		const firstOpenPosition = withoutMoved.findIndex((item) => item.status === 'open');
		const minimum = firstOpenPosition < 0 ? withoutMoved.length : firstOpenPosition;
		if (input.position < minimum) throw new Error('LIVE_ORDER_LOCKED');
	}
	return movePieceUsage(showId, usageId, expectedShowRevision, input);
}

export function issuePresentationAccess(showId: string) {
	const database = getDatabase();
	const now = nowIso();
	ensureLiveState(database, showId, now);
	const token = randomBytes(32).toString('base64url');
	database.transaction(() => {
		database
			.prepare(
				'UPDATE presentation_access_tokens SET revoked_at_utc = ? WHERE show_id = ? AND revoked_at_utc IS NULL'
			)
			.run(now, showId);
		database
			.prepare(
				`INSERT INTO presentation_access_tokens (id, show_id, token_hash, created_at_utc)
				 VALUES (?, ?, ?, ?)`
			)
			.run(randomUUID(), showId, hashToken(token), now);
	})();
	return token;
}

function presentationShowId(database: Database.Database, token: string) {
	if (!token || token.length > 200) return null;
	const row = database
		.prepare(
			`SELECT show_id FROM presentation_access_tokens
			 WHERE token_hash = ? AND revoked_at_utc IS NULL`
		)
		.get(hashToken(token)) as { show_id: string } | undefined;
	return row?.show_id ?? null;
}

export function getPresentationView(token: string): PresentationView | null {
	const database = getDatabase();
	const showId = presentationShowId(database, token);
	if (!showId) return null;
	const state = ensureLiveState(database, showId, nowIso());
	if (!state.presentation_usage_id) return { revision: state.presentation_revision, content: null };
	const usage = database
		.prepare(
			`SELECT u.title_snapshot, u.presentation_snapshot, u.original_piece_id,
			 u.presentation_mode_snapshot, u.presentation_source_label_snapshot,
			 u.presentation_source_url_snapshot, u.presentation_source_timecode_snapshot,
			 u.presentation_title_meta_snapshot, u.presentation_description_snapshot,
			 u.presentation_image_url_snapshot, u.presentation_site_name_snapshot,
			 u.presentation_provider_snapshot, u.presentation_provider_id_snapshot
			 FROM piece_usages u JOIN show_sections s ON s.id = u.show_section_id
			 WHERE u.id = ? AND s.show_id = ? AND s.is_reserve_bank = 0`
		)
		.get(state.presentation_usage_id, showId) as
		| {
				title_snapshot: string;
				presentation_snapshot: string;
				original_piece_id: string | null;
				presentation_mode_snapshot: PresentationContent['mode'];
				presentation_source_label_snapshot: string;
				presentation_source_url_snapshot: string;
				presentation_source_timecode_snapshot: number | null;
				presentation_title_meta_snapshot: string;
				presentation_description_snapshot: string;
				presentation_image_url_snapshot: string;
				presentation_site_name_snapshot: string;
				presentation_provider_snapshot: PresentationContent['provider'];
				presentation_provider_id_snapshot: string;
		  }
		| undefined;
	if (!usage) return { revision: state.presentation_revision, content: null };
	const sources =
		usage.presentation_mode_snapshot === 'text' && usage.original_piece_id
			? (database
					.prepare(
						`SELECT label, url, timecode_seconds AS timecodeSeconds
					 FROM piece_sources WHERE piece_id = ? ORDER BY position`
					)
					.all(usage.original_piece_id) as {
					label: string;
					url: string;
					timecodeSeconds: number | null;
				}[])
			: [];
	const images =
		usage.presentation_mode_snapshot === 'text' && usage.original_piece_id
			? (database
					.prepare(
						`SELECT id, alt_text AS altText FROM piece_media
					 WHERE piece_id = ? ORDER BY position`
					)
					.all(usage.original_piece_id) as { id: string; altText: string }[])
			: [];
	return {
		revision: state.presentation_revision,
		content: {
			mode: usage.presentation_mode_snapshot,
			title: usage.title_snapshot,
			html: renderMarkdown(usage.presentation_snapshot),
			source: usage.presentation_source_url_snapshot
				? {
						label: usage.presentation_source_label_snapshot,
						url: usage.presentation_source_url_snapshot,
						timecodeSeconds: usage.presentation_source_timecode_snapshot
					}
				: null,
			previewTitle: usage.presentation_title_meta_snapshot,
			description: usage.presentation_description_snapshot,
			imageUrl: usage.presentation_image_url_snapshot,
			siteName: usage.presentation_site_name_snapshot,
			provider: usage.presentation_provider_snapshot,
			providerId: usage.presentation_provider_id_snapshot,
			embedUrl: buildEmbedUrl(
				usage.presentation_provider_snapshot,
				usage.presentation_provider_id_snapshot,
				usage.presentation_source_timecode_snapshot
			),
			sources,
			images
		}
	};
}

export async function getPresentationPreviewImage(token: string) {
	const view = getPresentationView(token);
	if (!view?.content?.imageUrl || view.content.mode === 'text') return null;
	try {
		return await fetchPresentationImage(view.content.imageUrl);
	} catch {
		return null;
	}
}

export async function getPresentationMedia(token: string, mediaId: string) {
	const database = getDatabase();
	const showId = presentationShowId(database, token);
	if (!showId) return null;
	const allowed = database
		.prepare(
			`SELECT 1 FROM show_live_states l
			 JOIN piece_usages u ON u.id = l.presentation_usage_id
			 JOIN show_sections s ON s.id = u.show_section_id
			 JOIN piece_media m ON m.piece_id = u.original_piece_id
			 WHERE l.show_id = ? AND s.show_id = ? AND m.id = ?`
		)
		.get(showId, showId, mediaId);
	if (!allowed) return null;
	return getMediaFile(mediaId);
}