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

// Factor de peso real para rosas por ramo según longitud del tallo
function getRoseBunchWeight(lengthCm: number): number {
  if (lengthCm <= 40) return 1.6;
  if (lengthCm <= 50) return 1.8;
  if (lengthCm <= 60) return 2.0;
  return 2.5; // 70cm+
}

export async function POST(request: Request) {
  try {
    const body = await request.json();
    const { farmId, farmName, rows } = body;

    if (!farmId || !Array.isArray(rows) || rows.length === 0) {
      return NextResponse.json({ error: 'Finca y datos de variedades requeridos' }, { status: 400 });
    }

    let resolvedFarmName = farmName;
    if (!resolvedFarmName) {
      const f = await prisma.farm.findUnique({ where: { id: farmId } });
      resolvedFarmName = f?.name || 'Finca';
    }

    let createdBoxTypes = 0;
    let createdProducts = 0;
    const processedVarieties: any[] = [];

    for (const row of rows) {
      // Soportar tanto objetos ya parseados como filas crudas de Excel
      const variety = (row.variety || row['VARIETY'] || row['Variety'] || row['Variedad'] || row['PRODUCT'] || row['Item'] || '').toString().trim();
      if (!variety) continue;

      const product = (row.product || row['PRODUCT'] || row['Product'] || 'Rose').toString().trim();
      const lengthCm = parseFloat(row.lengthCm || row['LENGTH'] || row['Length'] || row['Longitud'] || row['Tallo'] || 50) || 50;
      const pack = parseInt(row.pack || row['PACK'] || row['Pack'] || row['Ramos'] || 0, 10) || 0;
      // Regla: si el pack dice 0, no se debe subir esa línea
      if (!pack || pack <= 0) continue;

      const stems = parseInt(row.stems || row['STEMS'] || row['Stems'] || row['Tallos'] || 25, 10) || 25;
      const boxBase = (row.boxType || row['BOX TYPE'] || row['BoxType'] || row['TipoCaja'] || row['Box'] || 'EB').toString().trim().toUpperCase();

      const l = parseFloat(row.l || row['L'] || row['LengthBox'] || row['Largo'] || 104) || 104;
      const w = parseFloat(row.w || row['W'] || row['WidthBox'] || row['Ancho'] || 18) || 18;
      const h = parseFloat(row.h || row['H'] || row['HeightBox'] || row['Alto'] || 14) || 14;

      // Cálculo DIM: (L * W * H) / 6000
      const dimWeight = row.dimWeight ? parseFloat(row.dimWeight) : Math.round(((l * w * h) / 6000) * 100) / 100;

      // Cálculo Real Weight según regla oficial:
      // Solamente si no tiene el peso real y el producto es rosa se debe calcular el peso real, para los demas productos debe venir lleno
      let realWeight = parseFloat(row.realWeight || row['REAL WEIGHT'] || row['RealWeight'] || row['PesoReal'] || 0);
      if (!realWeight || realWeight <= 0) {
        if (/ros[ea]/i.test(product) || !product) {
          const bunchWeight = getRoseBunchWeight(lengthCm);
          realWeight = Math.round((pack * bunchWeight) * 100) / 100;
        }
      }

      // Nombre y código de caja estandarizado: ej. "EB-FARM-FINCAMAFER-104x18x14" y display "EB-FARM-104x18x14"
      const cleanFarmTag = resolvedFarmName.toUpperCase().replace(/[^A-Z0-9]/g, '');
      const boxCode = `${boxBase}-FARM-${cleanFarmTag}-${Math.round(l)}x${Math.round(w)}x${Math.round(h)}`;
      const boxDisplayName = `${boxBase}-FARM-${Math.round(l)}x${Math.round(w)}x${Math.round(h)}`;

      // Upsert BoxType
      const existingBox = await prisma.boxType.findUnique({
        where: { code: boxCode }
      });

      if (!existingBox) {
        await prisma.boxType.create({
          data: {
            code: boxCode,
            name: boxDisplayName,
            length: l,
            width: w,
            height: h,
            dimWeight,
            realWeight,
            farmId,
            farmName: resolvedFarmName
          }
        });
        createdBoxTypes++;
      } else {
        await prisma.boxType.update({
          where: { id: existingBox.id },
          data: {
            name: boxDisplayName,
            length: l,
            width: w,
            height: h,
            dimWeight,
            realWeight,
            farmId,
            farmName: resolvedFarmName
          }
        });
      }

      // Verificar o crear Producto en el catálogo si no existe
      const productCode = (row['CODE'] || row['Code'] || row['ITEM'] || variety).toString().trim().toUpperCase();
      const existingProd = await prisma.product.findUnique({ where: { code: productCode } });
      if (!existingProd) {
        await prisma.product.create({
          data: {
            code: productCode,
            name: variety,
            boxType: boxCode,
            length: l,
            width: w,
            height: h,
            realWeight,
            dimWeight,
            stems: pack * stems
          }
        });
        createdProducts++;
      }

      processedVarieties.push({
        variety,
        productCode,
        lengthCm,
        pack,
        stems,
        boxCode,
        dimensions: `${l}x${w}x${h} cm`,
        realWeight,
        dimWeight
      });
    }

    return NextResponse.json({
      success: true,
      message: `Catálogo de finca procesado: ${processedVarieties.length} variedades cargadas con éxito.`,
      farmName: resolvedFarmName,
      createdBoxTypes,
      createdProducts,
      varieties: processedVarieties
    });

  } catch (error: any) {
    console.error('Error uploading farm varieties:', error);
    return NextResponse.json({ error: error.message || 'Error al procesar archivo de variedades' }, { status: 500 });
  }
}