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

type SessionPayload = {
  client?: {
    id: string;
    name?: string | null;
    avatar_url?: string | null;
  } | null;
};

export async function POST(req: Request) {
  try {
    const cookieStore = await cookies();
    const token = cookieStore.get("ks_client_portal")?.value || "";
    if (!token) {
      return NextResponse.json({ error: "Faça login para avaliar este produto." }, { status: 401 });
    }

    const body = await req.json();
    const slug = String(body?.slug || "").trim();
    const productId = String(body?.productId || "").trim();
    const reviewId = String(body?.reviewId || "").trim();
    const rating = Number(body?.rating || 0);
    const comment = String(body?.comment || "").trim();

    if (!slug || !productId) {
      return NextResponse.json({ error: "Produto inválido." }, { status: 400 });
    }
    if (!Number.isInteger(rating) || rating < 1 || rating > 5) {
      return NextResponse.json({ error: "Selecione uma nota válida." }, { status: 400 });
    }
    if (comment.length < 8) {
      return NextResponse.json({ error: "Escreva um comentário mais completo." }, { status: 400 });
    }

    const admin = createAdminClient();
    const sessionResult = await admin.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?.id) {
      return NextResponse.json({ error: "Sessão inválida. Faça login novamente." }, { status: 401 });
    }

    const { data: profile } = await admin
      .from("profiles")
      .select("id")
      .eq("slug", slug)
      .maybeSingle();

    if (!profile?.id) {
      return NextResponse.json({ error: "Loja não encontrada." }, { status: 404 });
    }

    const { data: product } = await admin
      .from("products")
      .select("id,name,user_id,active,show_in_catalog")
      .eq("id", productId)
      .eq("user_id", profile.id)
      .maybeSingle();

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

    const editableReviewQuery = admin
      .from("product_reviews")
      .select("id,status")
      .eq("catalog_user_id", profile.id)
      .eq("product_id", productId)
      .eq("client_id", sessionPayload.client.id)
      .in("status", ["pending", "rejected"]);

    const { data: editableReview } = reviewId
      ? await editableReviewQuery.eq("id", reviewId).maybeSingle()
      : await editableReviewQuery.order("created_at", { ascending: false }).limit(1).maybeSingle();

    const reviewPayload = {
      catalog_user_id: profile.id,
      product_id: productId,
      client_id: sessionPayload.client.id,
      rating,
      comment,
      status: "pending" as const,
      moderated_at: null,
      approved_at: null,
      rejected_at: null,
      moderation_notes: null,
    };

    const reviewMutation = editableReview?.id
      ? admin
          .from("product_reviews")
          .update(reviewPayload)
          .eq("id", editableReview.id)
          .select("id,client_id,rating,comment,status,created_at,updated_at")
          .single()
      : admin
          .from("product_reviews")
          .insert(reviewPayload)
          .select("id,client_id,rating,comment,status,created_at,updated_at")
          .single();

    const { data: review, error: reviewError } = await reviewMutation;

    if (reviewError || !review) {
      return NextResponse.json(
        { error: "Não foi possível salvar sua avaliação. Verifique se o SQL já foi executado." },
        { status: 500 }
      );
    }

    return NextResponse.json({
      ok: true,
      review: {
        ...review,
        client_name: String(sessionPayload.client.name || "Cliente").trim() || "Cliente",
        client_avatar_url: sessionPayload.client.avatar_url || null,
      },
    });
  } catch (error) {
    return NextResponse.json(
      { error: "Não foi possível processar sua avaliação agora." },
      { status: 500 }
    );
  }
}