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

interface QuoteItemRequest {
  productId: string;
  quantity: number;
  description?: string;
  notes?: string;
}

async function getAuth() {
  const supabase = await createClient();
  const {
    data: { user },
  } = await supabase.auth.getUser();
  return { supabase, user };
}

export async function POST(
  req: Request,
  { params }: { params: Promise<{ id: string }> }
) {
  try {
    const { id } = await params;
    const { supabase, user } = await getAuth();
    if (!user) {
      return NextResponse.json({ error: "Não autenticado." }, { status: 401 });
    }

    // Validar permissões
    const ctx = await getCompanyContext(supabase, user);
    if (!canCompany(ctx, user.id, "quotes.write")) {
      return NextResponse.json({ error: "Sem permissão para editar orçamentos." }, { status: 403 });
    }

    // Validar e parsear request body
    const body: QuoteItemRequest = await req.json();
    
    if (!body.productId || !body.quantity) {
      return NextResponse.json(
        { error: "productId e quantity são obrigatórios." },
        { status: 400 }
      );
    }

    if (body.quantity <= 0) {
      return NextResponse.json(
        { error: "quantity deve ser maior que zero." },
        { status: 400 }
      );
    }

    // Buscar quote para validar tenant
    const { data: quote, error: quoteError } = await supabase
      .from("quotes")
      .select("tenant_id, status")
      .eq("id", id)
      .single();

    if (quoteError || !quote) {
      return NextResponse.json(
        { error: "Orçamento não encontrado." },
        { status: 404 }
      );
    }

    // Validar se quote pertence ao tenant do usuário
    if (quote.tenant_id !== ctx.companyId) {
      return NextResponse.json(
        { error: "Orçamento não pertence ao seu tenant." },
        { status: 403 }
      );
    }

    // Buscar dados do produto
    const { data: product, error: productError } = await supabase
      .from("products")
      .select("id,name,price,price_on_request,cost_total,estimated_base_cost")
      .eq("id", body.productId)
      .eq("tenant_id", quote.tenant_id)
      .single();

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

    const unitPrice = product.price_on_request ? 0 : Number(product.price ?? 0) || 0;
    const costUnit = Number(product.cost_total ?? product.estimated_base_cost ?? 0) || 0;
    const totalPrice = unitPrice * body.quantity;
    const costTotal = costUnit * body.quantity;
    const marginPercentage = unitPrice > 0 ? ((unitPrice - costUnit) / unitPrice) * 100 : 0;

    const { data: newItem, error: insertError } = await supabase
      .from("quote_items")
      .insert({
        quote_id: id,
        product_id: body.productId,
        description: body.description || product.name,
        notes: body.notes,
        quantity: body.quantity,
        unit_price: unitPrice,
        total_price: totalPrice,
        cost_unit: costUnit,
        cost_total: costTotal,
        margin_percentage: marginPercentage,
        price_locked: false,
      })
      .select()
      .single();

    if (insertError) {
      console.error("Erro ao inserir item:", insertError);
      return NextResponse.json(
        { error: "Erro ao adicionar item ao orçamento." },
        { status: 500 }
      );
    }

    return NextResponse.json(newItem);

  } catch (error) {
    console.error("Erro ao adicionar item ao orçamento:", error);
    return NextResponse.json(
      { error: "Erro interno ao adicionar item." },
      { status: 500 }
    );
  }
}