import type { RequestHandler } from './$types';
import { json, error } from '@sveltejs/kit';
import { getSurrealDB } from '$lib/server/db';
import { generatePresignedUploadUrl, getCompanyAdPath } from '$lib/server/cloudflare';

/**
 * Génère une URL signée pour que Plainly puisse uploader directement vers R2
 * 
 * POST /api/render/presigned-url
 * Body: { adId: string }
 * 
 * Retourne: { uploadUrl, publicUrl, key, headers }
 */
export const POST: RequestHandler = async ({ request }) => {
  try {
    const { adId } = await request.json();

    if (!adId) {
      throw error(400, 'adId requis');
    }

    const cleanAdId = adId.replace('ad:', '');
    const db = await getSurrealDB();

    // Récupérer la pub et les infos de l'entreprise
    const [adResult] = await db.query<[any[]]>(
      `SELECT *, user.company.r2_folder_name as company_folder FROM type::thing("ad", $adId)`,
      { adId: cleanAdId }
    );

    const ad = adResult?.[0];
    if (!ad) {
      throw error(404, 'Publicité non trouvée');
    }

    // Déterminer le chemin R2
    const filename = `output-${Date.now()}.mp4`;
    let r2Key: string;

    if (ad.company_folder) {
      r2Key = getCompanyAdPath(ad.company_folder, cleanAdId, filename, ad.name);
    } else {
      // Fallback si pas de dossier entreprise
      r2Key = `ads/${cleanAdId}/${filename}`;
    }

    // Générer l'URL signée (valide 2 heures pour laisser le temps au rendu)
    const { uploadUrl, publicUrl, key } = await generatePresignedUploadUrl(
      r2Key,
      'video/mp4',
      7200 // 2 heures
    );

    // Sauvegarder le chemin prévu dans la pub pour référence
    await db.query(
      `UPDATE type::thing("ad", $adId) SET 
        pending_output_key = $key,
        pending_output_url = $publicUrl,
        updated_at = time::now()`,
      { adId: cleanAdId, key, publicUrl }
    );

    console.log(`[Presigned URL] Generated for ad ${cleanAdId}: ${key}`);

    return json({
      uploadUrl,
      publicUrl,
      key,
      headers: {
        'content-type': 'video/mp4'
      }
    });

  } catch (err) {
    console.error('[Presigned URL] Error:', err);
    if (err instanceof Error && 'status' in err) {
      throw err;
    }
    throw error(500, err instanceof Error ? err.message : 'Erreur interne');
  }
};

/**
 * GET pour récupérer l'URL signée via query params (alternative)
 * GET /api/render/presigned-url?adId=xxx
 */
export const GET: RequestHandler = async ({ url }) => {
  const adId = url.searchParams.get('adId');
  
  if (!adId) {
    throw error(400, 'adId requis');
  }

  // Réutiliser la logique POST
  const fakeRequest = new Request(url, {
    method: 'POST',
    body: JSON.stringify({ adId }),
    headers: { 'Content-Type': 'application/json' }
  });

  return POST({ request: fakeRequest, url } as any);
};