import type { PageServerLoad, Actions } from './$types';
import { fail } from '@sveltejs/kit';
import { ListObjectsV2Command, DeleteObjectCommand } from '@aws-sdk/client-s3';
import { getCloudflareR2Client, uploadToR2, getFilePublicUrl } from '$lib/server/cloudflare';
import { serializeData } from '$lib/utils/serialize';
import { env } from '$env/dynamic/private';

export const load: PageServerLoad = async () => {
	try {
		const r2 = getCloudflareR2Client();
		const bucket = env.CLOUDFLARE_R2_BUCKET_NAME;

		if (!bucket) {
			return { files: [] };
		}

		// Lister tous les objets dans le bucket
		const command = new ListObjectsV2Command({
			Bucket: bucket
		});
		const response = await r2.send(command);

		// Créer une map des thumbnails par nom de vidéo
		const thumbnailMap = new Map<string, string>();
		const allObjects = response.Contents || [];
		
		allObjects.forEach((object: any) => {
			const key = object.Key || '';
			if (key.includes('/thumbnails/')) {
				// Extraire le nom de base de la vidéo depuis le thumbnail
				// Format: users/{id}/thumbnails/{timestamp}_{videoName}.jpg
				const match = key.match(/thumbnails\/\d+_(.+)\.\w+$/);
				if (match) {
					const videoName = match[1];
					// Stocker le thumbnail pour ce nom de vidéo
					if (!thumbnailMap.has(videoName) || key > thumbnailMap.get(videoName)!) {
						thumbnailMap.set(videoName, getFilePublicUrl(key));
					}
				}
			}
		});

		const files =
			allObjects.map((object: any) => {
				const key = object.Key || '';
				
				// Ignorer les thumbnails dans la liste principale
				if (key.includes('/thumbnails/')) {
					return null;
				}

				const name = key.split('/').pop() || key;
				const folder = key.includes('/') ? key.split('/')[0] : 'root';
				const extension = name.split('.').pop()?.toLowerCase() || '';

				// Déterminer le type de fichier
				const videoExtensions = ['mp4', 'webm', 'ogg', 'mov', 'avi'];
				const imageExtensions = ['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg'];

				let type = 'unknown';
				if (videoExtensions.includes(extension)) type = 'video';
				else if (imageExtensions.includes(extension)) type = 'image';

				// Chercher le thumbnail pour cette vidéo
				let thumbnailUrl: string | null = null;
				if (type === 'video') {
					const baseName = name.replace(/\.\w+$/, '');
					// Chercher le thumbnail avec le nom exact
					thumbnailUrl = thumbnailMap.get(baseName) || null;
					
					// Si pas trouvé, chercher dans les fichiers un fichier avec le même nom mais .jpg/.png
					if (!thumbnailUrl) {
						const possibleThumbnailKeys = [
							key.replace(/\.\w+$/, '.jpg'),
							key.replace(/\.\w+$/, '.png'),
							key.replace(/\.\w+$/, '_thumb.jpg'),
							key.replace(/\.\w+$/, '_thumbnail.jpg')
						];
						
						for (const possibleKey of possibleThumbnailKeys) {
							if (allObjects.some((o: any) => o.Key === possibleKey)) {
								thumbnailUrl = getFilePublicUrl(possibleKey);
								break;
							}
						}
					}
				}

				return {
					key,
					name,
					folder,
					url: getFilePublicUrl(key),
					thumbnailUrl,
					size: object.Size || 0,
					lastModified: object.LastModified?.toISOString() || '',
					type
				};
			}).filter((f: any) => f !== null) || [];

		return {
			files: serializeData(files)
		};
	} catch (error) {
		console.error('Error listing R2 objects:', error);
		return {
			files: []
		};
	}
};

export const actions: Actions = {
	uploadMedia: async ({ request }) => {
		const formData = await request.formData();
		const files = formData.getAll('files') as File[];
		const folder = formData.get('folder') as string;

		if (!files || files.length === 0) {
			return fail(400, { error: 'Aucun fichier sélectionné' });
		}

		try {
			const uploadedFiles: string[] = [];

			for (const file of files) {
				// Vérifier le type de fichier
				const isVideo = file.type.startsWith('video/');
				const isImage = file.type.startsWith('image/');

				if (!isVideo && !isImage) {
					continue; // Skip non-media files
				}

				// Vérifier la taille (max 50MB)
				const maxSize = 50 * 1024 * 1024;
				if (file.size > maxSize) {
					continue; // Skip files that are too large
				}

				// Générer un nom de fichier unique
				const timestamp = Date.now();
				const extension = file.name.split('.').pop();
				const sanitizedName = file.name
					.split('.')[0]
					.replace(/[^a-zA-Z0-9-_]/g, '_')
					.substring(0, 50);
				const fileName = `${folder}/${sanitizedName}_${timestamp}.${extension}`;

				// Upload vers R2
				await uploadToR2(file, fileName, file.type);

				uploadedFiles.push(fileName);
			}

			if (uploadedFiles.length === 0) {
				return fail(400, { error: 'Aucun fichier valide à uploader' });
			}

			return {
				success: `${uploadedFiles.length} fichier(s) uploadé(s) avec succès`
			};
		} catch (error) {
			console.error('Error uploading files:', error);
			return fail(500, { error: "Erreur lors de l'upload des fichiers" });
		}
	},

	deleteFile: async ({ request }) => {
		const formData = await request.formData();
		const key = formData.get('key') as string;

		if (!key) {
			return fail(400, { error: 'Clé de fichier manquante' });
		}

		try {
			const r2 = getCloudflareR2Client();
			const bucket = env.CLOUDFLARE_R2_BUCKET_NAME;

			if (!bucket) {
				return fail(500, { error: 'Configuration Cloudflare R2 manquante' });
			}

			const command = new DeleteObjectCommand({
				Bucket: bucket,
				Key: key
			});
			await r2.send(command);

			return {
				success: 'Fichier supprimé avec succès'
			};
		} catch (error) {
			console.error('Error deleting file:', error);
			return fail(500, { error: 'Erreur lors de la suppression du fichier' });
		}
	}
};