import type { Metadata } from "next";
import { cookies } from "next/headers";
import { notFound, redirect } from "next/navigation";
import { createAdminClient } from "@/lib/supabase-admin";
import { getSupabaseClient } from "@/lib/supabase";
import StoreLayout from "@/components/StoreLayout";
import CatalogCheckoutClient from "@/components/CatalogCheckoutClient";
import { applyPreferredAddressToClient } from "@/lib/client-portal-addresses";
import { lerVisaoDaLoja } from "@/lib/loja/visao.server";
import { carregarPagamento, meiosDoLocal } from "@/lib/provedor-de-pagamento";

async function resolveClientAvatarUrl(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;

  try {
    const admin = createAdminClient();
    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;
  } catch {
    return value;
  }
}

type SessionPayload = {
  client?: {
    id: string;
    name?: string | null;
    company_name?: string | null;
    document?: string | null;
    email?: string | null;
    avatar_url?: string | null;
    phone?: string | null;
    whatsapp?: string | null;
    address_zip?: string | null;
    address_street?: string | null;
    address_number?: string | null;
    address_complement?: string | null;
    address_neighborhood?: string | null;
    address_city?: string | null;
    address_state?: string | null;
    notes?: string | null;
    addresses?: Array<{
      id: string;
      label?: string | null;
      recipient_name?: string | null;
      phone?: string | null;
      zip?: string | null;
      street?: string | null;
      number?: string | null;
      complement?: string | null;
      neighborhood?: string | null;
      city?: string | null;
      state?: string | null;
      reference?: string | null;
      is_default?: boolean | null;
      created_at?: string | null;
      updated_at?: string | null;
    }> | null;
  } | null;
};

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

export async function generateMetadata(props: {
  params: Promise<{ slug: string }>;
}): Promise<Metadata> {
  const params = await props.params;
  const slug = params.slug;
  const supabase = getSupabaseClient();
  const { data: profile } = await supabase
    .from("profiles")
    .select("catalog_name,store_name")
    .eq("slug", slug)
    .maybeSingle();

  const storeName = profile?.catalog_name || profile?.store_name || "Loja";

  return {
    title: { absolute: `Checkout | ${storeName}` },
    description: `Finalize seu pedido na loja ${storeName}.`,
  };
}

export default async function CatalogCheckoutPage(props: {
  params: Promise<{ slug: string }>;
}) {
  const params = await props.params;
  const slug = params.slug;
  const cookieStore = await cookies();
  const token = cookieStore.get("ks_client_portal")?.value || "";

  const supabase = getSupabaseClient();
  const { data: profile, error: profileError } = await supabase
    .from("profiles")
    .select("*")
    .eq("slug", slug)
    .single();

  if (profileError || !profile?.id) {
    notFound();
  }

  if (!token) {
    redirect(`/${slug}/cliente/login?next=${encodeURIComponent(`/${slug}/checkout`)}`);
  }

  const sessionResult = await supabase.rpc("client_portal_get_session", {
    p_slug: slug,
    p_session_token: token,
  });
  const sessionPayload = (sessionResult.data || null) as SessionPayload | null;

  if (sessionResult.error || !sessionPayload?.client) {
    redirect(`/${slug}/cliente/login?next=${encodeURIComponent(`/${slug}/checkout`)}`);
  }

  /* O checkout com pagamento so existe na loja que vende pelo carrinho. Loja
     em pausa, pedido de orcamento ou cadastro em analise voltam para a vitrine. */
  const { visao } = await lerVisaoDaLoja(slug, profile);
  if (!visao.podeComprar || visao.modoDeCompra !== "cart") {
    redirect(`/${slug}`);
  }

  const checkoutClient = applyPreferredAddressToClient(
    sessionPayload.client || {},
    sessionPayload.client?.addresses || []
  );

  let clientAvatarUrl = await resolveClientAvatarUrl(checkoutClient.avatar_url as string | null | undefined);
  try {
    const admin = createAdminClient();
    const { data: clientRecord } = await admin
      .from("clients")
      .select("avatar_url")
      .eq("id", checkoutClient.id)
      .maybeSingle();
    clientAvatarUrl = (await resolveClientAvatarUrl(clientRecord?.avatar_url)) || clientAvatarUrl;
  } catch {
    // Fallback silencioso
  }

  /* Loja que cobra online precisa do e-mail do cliente (o Mercado Pago e o
     Asaas não cobram sem ele). A tela pede antes, a mesma regra do servidor. */
  const cobraOnline = await carregarPagamento(createAdminClient() as never, String(profile.id))
    .then((estado) => meiosDoLocal(estado, "loja").length > 0)
    .catch(() => false);

  const storeName = profile.catalog_name || profile.store_name || "Loja";
  const logoUrl = profile.catalog_logo_url || profile.logo_url || "";
  const primaryColor = profile.primary_color || "#4425A7";

  return (
    <StoreLayout
      primaryColor={primaryColor}
      whatsappNumber={profile.whatsapp || undefined}
      cartScope={profile.id || slug}
      storeSlug={slug}
      theme={profile.catalog_theme}
      visao={visao}
    >
      <CatalogCheckoutClient
        slug={slug}
        cobraOnline={cobraOnline}
        storeName={storeName}
        logoUrl={logoUrl}
        primaryColor={primaryColor}
        headerColor={profile.catalog_header_color || primaryColor}
        headerTextColor={profile.catalog_header_text_color || "#ffffff"}
        menuColor={profile.catalog_menu_color || "#ffffff"}
        menuTextColor={profile.catalog_menu_text_color || "#0f172a"}
        storeSlogan={profile.catalog_slogan || ""}
        showStoreName={profile.catalog_show_name_in_header !== false}
        showStoreSlogan={Boolean(profile.catalog_show_slogan_in_header)}
        client={{
          ...checkoutClient,
          avatar_url: clientAvatarUrl,
        }}
      />
    </StoreLayout>
  );
}