import { NextResponse } from "next/server";
import { createClient as createSupabaseClient } from "@supabase/supabase-js";
import { buildPublicUrl, resolvePublicOrigin } from "@/lib/request-origin";
import { origemDaRequisicao, tentativaPermitida } from "@/lib/limite-de-tentativas";
import { createAdminClient } from "@/lib/supabase-admin";
import { caminhoNaLoja, enderecoDaPassagem, origemDaLoja } from "@/lib/passagem-do-login";

function sanitizeNextPath(slug: string, value: string | null | undefined) {
  const next = String(value || "").trim();
  if (!next) return null;
  if (!next.startsWith("/")) return null;
  if (next.startsWith("//")) return null;
  if (!next.startsWith(`/${slug}`)) return null;
  return next;
}

export async function POST(request: Request) {
  try {
    const body = (await request.json()) as {
      slug?: string;
      access_token?: string;
      next?: string;
      origem?: string | null;
      vinculo?: string | null;
    };
    const slug = String(body?.slug || "").trim();
    const accessToken = String(body?.access_token || "").trim();
    const next = String(body?.next || "").trim();

    if (!slug || !accessToken) {
      return NextResponse.json({ error: "Dados de autenticação inválidos." }, { 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 });
    }

    if (!tentativaPermitida(`portal-google:${origemDaRequisicao(request)}`, 20, 15 * 60)) {
      return NextResponse.json({ error: "Muitas tentativas. Aguarde alguns minutos e tente de novo." }, { status: 429 });
    }

    const supabase = createSupabaseClient(url, anon);
    const { data: authData, error: authError } = await supabase.auth.getUser(accessToken);
    if (authError || !authData?.user?.email) {
      return NextResponse.json({ error: "Não foi possível validar o login Google." }, { status: 401 });
    }

    const email = String(authData.user.email || "").trim().toLowerCase();
    if (!email) {
      return NextResponse.json({ error: "Conta Google sem e-mail válido." }, { status: 401 });
    }

    const forwardedFor = request.headers.get("x-forwarded-for") || "";
    const ip = forwardedFor.split(",")[0]?.trim() || "";
    const userAgent = request.headers.get("user-agent") || "";

    const { data, error } = await supabase.rpc("client_portal_google_login", {
      p_slug: slug,
      p_email: email,
      p_user_agent: userAgent,
      p_ip: ip,
    });
    if (error || !data?.session_token) {
      return NextResponse.json(
        {
          error: error?.message || "Não foi possível entrar com o Google nesta loja.",
        },
        { status: 403 }
      );
    }

    /* Loja em dominio proprio: o cliente saiu de la para o Google e precisa
       voltar para la, onde esta o carrinho. A sessao nao viaja na URL: vai
       uma passagem de uso unico, presa ao navegador dele (migration 163). Se
       a passagem nao sair, ele fica logado aqui, como era antes. */
    let enderecoDeVolta: string | null = null;
    const loja = origemDaLoja(body?.origem);
    const vinculo = String(body?.vinculo || "").trim();
    if (loja && vinculo && loja.origem !== new URL(resolvePublicOrigin(request)).origin) {
      try {
        const admin = createAdminClient();
        const { data: codigo, error: erroDaPassagem } = await admin.rpc("client_portal_criar_passagem", {
          p_slug: slug,
          p_session_token: String(data.session_token),
          p_dominio: loja.dominio,
          p_vinculo: vinculo,
          p_ip: ip,
        });
        if (!erroDaPassagem && typeof codigo === "string" && codigo) {
          enderecoDeVolta = enderecoDaPassagem(loja.origem, codigo, caminhoNaLoja(slug, next));
        }
      } catch {
        enderecoDeVolta = null;
      }
    }

    const sanitizedNext = sanitizeNextPath(slug, next);
    const redirectUrl = buildPublicUrl(request, sanitizedNext || `/${slug}/cliente`);
    if (redirectUrl.pathname.startsWith(`/${slug}/cliente`)) {
      redirectUrl.searchParams.set("portal_token", String(data.session_token));
    }

    const response = NextResponse.json({ ok: true, redirect_url: enderecoDeVolta || redirectUrl.toString() });
    response.cookies.set({
      name: "ks_client_portal",
      value: String(data.session_token),
      httpOnly: true,
      secure: process.env.NODE_ENV === "production",
      sameSite: "lax",
      path: "/",
      maxAge: 60 * 60 * 24 * 15,
    });
    return response;
  } catch (err) {
    const message =
      typeof err === "object" && err && "message" in err && typeof err.message === "string"
        ? err.message
        : "Falha ao concluir login com Google.";
    return NextResponse.json({ error: message }, { status: 500 });
  }
}