import { json } from '@sveltejs/kit';
import type { RequestHandler } from './$types';
import { getSurrealDB } from '$lib/server/db';
import { uploadToR2, getCompanyR2Path, generateAdFolderName } from '$lib/server/cloudflare';

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

	const userId = locals.user.id.replace('user:', '');
	const status = url.searchParams.get('status');

	const db = await getSurrealDB();

	try {
		let query = 'SELECT * FROM ad WHERE user = type::thing("user", $userId)';
		const params: Record<string, any> = { userId };

		if (status) {
			query += ' AND status = $status';
			params.status = status;
		}

		query += ' ORDER BY updated_at DESC';

		const result = await db.query<[any[]]>(query, params);
		const ads = result[0] || [];

		// Récupérer les formats pour chaque publicité
		for (const ad of ads) {
			const adId = typeof ad.id === 'string' ? ad.id.replace('ad:', '') : ad.id?.id || ad.id;
			const formatsResult = await db.query<[any[]]>(
				'SELECT * FROM ad_format WHERE ad = type::thing("ad", $adId)',
				{ adId }
			);
			ad.formats = formatsResult[0] || [];
		}

		return json({ ads });
	} catch (error) {
		console.error('Error fetching ads:', error);
		return json({ error: 'Erreur serveur' }, { status: 500 });
	}
};

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

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

	try {
		const body = await request.json();
		const { name, description, creation_method, ad_type } = body;

		if (!name || !name.trim()) {
			return json({ error: 'Le nom est requis' }, { status: 400 });
		}

		if (!creation_method || !['template', 'upload', 'editor'].includes(creation_method)) {
			return json({ error: 'Méthode de création invalide' }, { status: 400 });
		}

		const db = await getSurrealDB();

		// Créer la publicité
		const adData: Record<string, any> = {
			user: `user:${userId}`,
			name: name.trim(),
			description: description || null,
			creation_method,
			ad_type: ad_type || null,
			status: 'draft',
			content: null,
			thumbnail_url: null
		};

		// Construire les champs dynamiquement pour éviter d'envoyer NULL
		const fields: string[] = [
			'user: type::thing("user", $userId)',
			'name: $name',
			'creation_method: $creation_method',
			'status: "draft"',
			'created_at: time::now()',
			'updated_at: time::now()'
		];
		
		const params: Record<string, any> = {
			userId,
			name: adData.name,
			creation_method: adData.creation_method
		};

		// Ajouter les champs optionnels seulement s'ils ont une valeur
		if (adData.description) {
			fields.push('description: $description');
			params.description = adData.description;
		}

		if (adData.ad_type) {
			fields.push('ad_type: $ad_type');
			params.ad_type = adData.ad_type;
		}

		if (adData.content) {
			fields.push('content: $content');
			params.content = adData.content;
		}

		if (adData.thumbnail_url) {
			fields.push('thumbnail_url: $thumbnail_url');
			params.thumbnail_url = adData.thumbnail_url;
		}

		const result = await db.query<[any[]]>(
			`CREATE ad CONTENT { ${fields.join(', ')} }`,
			params
		);

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

		if (!ad) {
			return json({ error: 'Erreur lors de la création' }, { status: 500 });
		}

		// Créer le dossier R2 pour cette pub
		try {
			const adId = typeof ad.id === 'string' 
				? ad.id.replace('ad:', '') 
				: ad.id?.id || ad.id;
			
			// Générer le nom du dossier avec le nom de la pub
			const adFolderName = generateAdFolderName(adData.name, adId);
			console.log(`[Ads] Creating folder for ad ${adFolderName}...`);
			
			// Récupérer le r2_folder_name de l'entreprise
			const [userResult] = await db.query<[any[]]>(
				`SELECT company.r2_folder_name FROM user WHERE id = type::thing("user", $userId)`,
				{ userId }
			);
			const r2FolderName = userResult?.[0]?.company?.r2_folder_name;
			console.log(`[Ads] r2FolderName: ${r2FolderName}`);
			
			if (r2FolderName) {
				const adFolderPath = `${getCompanyR2Path(r2FolderName)}/ads/${adFolderName}`;
				await uploadToR2(Buffer.from(''), `${adFolderPath}/.gitkeep`, 'text/plain');
				console.log(`[Ads] Created folder: ${adFolderPath}`);
			} else {
				console.log(`[Ads] No r2_folder_name found for user ${userId}`);
			}
		} catch (folderErr) {
			console.warn('[Ads] Could not create ad folder:', folderErr);
		}

		return json({ ad }, { status: 201 });
	} catch (error) {
		console.error('Error creating ad:', error);
		return json({ error: 'Erreur serveur' }, { status: 500 });
	}
};