import type { PageServerLoad } from './$types';
import { getSurrealDB } from '$lib/server/db';
import { serializeData } from '$lib/utils/serialize';

const PAGE_LOAD_TIMEOUT_MS = 1500;

const withTimeout = async <T>(
	promise: Promise<T>,
	ms: number,
	label: string
): Promise<T> => {
	return new Promise<T>((resolve, reject) => {
		const timer = setTimeout(() => {
			reject(new Error(`Timeout ${label} after ${ms}ms`));
		}, ms);

		promise
			.then((value) => {
				clearTimeout(timer);
				resolve(value);
			})
			.catch((error) => {
				clearTimeout(timer);
				reject(error);
			});
	});
};

export const load: PageServerLoad = async ({ locals }) => {
	const userId = locals.user?.id;
	
	const fallbackData = {
		folders: [],
		media: [],
		currentFolder: null,
		currentUserId: userId?.replace('user:', '') || null,
		stats: { images: 0, videos: 0, audio: 0, documents: 0, total_size: 0 }
	};
	
	if (!userId) {
		return fallbackData;
	}
	
	const cleanUserId = userId.replace('user:', '');
	
	try {
		const db = await withTimeout(
			getSurrealDB(),
			PAGE_LOAD_TIMEOUT_MS,
			"getSurrealDB for media page"
		);
		// Note: schema v2 n'a pas de champ company sur media, on filtre par user uniquement
		// Exclure les fichiers .gitkeep de la médiathèque
		const mediaQuery = `
			SELECT * 
			FROM media 
			WHERE user = type::thing("user", $userId)
				AND name != ".gitkeep"
				AND (original_name IS NONE OR original_name != ".gitkeep")
			ORDER BY created_at DESC
		`;
		
		const userIdForQuery = cleanUserId;
		const mediaResult = await withTimeout(
			db.query<[any[]]>(mediaQuery, { userId: userIdForQuery }),
			PAGE_LOAD_TIMEOUT_MS,
			"query media"
		);

		// Charger les dossiers de l'utilisateur
		const foldersResult = await withTimeout(
			db.query<[any[]]>(
				'SELECT * FROM media_folder WHERE user = type::thing("user", $userId) ORDER BY name ASC',
				{ userId: cleanUserId }
			),
			PAGE_LOAD_TIMEOUT_MS,
			"query media folders"
		);

		// Statistiques globales
		const statsQuery = `
			SELECT 
				count(SELECT * FROM media WHERE user = type::thing("user", $userId) AND type = "image") as images,
				count(SELECT * FROM media WHERE user = type::thing("user", $userId) AND type = "video") as videos,
				count(SELECT * FROM media WHERE user = type::thing("user", $userId) AND type = "audio") as audio,
				count(SELECT * FROM media WHERE user = type::thing("user", $userId) AND type = "document") as documents,
				math::sum((SELECT size_bytes FROM media WHERE user = type::thing("user", $userId)).size_bytes) as total_size
			FROM ONLY {}
		`;
		
		const statsResult = await withTimeout(
			db.query<[{ images: number; videos: number; audio: number; documents: number; total_size: number }[]]>(
				statsQuery,
				{ userId: cleanUserId }
			),
			PAGE_LOAD_TIMEOUT_MS,
			"query media stats"
		);
		
		return {
			folders: serializeData(foldersResult[0] || []),
			media: serializeData(mediaResult[0] || []),
			currentFolder: null,
			currentUserId: cleanUserId,
			stats: statsResult[0]?.[0] || { images: 0, videos: 0, audio: 0, documents: 0, total_size: 0 }
		};
	} catch (error) {
		console.error('Error loading media:', error);
		console.error('Error details:', JSON.stringify(error));
		return {
			folders: [],
			media: [],
			currentFolder: null,
			currentUserId: cleanUserId,
			stats: { images: 0, videos: 0, audio: 0, documents: 0, total_size: 0 }
		};
	}
};