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

interface LockRequest {
  locked: boolean;
}

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 { 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, "orders.write")) {
      return NextResponse.json({ error: "Sem permissão para editar pedidos." }, { status: 403 });
    }

    // Validar e parsear request body
    const body: LockRequest = await req.json();
    
    if (typeof body.locked !== "boolean") {
      return NextResponse.json(
        { error: "Campo 'locked' deve ser booleano." },
        { status: 400 }
      );
    }

    const resolvedParams = await params;
    const itemId = typeof resolvedParams?.id === "string" ? resolvedParams.id : "";
    if (!itemId) {
      return NextResponse.json({ error: "Id inválido." }, { status: 400 });
    }

    const { data: item, error: itemError } = await supabase
      .from("order_items")
      .select(`
        *,
        orders (tenant_id, status)
      `)
      .eq("id", itemId)
      .single();

    if (itemError || !item) {
      return NextResponse.json(
        { error: "Item não encontrado." },
        { status: 404 }
      );
    }

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

    // Validar se pedido está em estado editável
    if (item.orders?.status && ["approved", "cancelled", "completed", "delivered"].includes(item.orders.status)) {
      return NextResponse.json(
        { error: "Pedido não está mais editável." },
        { status: 422 }
      );
    }

    // Atualizar status de bloqueio
    const { data: updatedItem, error: updateError } = await supabase
      .from("order_items")
      .update({
        price_locked: body.locked,
        updated_at: new Date().toISOString()
      })
      .eq("id", itemId)
      .select()
      .single();

    if (updateError) {
      console.error("Erro ao atualizar bloqueio:", updateError);
      return NextResponse.json(
        { error: "Erro ao atualizar bloqueio de preço." },
        { status: 500 }
      );
    }

    return NextResponse.json({
      success: true,
      locked: updatedItem.price_locked,
      message: body.locked ? "Preço bloqueado com sucesso." : "Preço desbloqueado com sucesso."
    });

  } catch (error) {
    console.error("Erro ao atualizar bloqueio:", error);
    return NextResponse.json(
      { error: "Erro interno ao atualizar bloqueio." },
      { status: 500 }
    );
  }
}