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

// GET /api/orders/[id] - Obtiene la orden completa con clientes y líneas
export async function GET(request: Request, props: { params: Promise<{ id: string }> }) {
  try {
    const resolvedParams = props?.params ? await props.params : (props as any) || {};
    const id = resolvedParams?.id;

    if (!id) {
      return NextResponse.json({ error: 'ID de orden no especificado' }, { status: 400 });
    }

    const order = await prisma.order.findUnique({
      where: { id },
      include: {
        shippingCustomer: true,
        billingCustomer: true,
        masterCustomer: true,
        lines: {
          include: {
            product: true,
            farm: true,
          },
          orderBy: { createdAt: 'asc' },
        },
      },
    });

    if (!order) {
      return NextResponse.json({ error: `Orden no encontrada con id: ${id}` }, { status: 404 });
    }

    return NextResponse.json(order);
  } catch (error: any) {
    console.error('Error fetching order by id:', error);
    return NextResponse.json({ error: error.message || 'Error al obtener la orden' }, { status: 500 });
  }
}

// PUT /api/orders/[id] - Actualiza los datos de la orden y clientes
export async function PUT(request: Request, props: { params: Promise<{ id: string }> }) {
  try {
    const resolvedParams = props?.params ? await props.params : (props as any) || {};
    const id = resolvedParams?.id;

    if (!id) {
      return NextResponse.json({ error: 'ID de orden no especificado' }, { status: 400 });
    }
    const body = await request.json();

    const existingOrder = await prisma.order.findUnique({
      where: { id },
      include: {
        shippingCustomer: true,
        billingCustomer: true,
        lines: true,
      },
    });

    if (!existingOrder) {
      return NextResponse.json({ error: 'Orden no encontrada' }, { status: 404 });
    }

    const {
      po,
      orderNumber,
      creationDate,
      deliveryDate,
      shipdt,
      awb,
      service,
      status,
      shippingCustomer,
      billingCustomer,
      lines,
    } = body;

    const parsedCreationDate = creationDate ? new Date(creationDate) : existingOrder.creationDate;
    const parsedDeliveryDate = deliveryDate ? new Date(deliveryDate) : existingOrder.deliveryDate;
    const recalculatedShipdt = shipdt || (parsedDeliveryDate ? calculateShipDate(parsedDeliveryDate, service || 'FEDEX') : existingOrder.shipdt);

    // Actualizar cliente Shipping si se proveyó
    if (shippingCustomer && existingOrder.shippingCustomerId) {
      await prisma.customer.update({
        where: { id: existingOrder.shippingCustomerId },
        data: {
          businessName: shippingCustomer.businessName || undefined,
          contactName: shippingCustomer.contactName || null,
          address: shippingCustomer.address || null,
          address2: shippingCustomer.address2 || null,
          city: shippingCustomer.city || null,
          state: shippingCustomer.state || null,
          zipCode: shippingCustomer.zipCode || null,
          phone: shippingCustomer.phone || null,
        },
      });
    }

    // Actualizar cliente Billing si se proveyó
    if (billingCustomer && existingOrder.billingCustomerId) {
      await prisma.customer.update({
        where: { id: existingOrder.billingCustomerId },
        data: {
          businessName: billingCustomer.businessName || undefined,
          contactName: billingCustomer.contactName || null,
          phone: billingCustomer.phone || null,
        },
      });
    }

    // Actualizar la orden principal
    const updatedOrder = await prisma.order.update({
      where: { id },
      data: {
        po: po || existingOrder.po,
        orderNumber: orderNumber || existingOrder.orderNumber,
        creationDate: parsedCreationDate,
        deliveryDate: parsedDeliveryDate,
        shipdt: recalculatedShipdt,
        awb: awb !== undefined ? awb : existingOrder.awb,
        service: service || existingOrder.service,
        status: status || existingOrder.status,
      },
    });

    // Actualizar líneas individuales si se enviaron
    if (Array.isArray(lines)) {
      for (const line of lines) {
        if (line.id) {
          await prisma.orderLine.update({
            where: { id: line.id },
            data: {
              trackingNumber: line.trackingNumber !== undefined ? line.trackingNumber : undefined,
              airwayBill: line.airwayBill !== undefined ? line.airwayBill : undefined,
              price: line.price !== undefined ? parseFloat(line.price) || 0 : undefined,
              status: line.status || undefined,
              boxNumber: line.boxNumber || undefined,
              message: line.message !== undefined ? line.message : undefined,
            },
          });
        }
      }
    }

    return NextResponse.json({ success: true, order: updatedOrder });
  } catch (error: any) {
    console.error('Error updating order:', error);
    return NextResponse.json({ error: error.message || 'Error al actualizar la orden' }, { status: 500 });
  }
}

// DELETE /api/orders/[id] - Elimina una orden y sus líneas
export async function DELETE(request: Request, props: { params: Promise<{ id: string }> }) {
  try {
    const resolvedParams = props?.params ? await props.params : (props as any) || {};
    const id = resolvedParams?.id;

    if (!id) {
      return NextResponse.json({ error: 'ID de orden no especificado' }, { status: 400 });
    }

    // Prisma cascade deletes lines on order delete
    await prisma.order.delete({
      where: { id },
    });

    return NextResponse.json({ success: true, message: 'Orden eliminada exitosamente' });
  } catch (error: any) {
    console.error('Error deleting order:', error);
    return NextResponse.json({ error: error.message || 'Error al eliminar la orden' }, { status: 500 });
  }
}