import { json } from '@sveltejs/kit';
import type { RequestHandler } from './$types';
import { getSurrealDB } from '$lib/server/db';
import { uploadToR2 } from '$lib/server/cloudflare';
import { createMediaRecord, getMediaType } from '$lib/server/media';
import { generateThumbnail, getVideoMetadata } from '$lib/server/ffmpeg';
import { Buffer } from 'buffer';

export const POST: RequestHandler = async ({ params, request, locals }) => {
	if (!locals.user) {
		return json({ error: 'Non autorisé' }, { status: 401 });
	}

	const adId = params.id;
	const userId = locals.user.id.replace('user:', '');

	try {
		const formData = await request.formData();
		const file = formData.get('file') as File;

		if (!file) {
			return json({ error: 'Fichier manquant' }, { status: 400 });
		}

		// Vérifier que l'utilisateur a accès à cette pub
		const db = await getSurrealDB();
		const adResult = await db.query<[any[]]>(
			'SELECT * FROM type::thing("ad", $adId)',
			{ adId }
		);

		const ad = adResult[0]?.[0];

		if (!ad) {
			return json({ error: 'Publicité non trouvée' }, { status: 404 });
		}

		const adUserId = typeof ad.user === 'string' 
			? ad.user.replace('user:', '') 
			: ad.user?.id || ad.user;

		if (adUserId !== userId) {
			return json({ error: 'Accès refusé' }, { status: 403 });
		}

		// Récupérer la company de l'utilisateur
		const userResult = await db.query<[any[]]>(
			'SELECT company FROM user WHERE id = type::thing("user", $userId)',
			{ userId }
		);
		const userCompany = userResult[0]?.[0]?.company;
		const companyId = userCompany 
			? (typeof userCompany === 'string' ? userCompany.replace('company:', '') : userCompany.id?.replace?.('company:', '') || userCompany.id)
			: null;

		// Upload vers R2
		const fileName = `ads/${adId}/${file.name}`;
		const fileResult = await uploadToR2(file, fileName, file.type);
		const fileUrl = fileResult.url;
		
		// Générer thumbnail pour les vidéos
		let thumbnailUrl: string | null = null;
		let videoMetadata: any = null;
		const mediaType = getMediaType(file.type);
		
		console.log('Upload direct - Type de fichier:', file.type, 'Type média:', mediaType);
		
		if (mediaType === 'video') {
			try {
				console.log('Début génération thumbnail pour vidéo uploadée...');
				// Convertir File en Buffer
				const arrayBuffer = await file.arrayBuffer();
				const buffer = Buffer.from(arrayBuffer);
				
				// Générer le thumbnail
				const thumbnailBuffer = await generateThumbnail(buffer, 1);
				console.log('Thumbnail buffer généré, taille:', thumbnailBuffer.length);
				
				// Extraire les métadonnées
				videoMetadata = await getVideoMetadata(buffer);
				console.log('Métadonnées vidéo:', videoMetadata);
				
				// Upload du thumbnail vers R2
				const thumbnailKey = `thumbnails/${userId}/${Date.now()}_${file.name.replace(/\.[^/.]+$/, '')}_thumb.jpg`;
				const thumbnailResult = await uploadToR2(
						new File([new Uint8Array(thumbnailBuffer)], 'thumbnail.jpg', { type: 'image/jpeg' }),
					thumbnailKey,
					'image/jpeg'
				);
				thumbnailUrl = thumbnailResult.url;
				
				console.log('Thumbnail généré pour upload direct:', thumbnailUrl);
			} catch (thumbErr) {
				console.error('ERREUR: Could not generate thumbnail for video:', thumbErr);
				// Ne pas bloquer si le thumbnail échoue
			}
		}

		// Sauvegarder dans la médiathèque avec thumbnail
		try {
			console.log('Creating media record with:', {
				userId,
				companyId,
				name: `${ad.name} - Vidéo`,
				originalName: file.name,
				type: mediaType,
				mimeType: file.type,
				url: fileUrl,
				cloudflareKey: fileResult.key,
				thumbnailUrl,
				sizeBytes: file.size
			});
			
			await createMediaRecord({
				userId,
				companyId,
				name: `${ad.name} - Vidéo`,
				originalName: file.name,
				type: mediaType,
				mimeType: file.type,
				url: fileUrl,
				cloudflareKey: fileResult.key,
				thumbnailUrl: thumbnailUrl || undefined,
				sizeBytes: file.size,
				...(videoMetadata && {
					width: videoMetadata.width,
					height: videoMetadata.height,
					durationSeconds: videoMetadata.duration,
					metadata: videoMetadata
				})
			});
		} catch (mediaErr) {
			console.error('Error creating media record:', mediaErr);
			// Ne pas bloquer si l'ajout à la médiathèque échoue
		}

		// Mettre à jour la publicité avec thumbnail
		const content = {
			url: fileUrl,
			thumbnail_url: thumbnailUrl,
			uploaded_at: new Date().toISOString(),
			file_name: file.name,
			file_size: file.size,
			file_type: file.type,
			...(videoMetadata && { metadata: videoMetadata })
		};

		const updateResult = await db.query<[any[]]>(
			`UPDATE type::thing("ad", $adId) SET 
				content = $content,
				thumbnail_url = $thumbnailUrl,
				output_url = $fileUrl,
				status = "ready",
				updated_at = time::now()`,
			{ adId, content, thumbnailUrl, fileUrl }
		);

		const updatedAd = updateResult[0]?.[0];

		return json({ ad: updatedAd }, { status: 200 });
	} catch (error) {
		console.error('Error uploading video:', error);
		return json({ error: 'Erreur lors de l\'upload' }, { status: 500 });
	}
};