import { cookies } from "next/headers";
import { NextResponse } from "next/server";
import { createClient as createSupabaseClient } from "@supabase/supabase-js";
import { createAdminClient } from "@/lib/supabase-admin";

export async function POST(request: Request) {
  try {
    const cookieStore = await cookies();
    const token = cookieStore.get("ks_client_portal")?.value || "";
    if (!token) {
      return NextResponse.json({ error: "Sessão inválida." }, { status: 401 });
    }

    const formData = await request.formData();
    const slug = String(formData.get("slug") || "").trim();
    const avatar = formData.get("avatar");

    if (!slug) {
      return NextResponse.json({ error: "Loja inválida." }, { status: 400 });
    }
    if (!(avatar instanceof File)) {
      return NextResponse.json({ error: "Arquivo inválido." }, { status: 400 });
    }
    if (!avatar.type.startsWith("image/")) {
      return NextResponse.json({ error: "Envie uma imagem válida." }, { status: 400 });
    }
    if (avatar.size > 5 * 1024 * 1024) {
      return NextResponse.json({ error: "A imagem deve ter até 5MB." }, { status: 400 });
    }

    const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
    const anon = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
    if (!url || !anon) {
      return NextResponse.json({ error: "Configuração do Supabase ausente." }, { status: 500 });
    }

    const supabase = createSupabaseClient(url, anon);
    const { data: sessionData, error: sessionError } = await supabase.rpc("client_portal_get_session", {
      p_slug: slug,
      p_session_token: token,
    });

    const clientId = sessionData?.client?.id as string | undefined;
    if (sessionError || !clientId) {
      return NextResponse.json({ error: "Sessão inválida." }, { status: 401 });
    }

    let admin;
    try {
      admin = createAdminClient();
    } catch {
      return NextResponse.json(
        {
          error:
            "Configuração do storage ausente no servidor. Defina `SUPABASE_SERVICE_ROLE_KEY` para salvar avatares.",
        },
        { status: 500 }
      );
    }
    const { data: bucketData } = await admin.storage.getBucket("client-avatars");
    if (!bucketData) {
      const { error: createBucketError } = await admin.storage.createBucket("client-avatars", {
        public: false,
        fileSizeLimit: 5 * 1024 * 1024,
        allowedMimeTypes: ["image/jpeg", "image/jpg", "image/png", "image/webp"],
      });
      if (createBucketError) {
        return NextResponse.json(
          {
            error:
              createBucketError.message?.includes("row-level security")
                ? "O bucket de avatares não pôde ser preparado porque o servidor não está usando uma service role válida no Supabase."
                : `Não foi possível preparar o storage: ${createBucketError.message}`,
          },
          { status: 400 }
        );
      }
    }

    const extension = avatar.name.includes(".") ? avatar.name.split(".").pop() : "jpg";
    const safeExtension = String(extension || "jpg")
      .toLowerCase()
      .replace(/[^a-z0-9]/g, "");
    const path = `${slug}/${clientId}/avatar.${safeExtension || "jpg"}`;

    const arrayBuffer = await avatar.arrayBuffer();
    const { error: uploadError } = await admin.storage
      .from("client-avatars")
      .upload(path, Buffer.from(arrayBuffer), {
        contentType: avatar.type || "image/jpeg",
        upsert: true,
      });

    if (uploadError) {
      return NextResponse.json({ error: `Não foi possível enviar a foto: ${uploadError.message}` }, { status: 400 });
    }

    const storedAvatarValue = `client-avatars/${path}`;

    const { data: signedData, error: signedError } = await admin.storage
      .from("client-avatars")
      .createSignedUrl(path, 60 * 60 * 24 * 365);
    if (signedError || !signedData?.signedUrl) {
      return NextResponse.json(
        { error: `Não foi possível gerar URL da foto: ${signedError?.message || "falha desconhecida"}` },
        { status: 400 }
      );
    }
    const avatarUrl = signedData.signedUrl;

    const { data: updatedClient, error: updateError } = await admin
      .from("clients")
      .update({ avatar_url: storedAvatarValue })
      .eq("id", clientId)
      .select("id,avatar_url")
      .maybeSingle();

    if (updateError || !updatedClient) {
      const reason = updateError?.message || "nenhum registro foi atualizado";
      return NextResponse.json({ error: `Não foi possível salvar a foto: ${reason}` }, { status: 400 });
    }

    return NextResponse.json({ ok: true, avatar_url: avatarUrl });
  } catch (err) {
    const message =
      typeof err === "object" && err && "message" in err && typeof err.message === "string"
        ? err.message
        : "Não foi possível atualizar a foto.";
    return NextResponse.json({ error: message }, { status: 500 });
  }
}