import { NextResponse } from 'next/server';
import { prisma } from '@/lib/prisma';
import { calculateShipDate } from '@/lib/dateUtils';

export async function POST(request: Request) {
  try {
    const { lineIds, reason, deliveryDate } = await request.json();

    if (!Array.isArray(lineIds) || lineIds.length === 0) {
      return NextResponse.json({ error: 'Debes seleccionar al menos una línea/caja para reenviar' }, { status: 400 });
    }

    if (!reason || !reason.trim()) {
      return NextResponse.json({ error: 'Debes ingresar el motivo o razón del reenvío (comentario)' }, { status: 400 });
    }

    // Buscar las líneas seleccionadas con sus órdenes y productos
    const lines = await prisma.orderLine.findMany({
      where: { id: { in: lineIds } },
      include: {
        order: {
          include: {
            shippingCustomer: true,
            billingCustomer: true,
            masterCustomer: true,
          }
        },
        product: true,
        farm: true,
      }
    });

    if (lines.length === 0) {
      return NextResponse.json({ error: 'No se encontraron las líneas seleccionadas' }, { status: 404 });
    }

    // Calcular el siguiente boxNumber secuencial global para que ninguna etiqueta salga como #000000
    const linesWithBox = await prisma.orderLine.findMany({
      where: { boxNumber: { not: null } },
      select: { boxNumber: true }
    });
    const cancelledWithBox = await prisma.cancelledLabel.findMany({
      select: { boxNumber: true }
    });

    let currentBoxSeq = 100000;
    linesWithBox.forEach(b => {
      const n = parseInt(b.boxNumber || '', 10);
      if (!isNaN(n) && n > currentBoxSeq) currentBoxSeq = n;
    });
    cancelledWithBox.forEach(c => {
      const n = parseInt(c.boxNumber || '', 10);
      if (!isNaN(n) && n > currentBoxSeq) currentBoxSeq = n;
    });

    // Agrupar líneas seleccionadas por orden original
    const linesByOrder = new Map<string, typeof lines>();
    lines.forEach(l => {
      const arr = linesByOrder.get(l.orderId) || [];
      arr.push(l);
      linesByOrder.set(l.orderId, arr);
    });

    const createdOrders = [];

    for (const [orderId, selectedLinesForOrder] of linesByOrder.entries()) {
      const originalOrder = selectedLinesForOrder[0].order;

      // Generar PO único para el reenvío
      const poClean = originalOrder.po.replace(/-REENVIO-\d+/g, '').replace(/-CLON-\d+/g, '');
      const reenvioCount = await prisma.order.count({
        where: { po: { startsWith: `${poClean}-REENVIO` } }
      });
      const newPO = `${poClean}-REENVIO-${reenvioCount + 1}`;

      const targetDeliveryDate = deliveryDate ? new Date(deliveryDate) : originalOrder.deliveryDate;
      const targetShipdt = calculateShipDate(targetDeliveryDate, originalOrder.service || 'FEDEX');

      // Crear la nueva orden de reposición con precio 0 y status NEW
      const newOrder = await prisma.order.create({
        data: {
          po: newPO,
          orderNumber: originalOrder.orderNumber,
          creationDate: new Date(),
          deliveryDate: targetDeliveryDate,
          shipdt: targetShipdt,
          awb: null,
          master: null,
          service: originalOrder.service || 'FEDEX',
          pkgType: originalOrder.pkgType || 'CP',
          origin: originalOrder.origin || null,
          destination: originalOrder.destination || null,
          status: 'NEW',
          isReplacement: true,
          replacementReason: reason.trim(),
          shippingCustomerId: originalOrder.shippingCustomerId,
          billingCustomerId: originalOrder.billingCustomerId,
          masterCustomerId: originalOrder.masterCustomerId,
        }
      });

      // Crear SOLAMENTE las líneas seleccionadas para esta orden
      for (const line of selectedLinesForOrder) {
        currentBoxSeq++;
        const boxNumber = String(currentBoxSeq).padStart(10, '0');
        const farmRuc = line.farm?.ruc || '1793456789001';
        const itemCode = line.product.code;
        const uniqueCode = `${farmRuc}-${itemCode}-${boxNumber}`;

        await prisma.orderLine.create({
          data: {
            orderId: newOrder.id,
            productId: line.productId,
            quantity: 1,
            price: 0, // Reposición gratuita al cliente
            farmPrice: 0,
            farmId: null, // Sin finca asignada al iniciar
            airwayBill: null, // Sin guía asignada
            hawb: null,
            trackingNumber: null,
            boxNumber: boxNumber,
            uniqueCode: uniqueCode,
            status: 'NEW', // Entra como NEW
            observaciones: `Reenvío/Reposición: ${reason.trim()}`,
            message: `Reenvío de PO #${originalOrder.po}`,
          }
        });
      }

      createdOrders.push(newOrder);
    }

    return NextResponse.json({
      success: true,
      message: `Se generó exitosamente el reenvío de ${lines.length} caja(s) seleccionada(s) con status NEW y valor $0.00.`,
      orders: createdOrders
    });

  } catch (error: any) {
    console.error('Error creating re-send order:', error);
    return NextResponse.json({ error: error.message || 'Error al procesar el reenvío' }, { status: 500 });
  }
}