import { NextResponse } from "next/server";
import { createAdminClient, createClient } from "@/lib/supabase-server";
import { canCompany, getCompanyContext } from "@/lib/company-context";

export const runtime = "nodejs";
export const dynamic = "force-dynamic";
export const revalidate = 0;

async function resolveStorageUrl(admin: ReturnType<typeof createAdminClient>, rawValue: string | null | undefined) {
  const value = String(rawValue || "").trim();
  if (!value) return null;
  if (value.startsWith("data:")) return value;

  const parseStorageTarget = (input: string): { bucket: string; path: string } | null => {
    const normalized = input.replace(/^\/+/, "");

    if (/^https?:\/\//i.test(input)) {
      try {
        const parsed = new URL(input);
        const publicMarker = "/storage/v1/object/public/";
        const signMarker = "/storage/v1/object/sign/";
        const marker = parsed.pathname.includes(signMarker) ? signMarker : publicMarker;
        if (!parsed.pathname.includes(marker)) return null;
        const rest = parsed.pathname.slice(parsed.pathname.indexOf(marker) + marker.length);
        const [bucket, ...parts] = rest.split("/");
        return bucket && parts.length ? { bucket, path: parts.join("/") } : null;
      } catch {
        return null;
      }
    }

    const clean = normalized
      .replace(/^storage\/v1\/object\/public\//, "")
      .replace(/^storage\/v1\/object\/sign\//, "");
    const [bucket, ...parts] = clean.split("/");
    return bucket && parts.length ? { bucket, path: parts.join("/") } : null;
  };

  const target = parseStorageTarget(value);
  if (!target) return value;

  const { data: signedData, error: signedError } = await admin.storage
    .from(target.bucket)
    .createSignedUrl(target.path, 60 * 60 * 24 * 30);

  if (!signedError && signedData?.signedUrl) return signedData.signedUrl;

  const { data: publicData } = admin.storage.from(target.bucket).getPublicUrl(target.path);
  return publicData?.publicUrl || value;
}

export async function GET(req: Request) {
  const supabase = await createClient();
  const {
    data: { user },
  } = await supabase.auth.getUser();

  if (!user) {
    return NextResponse.json({ error: "Não autenticado." }, { status: 401 });
  }

  const ctx = await getCompanyContext(supabase, user);
  if (!canCompany(ctx, user.id, "clients.read")) {
    return NextResponse.json({ error: "Sem permissão." }, { status: 403 });
  }

  const { searchParams } = new URL(req.url);
  const clientId = String(searchParams.get("clientId") || "").trim();
  if (!clientId) {
    return NextResponse.json({ error: "Cliente inválido." }, { status: 400 });
  }

  try {
    const admin = createAdminClient();
    const tenantIds = ctx.tenantIds?.length ? ctx.tenantIds : [ctx.ownerId ?? user.id];
    const { data: client, error } = await admin
      .from("clients")
      .select("id,avatar_url")
      .eq("id", clientId)
      .in("user_id", tenantIds)
      .maybeSingle();

    if (error || !client?.id) {
      return NextResponse.json({ error: "Cliente não encontrado." }, { status: 404 });
    }

    const avatarUrl = await resolveStorageUrl(admin, client.avatar_url);
    return NextResponse.json({ ok: true, avatarUrl });
  } catch {
    return NextResponse.json({ error: "Falha ao resolver avatar do cliente." }, { status: 500 });
  }
}