import { json } from "@sveltejs/kit";
import type { RequestHandler } from "./$types";
import { getSurrealDB } from "$lib/server/db";
import type { Company } from "$lib/types";

// GET: Récupérer les informations de l'entreprise
export const GET: RequestHandler = async ({ locals }) => {
  if (!locals.user || !locals.company) {
    return json({ error: "Non autorisé" }, { status: 401 });
  }

  try {
    const db = await getSurrealDB();
    
    // Récupérer les données complètes de l'entreprise
    // Ensure we pass the raw id (without prefix) to the query
    const companyId = locals.company.id;
    const rawCompanyId = companyId.replace('company:', '');

    const result = await db.query<[Company[]]>(
      `SELECT * FROM company WHERE id = type::thing("company", $companyId)`,
      { companyId: rawCompanyId }
    );

    const company = result[0]?.[0];
    if (!company) {
      return json({ error: "Entreprise non trouvée" }, { status: 404 });
    }

    return json({ company });
  } catch (error) {
    console.error("Erreur lors de la récupération de l'entreprise:", error);
    return json(
      { error: "Erreur lors de la récupération des données" },
      { status: 500 }
    );
  }
};

// PATCH: Mettre à jour les informations de l'entreprise
export const PATCH: RequestHandler = async ({ request, locals }) => {
  if (!locals.user || !locals.company) {
    return json({ error: "Non autorisé" }, { status: 401 });
  }

  // Vérifier que l'utilisateur a les droits de modifier l'entreprise
  if (locals.user.company_role !== "owner" && locals.user.company_role !== "admin") {
    return json({ error: "Permissions insuffisantes" }, { status: 403 });
  }

  try {
    const data = await request.json();
    const db = await getSurrealDB();
    
    // Extraire l'ID brut de l'entreprise (sans le préfixe "company:")
    const companyId = locals.company.id;
    const rawCompanyId = companyId.replace('company:', '');

    // Construire l'objet de mise à jour avec seulement les champs autorisés
    const updates: Record<string, any> = {};
    
    if (typeof data.name === "string") {
      updates.name = data.name.trim();
    }
    
    if (typeof data.siret === "string") {
      const siretValue = data.siret.trim();
      if (siretValue) {
        // Vérifier que le SIRET n'est pas déjà utilisé par une autre entreprise
        const existingSiret = await db.query<[Company[]]>(
          `SELECT * FROM company WHERE siret = $siret AND id != type::thing("company", $companyId)`,
          { siret: siretValue, companyId: rawCompanyId }
        );
        
        if (existingSiret[0]?.length > 0) {
          return json({ error: "Ce SIRET est déjà utilisé par une autre entreprise" }, { status: 400 });
        }
      }
      updates.siret = siretValue;
    }
    
    if (typeof data.rna === "string") {
      const rnaValue = data.rna.trim();
      if (rnaValue) {
        // Vérifier que le RNA n'est pas déjà utilisé par une autre entreprise
        const existingRna = await db.query<[Company[]]>(
          `SELECT * FROM company WHERE rna = $rna AND id != type::thing("company", $companyId)`,
          { rna: rnaValue, companyId: rawCompanyId }
        );
        
        if (existingRna[0]?.length > 0) {
          return json({ error: "Ce RNA est déjà utilisé par une autre entreprise" }, { status: 400 });
        }
      }
      updates.rna = rnaValue;
    }
    
    if (typeof data.legal_type === "string") {
      updates.legal_type = data.legal_type;
    }
    
    if (typeof data.address === "string") {
      updates.address = data.address.trim();
    }
    
    if (typeof data.postal_code === "string") {
      updates.postal_code = data.postal_code.trim();
    }
    
    if (typeof data.city === "string") {
      updates.city = data.city.trim();
    }
    
    if (typeof data.country === "string") {
      updates.country = data.country;
    }
    
    if (typeof data.phone === "string") {
      updates.phone = data.phone.trim();
    }

    // Effectuer la mise à jour - construire dynamiquement les SET clauses
    // Note: updated_at sera ajouté directement dans la requête avec time::now()
    
    // Construire la requête SET dynamiquement
    const setEntries = Object.entries(updates);
    if (setEntries.length === 0) {
      return json({ error: "Aucune modification à effectuer" }, { status: 400 });
    }
    
    // Créer les clauses SET: field1 = $field1, field2 = $field2, ...
    const setClauses = setEntries.map(([key]) => `${key} = $${key}`).join(', ');
    const queryParams: Record<string, any> = { companyId: rawCompanyId };
    setEntries.forEach(([key, value]) => {
      queryParams[key] = value;
    });
    
    // Ajouter updated_at avec time::now() directement dans la requête (pas comme paramètre string)
    const query = `UPDATE type::thing("company", $companyId) SET ${setClauses}, updated_at = time::now() RETURN AFTER`;
    
    const result = await db.query<[Company[]]>(query, queryParams);

    const updatedCompany = result[0]?.[0];
    if (!updatedCompany) {
      return json({ error: "Erreur lors de la mise à jour" }, { status: 500 });
    }

    return json({ 
      success: true, 
      company: updatedCompany,
      message: "Informations de l'entreprise mises à jour avec succès"
    });
    
  } catch (error) {
    console.error("[PATCH /api/company] Error:", error);
    return json(
      { error: "Erreur lors de la mise à jour des données" },
      { status: 500 }
    );
  }
};