// app/api/auth/bootstrap/route.ts
export const runtime = "nodejs";

import { NextResponse } from "next/server";
import { createClient } from "@supabase/supabase-js";

/**
 * POST /api/auth/bootstrap
 * Headers: Authorization: Bearer <access_token>
 * Retourne le contexte société à stocker côté client (localStorage).
 *
 * Stratégie:
 * 1) On récupère l'utilisateur via l'access_token.
 * 2) On lit d'abord user_metadata.{default_company_name, default_company_api_name}.
 * 3) (Optionnel) Si absent, tu peux appeler ta Lambda interne pour déduire la structure depuis l'email/user_id.
 * 4) On renvoie { company: { name, api_name, name_b64 } }.
 */
export async function POST(req: Request) {
  try {
    const auth = req.headers.get("authorization") || "";
    const token = auth.toLowerCase().startsWith("bearer ") ? auth.slice(7) : null;
    if (!token) {
      return NextResponse.json({ error: "missing_token" }, { status: 401 });
    }

    const supabaseUrl = process.env.SUPABASE_URL!;
    const serviceKey = process.env.SUPABASE_SERVICE_ROLE_KEY!;
    if (!supabaseUrl || !serviceKey) {
      return NextResponse.json({ error: "misconfigured_supabase" }, { status: 500 });
    }

    // Client admin (server-side)
    const admin = createClient(supabaseUrl, serviceKey, {
      auth: { autoRefreshToken: false, persistSession: false },
    });

    // 1) Récupérer l'utilisateur à partir de l'access_token
    const { data: userRes, error: userErr } = await admin.auth.getUser(token);
    if (userErr || !userRes?.user) {
      return NextResponse.json({ error: "invalid_token" }, { status: 401 });
    }

    const user = userRes.user;
    const meta = (user.user_metadata || {}) as Record<string, any>;

    // 2) Lire le client par défaut depuis les metadata (recommandé)
    let companyName: string | null = meta.default_company_name ?? null;
    let companyApi: string | null = meta.default_company_api_name ?? null;

    // 3) (Optionnel) Déduire depuis ta Lambda si les metadata ne sont pas présentes
    // 👉 Décommente et adapte à ton endpoint si tu veux ce fallback automatique
    //
    // if (!companyName || !companyApi) {
    //   try {
    //     const base = process.env.NEXT_PUBLIC_API_BASE || process.env.API_BASE;
    //     if (base) {
    //       const resp = await fetch(`${base}/get-structure-for-user`, {
    //         method: "POST",
    //         headers: { "Content-Type": "application/json" },
    //         body: JSON.stringify({ email: user.email, user_id: user.id }),
    //       });
    //       if (resp.ok) {
    //         const j = await resp.json();
    //         companyName = j?.name || companyName;
    //         companyApi  = j?.api_name || companyApi;
    //       }
    //     }
    //   } catch {
    //     // silencieux : on reste sur metadata si la Lambda n'est pas dispo
    //   }
    // }

    if (!companyName || !companyApi) {
      // Rien trouvé → on renvoie une 404 pour que le front affiche un message/CTA
      return NextResponse.json({ error: "no_company_found" }, { status: 404 });
    }

    const companyNameB64 = Buffer.from(companyName, "utf8").toString("base64");

    return NextResponse.json({
      ok: true,
      company: {
        name: companyName,
        api_name: companyApi,
        name_b64: companyNameB64,
      },
    });
  } catch (e: any) {
    return NextResponse.json({ error: "server_error", message: e?.message || "unknown" }, { status: 500 });
  }
}