// 🐝 Módulo de Análisis Profundo para Idoneidad Apícola - DATOS REALES
// Análisis espacial con datos reales de SIGPAC y Dynamic World

// Sistema de logging para análisis detallado
let analysisLog = [];
let logToFile = false;

// Sistema de popup de progreso
let progressPopup = null;

function logAnalysis(message, data = null) {
  const timestamp = new Date().toISOString();
  const logEntry = {
    timestamp,
    message,
    data: data ? JSON.stringify(data, null, 2) : null
  };
  
  if (logToFile) {
    analysisLog.push(logEntry);
  }
  
  console.log(message, data || '');
}

function exportAnalysisLog() {
  const logContent = analysisLog.map(entry => {
    let line = `[${entry.timestamp}] ${entry.message}`;
    if (entry.data) {
      line += `\n${entry.data}`;
    }
    return line;
  }).join('\n\n');
  
  const blob = new Blob([logContent], { type: 'text/plain' });
  const url = URL.createObjectURL(blob);
  const a = document.createElement('a');
  a.href = url;
  a.download = `analisis_apicola_${new Date().toISOString().slice(0,19).replace(/:/g,'-')}.log`;
  document.body.appendChild(a);
  a.click();
  document.body.removeChild(a);
  URL.revokeObjectURL(url);
  
  console.log(`📁 Log exportado: ${analysisLog.length} entradas`);
}

// Sistema de popup de progreso
function showProgressPopup() {
  // Crear popup de progreso si no existe
  if (!progressPopup) {
    progressPopup = document.createElement('div');
    progressPopup.id = 'progress-popup';
    progressPopup.style.cssText = `
      position: fixed;
      top: 50%;
      left: 50%;
      transform: translate(-50%, -50%);
      background: white;
      border: 2px solid #3b82f6;
      border-radius: 12px;
      padding: 20px;
      box-shadow: 0 10px 25px rgba(0,0,0,0.3);
      z-index: 10000;
      min-width: 300px;
      text-align: center;
      font-family: Arial, sans-serif;
    `;
    document.body.appendChild(progressPopup);
  }
  
  progressPopup.innerHTML = `
    <div style="margin-bottom: 15px;">
      <h3 style="margin: 0; color: #3b82f6; font-size: 18px;">🔬 Analysis in Progress</h3>
    </div>
    <div id="progress-bar-container" style="background: #f3f4f6; border-radius: 10px; height: 20px; margin: 10px 0; overflow: hidden;">
      <div id="progress-bar" style="background: linear-gradient(90deg, #3b82f6, #10b981); height: 100%; width: 0%; transition: width 0.3s ease; border-radius: 10px;"></div>
    </div>
    <div id="progress-text" style="font-size: 14px; color: #374151; margin: 10px 0;">Starting analysis...</div>
    <div id="progress-details" style="font-size: 12px; color: #6b7280;">Preparing data...</div>
  `;
  
  progressPopup.style.display = 'block';
}

function updateProgressPopup(current, total, percentage, details) {
  if (!progressPopup) return;
  
  const progressBar = document.getElementById('progress-bar');
  const progressText = document.getElementById('progress-text');
  const progressDetails = document.getElementById('progress-details');
  
  if (progressBar) progressBar.style.width = `${percentage}%`;
  if (progressText) progressText.textContent = `${current}/${total} steps completed (${percentage}%)`;
  if (progressDetails) progressDetails.textContent = `${details}`;
}

function hideProgressPopup() {
  if (progressPopup) {
    progressPopup.style.display = 'none';
  }
}

function showAnalysisComplete(validParcels, totalParcels, recommendedZones) {
  const successRate = totalParcels > 0 ? ((validParcels / totalParcels) * 100).toFixed(1) : 0;
  
  // Crear popup de resumen
  const summaryPopup = document.createElement('div');
  summaryPopup.style.cssText = `
    position: fixed;
    top: 50%;
    left: 50%;
    transform: translate(-50%, -50%);
    background: white;
    border: 2px solid #10b981;
    border-radius: 12px;
    padding: 25px;
    box-shadow: 0 10px 25px rgba(0,0,0,0.3);
    z-index: 10001;
    width: 60vw;
    text-align: center;
    font-family: Arial, sans-serif;
  `;
  
  summaryPopup.innerHTML = `
    <div style="margin-bottom: 20px;">
      <h3 style="margin: 0; color: #10b981; font-size: 20px;">✅ Análisis Completado</h3>
    </div>
    <div style="background: #f0fdf4; border-radius: 8px; padding: 15px; margin: 15px 0;">
      <div style="font-size: 16px; font-weight: bold; color: #166534; margin-bottom: 8px;">
        ${validParcels} parcelas válidas de ${totalParcels} analizadas
      </div>
      <div style="font-size: 14px; color: #15803d; margin-bottom: 8px;">
        Tasa de éxito: ${successRate}% • ${recommendedZones} zonas recomendadas
      </div>
      <div style="font-size: 12px; color: #6b7280;">
        Se muestran las ${Math.min(recommendedZones, 10)} mejores zonas apícolas encontradas
      </div>
    </div>
    <div style="display: flex; gap: 10px; justify-content: center; margin-top: 20px;">
      <button id="download-log-btn" style="
        background: #3b82f6;
        color: white;
        border: none;
        padding: 10px 20px;
        border-radius: 6px;
        cursor: pointer;
        font-size: 14px;
      ">📁 Descargar Log</button>
      <button id="close-summary-btn" style="
        background: #6b7280;
        color: white;
        border: none;
        padding: 10px 20px;
        border-radius: 6px;
        cursor: pointer;
        font-size: 14px;
      ">Cerrar</button>
    </div>
  `;
  
  document.body.appendChild(summaryPopup);
  
  // Event listeners
  document.getElementById('download-log-btn').onclick = () => {
    exportAnalysisLog();
    document.body.removeChild(summaryPopup);
  };
  
  document.getElementById('close-summary-btn').onclick = () => {
    document.body.removeChild(summaryPopup);
  };
  
  // Auto-cerrar después de 10 segundos
  setTimeout(() => {
    if (document.body.contains(summaryPopup)) {
      document.body.removeChild(summaryPopup);
    }
  }, 10000);
}

function startLogging() {
  logToFile = true;
  analysisLog = [];
  logAnalysis('🚀 INICIO DE ANÁLISIS DETALLADO');
}

function stopLogging() {
  logToFile = false;
  logAnalysis('🏁 FIN DE ANÁLISIS DETALLADO');
}

// Tabla fenológica de cultivos españoles (índice floral 0-1 por mes) - AMPLIADA
const CROP_PHENOLOGY = {
  'girasol': [0.0, 0.0, 0.0, 0.0, 0.1, 0.9, 0.9, 0.8, 0.1, 0.0, 0.0, 0.0],
  'lavanda': [0.0, 0.0, 0.0, 0.0, 0.3, 0.8, 0.8, 0.4, 0.0, 0.0, 0.0, 0.0],
  'olivo': [0.0, 0.0, 0.0, 0.0, 0.4, 0.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
  'almendro': [0.0, 0.0, 0.7, 0.7, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
  'naranjo': [0.0, 0.0, 0.0, 0.6, 0.6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
  'viñedo': [0.0, 0.0, 0.0, 0.0, 0.1, 0.6, 0.6, 0.4, 0.2, 0.0, 0.0, 0.0],
  'cereales': [0.0, 0.0, 0.0, 0.2, 0.5, 0.3, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
  'matorral': [0.0, 0.0, 0.3, 0.5, 0.7, 0.6, 0.4, 0.2, 0.1, 0.0, 0.0, 0.0],
  'bosque_frondoso': [0.0, 0.0, 0.2, 0.4, 0.6, 0.5, 0.3, 0.1, 0.0, 0.0, 0.0, 0.0],
  'pastizal': [0.0, 0.0, 0.2, 0.4, 0.5, 0.3, 0.2, 0.1, 0.0, 0.0, 0.0, 0.0],
  'urbano': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
  'improductivo': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
  
  // NUEVOS TIPOS PARA EVITAR ÍNDICES 0
  'citricos': [0.0, 0.0, 0.0, 0.6, 0.6, 0.3, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],  // Similar a naranjo
  'frutales': [0.0, 0.0, 0.5, 0.7, 0.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],  // Floración primaveral
  'huerta': [0.0, 0.0, 0.2, 0.4, 0.6, 0.5, 0.4, 0.3, 0.2, 0.0, 0.0, 0.0],    // Cultivos diversos
  
  'default': [0.0, 0.0, 0.4, 0.6, 0.8, 0.7, 0.5, 0.3, 0.1, 0.0, 0.0, 0.0]
};

// Clasificación de vegetación natural
const VEGETATION_SCORES = {
  'trees': 0.6,
  'grass': 0.4,
  'shrub_and_scrub': 0.8,
  'crops': 0.5,
  'water': 0.0,
  'built': 0.0,
  'bare': 0.1,
  'flooded_vegetation': 0.3,
  'snow_and_ice': 0.0
};

// Cache para evitar recálculos
const analysisCache = new Map();

// Cache específico para Exploración Rápida
let exploracionRapidaCache = {
  center: null,
  radius: null,
  parcelas: null,
  markers: null
};

// Función hash simple para generar valores determinísticos
function simpleHash(str) {
  let hash = 0;
  for (let i = 0; i < str.length; i++) {
    const char = str.charCodeAt(i);
    hash = ((hash << 5) - hash) + char;
    hash = hash & hash; // Convertir a 32bit integer
  }
  return Math.abs(hash);
}

// Función de fallback determinística cuando las APIs no están disponibles
function getDeterministicFallback(point, type) {
  const hash = simpleHash(`${point.lat.toFixed(6)}_${point.lng.toFixed(6)}_${type}`);
  
  if (type === 'vegetation') {
    // Fallback determinístico sin hardcodeo de ciudades
    const landCoverTypes = ['trees', 'grass', 'crops', 'shrub_and_scrub', 'bare'];
    const selectedType = landCoverTypes[hash % landCoverTypes.length];
    return {
      landCover: selectedType,
      confidence: 0.6 + (hash % 40) / 100,
      source: 'Fallback determinístico'
    };
  }
  
  if (type === 'infrastructure') {
    return {
      waterNearby: (hash % 3) === 0, // 33% probabilidad
      waterCount: hash % 3,
      roadAccess: (hash % 4) !== 0, // 75% probabilidad
      roadCount: hash % 5,
      industrialNearby: (hash % 10) === 0, // 10% probabilidad
      industrialCount: hash % 2,
      source: 'Fallback determinístico'
    };
  }
  
  return {};
}

// Iconos para cultivos específicos según README.md
const CROP_ICONS = {
  // Cereales
  'TRIGO': '🌾', 'CEBADA': '🌾', 'AVENA': '🌾', 'CENTENO': '🌾', 'MAÍZ': '🌽', 'ARROZ': '🌾',
  
  // Leguminosas
  'GUISANTES': '🟢', 'HABAS': '🟢', 'LENTEJAS': '🟢', 'GARBANZOS': '🟢', 'JUDÍAS': '🟢',
  
  // Oleaginosas
  'GIRASOL': '🌻', 'COLZA': '🌻', 'LINO': '🌻', 'CÁRTAMO': '🌻',
  
  // Hortalizas
  'TOMATE': '🍅', 'PIMIENTO': '🌶️', 'LECHUGA': '🥬', 'ZANAHORIA': '🥕', 'CEBOLLA': '🧅',
  
  // Frutales
  'MANZANO': '🍎', 'PERAL': '🍐', 'MELOCOTONERO': '🍑', 'CEREZO': '🍒', 'CIRUELO': '🟣',
  
  // Cítricos
  'NARANJO': '🍊', 'LIMONERO': '🍋', 'MANDARINO': '🍊', 'POMELO': '🍊',
  
  // Frutos Secos
  'ALMENDRO': '🌸', 'AVELLANO': '🌰', 'NOGAL': '🌰', 'PISTACHO': '🌰',
  
  // Aromáticas
  'LAVANDA': '💜', 'ROMERO': '🌿', 'TOMILLO': '🌿', 'ORÉGANO': '🌿',
  
  // Otros cultivos importantes
  'VIÑA': '🍇', 'OLIVO': '🫒', 'ALFALFA': '🌱', 'TABACO': '🚬', 'ESPÁRRAGO': '🌱',
  
  // Códigos SIGPAC según README
  'TA': '🌾', 'TH': '🥬', 'CF': '🍊', 'CI': '🍊', 'CS': '🍊', 'CV': '🍊',
  'FF': '🍎', 'FL': '🫒', 'FS': '🌰', 'FV': '🍇', 'FY': '🍎',
  'OC': '🫒', 'OF': '🫒', 'OV': '🫒', 'VI': '🍇', 'VO': '🍇',
  'PA': '🌳', 'PR': '🌿', 'PS': '🌱', 'FO': '🌲',
  'IV': '🏠', 'ZU': '🏙️', 'ED': '🏢', 'CA': '🛣️', 'AG': '💧', 'IM': '⬜',
  'EP': '🌿', 'VF': '🍇',
  
  // Barbecho y otros
  'BARBECHO TRADICIONAL': '🟫', 'REMOLACHA': '🟣',
  
  // Tipos fenológicos generales
  'viñedo': '🍇', 'olivo': '🫒', 'almendro': '🌸', 'naranjo': '🍊',
  'girasol': '🌻', 'lavanda': '💜', 'cereales': '🌾', 'matorral': '🌿',
  'bosque_frondoso': '🌳', 'pastizal': '🌱', 'huerta': '🥬',
  'citricos': '🍊', 'frutales': '🍎',
  
  'default': '🟫'
};

// Función para obtener icono de cultivo
function getCropIcon(cultivoEspecifico, tipoCultivo) {
  // Prioridad 1: Cultivo específico exacto
  if (cultivoEspecifico && CROP_ICONS[cultivoEspecifico.toUpperCase()]) {
    return CROP_ICONS[cultivoEspecifico.toUpperCase()];
  }
  
  // Prioridad 2: Búsqueda parcial en cultivo específico
  if (cultivoEspecifico) {
    const cultivoUpper = cultivoEspecifico.toUpperCase();
    for (const [key, icon] of Object.entries(CROP_ICONS)) {
      if (cultivoUpper.includes(key) || key.includes(cultivoUpper)) {
        return icon;
      }
    }
  }
  
  // Prioridad 3: Tipo de cultivo fenológico
  if (tipoCultivo && CROP_ICONS[tipoCultivo]) {
    return CROP_ICONS[tipoCultivo];
  }
  
  return CROP_ICONS['default'];
}

// Obtener todas las parcelas SIGPAC usando el método directo del botón "Cultivos Específicos"
async function getAllParcelasInArea(center, radiusKm = 5) {
  // Generar clave de caché basada en ubicación y radio
  const cacheKey = `${center.lat.toFixed(4)}_${center.lng.toFixed(4)}_${radiusKm}`;
  
  // Verificar si ya tenemos datos en caché
  if (analysisCache.has(cacheKey)) {
    console.log(`📦 USANDO CACHÉ - Clave: ${cacheKey}`);
    return analysisCache.get(cacheKey);
  }
  
  logAnalysis(`🔍 INICIANDO ANÁLISIS SIGPAC - Centro: ${center.lat}, ${center.lng} - Radio: ${radiusKm}km`);
  
  // Activar temporalmente ambas capas SIGPAC
  const wasSigpacActive = showSigpac;
  const wasCultivoActive = showCultivoDeclarado;
  showSigpac = true;
  showCultivoDeclarado = true;
  sigpacLayer.setOpacity(0.6);
  cultivoDeclaradoLayer.setOpacity(0.6);
  
  // Generar más puntos de muestreo para compensar zonas sin datos
  const samplePoints = generateSamplePoints(center, radiusKm, 500);
  const parcelas = new Map();
  let pointsProcessed = 0;
  let parcelasFound = 0;
  
  let emptyResponses = 0;
  let errorResponses = 0;
  let duplicates = 0;
  let unknownCrops = 0;
  
  for (const point of samplePoints) {
    try {
      // Crear bbox independiente del viewport del mapa, centrado en cada punto
      const radiusDeg = 0.001; // ~100m de radio para la consulta
      const pointBounds = {
        west: point.lng - radiusDeg,
        south: point.lat - radiusDeg,
        east: point.lng + radiusDeg,
        north: point.lat + radiusDeg
      };
      
      // Proyectar a EPSG:3857
      const sw = L.CRS.EPSG3857.project(L.latLng(pointBounds.south, pointBounds.west));
      const ne = L.CRS.EPSG3857.project(L.latLng(pointBounds.north, pointBounds.east));
      const bbox = [sw.x, sw.y, ne.x, ne.y].join(',');
      
      // Usar imagen fija 256x256 con punto en el centro
      const imageSize = 256;
      const centerPixel = imageSize / 2;
      
      const params = new URLSearchParams({
        service: 'WMS',
        version: '1.3.0',
        request: 'GetFeatureInfo',
        layers: 'AU.Sigpac:recinto,AU.Sigpac:linea_declaracion',
        query_layers: 'AU.Sigpac:recinto,AU.Sigpac:linea_declaracion',
        info_format: 'text/html',
        i: Math.round(centerPixel),
        j: Math.round(centerPixel),
        crs: 'EPSG:3857',
        bbox: bbox,
        width: imageSize,
        height: imageSize
      });
      
      const url = `${BACKEND}/proxy?url=${encodeURIComponent(SIGPAC_WMS + '?' + params.toString())}`;
      const html = await (await fetch(url)).text();
      
      if (!html || !html.trim()) {
        emptyResponses++;
        continue;
      }
      
      if (html.includes('ServiceException') || html.includes('no features') || !html.includes('<table')) {
        errorResponses++;
        continue;
      }
      
      const parcelaInfo = parseParcelaFromHTML(html, point);
      if (!parcelaInfo) {
        errorResponses++;
        continue;
      }
      
      if (parcelaInfo.producto === 'DESCONOCIDO') {
        unknownCrops++;
        continue;
      }
      
      const key = `${parcelaInfo.producto}_${point.lat.toFixed(4)}_${point.lng.toFixed(4)}`;
      if (parcelas.has(key)) {
        duplicates++;
        continue;
      }
      
      parcelas.set(key, parcelaInfo);
      parcelasFound++;
      logAnalysis(`🌱 Parcela válida: ${parcelaInfo.producto} en ${point.lat.toFixed(4)}, ${point.lng.toFixed(4)}`);
      
      pointsProcessed++;
      if (pointsProcessed % 50 === 0) {
        logAnalysis(`📊 Procesados ${pointsProcessed}/${samplePoints.length} puntos, ${parcelasFound} parcelas encontradas`);
        logAnalysis(`   - Vacías: ${emptyResponses}, Errores: ${errorResponses}, Duplicadas: ${duplicates}, Desconocidas: ${unknownCrops}`);
      }
      
    } catch (error) {
      errorResponses++;
      continue;
    }
  }
  
  logAnalysis(`📈 ESTADÍSTICAS FINALES:`);
  logAnalysis(`   - Puntos procesados: ${samplePoints.length}`);
  logAnalysis(`   - Parcelas encontradas: ${parcelasFound}`);
  logAnalysis(`   - Respuestas vacías: ${emptyResponses}`);
  logAnalysis(`   - Errores/Sin datos: ${errorResponses}`);
  logAnalysis(`   - Duplicadas: ${duplicates}`);
  logAnalysis(`   - Cultivos desconocidos: ${unknownCrops}`);
  
  // Restaurar estado original
  if (!wasSigpacActive) {
    showSigpac = false;
    sigpacLayer.setOpacity(0);
  }
  if (!wasCultivoActive) {
    showCultivoDeclarado = false;
    cultivoDeclaradoLayer.setOpacity(0);
  }
  
  const parcelasArray = Array.from(parcelas.values());
  logAnalysis(`✅ PARCELAS ENCONTRADAS: ${parcelasArray.length} únicas`);
  
  // Guardar en caché para futuras consultas
  analysisCache.set(cacheKey, parcelasArray);
  console.log(`💾 GUARDADO EN CACHÉ - Clave: ${cacheKey}, Parcelas: ${parcelasArray.length}`);
  
  return parcelasArray;
}

// Generar puntos de muestreo distribuidos uniformemente en el área
function generateSamplePoints(center, radiusKm, numPoints) {
  const points = [];
  const radiusDeg = radiusKm / 111;
  
  // Distribución uniforme en círculo usando método de rechazo
  let generated = 0;
  let attempts = 0;
  const maxAttempts = numPoints * 10;
  
  while (generated < numPoints && attempts < maxAttempts) {
    // Generar punto aleatorio en cuadrado
    const x = (Math.random() - 0.5) * 2 * radiusDeg;
    const y = (Math.random() - 0.5) * 2 * radiusDeg;
    
    // Verificar si está dentro del círculo
    if (x*x + y*y <= radiusDeg*radiusDeg) {
      const lat = center.lat + y;
      const lng = center.lng + x;
      points.push({ lat, lng });
      generated++;
    }
    attempts++;
  }
  
  // Si no se generaron suficientes puntos, usar distribución determinística
  if (generated < numPoints * 0.5) {
    console.log(`⚠️ Solo se generaron ${generated} puntos aleatorios, completando con distribución determinística`);
    
    const numPointsDeterministic = numPoints - generated;
    for (let i = 0; i < numPointsDeterministic; i++) {
      // Distribución uniforme en círculo - DETERMINÍSTICA
      const angle = (i / numPointsDeterministic) * 2 * Math.PI;
      const ringIndex = Math.floor(i / 8); // 8 puntos por anillo
      const numRings = Math.ceil(numPointsDeterministic / 8);
      const normalizedRadius = (ringIndex + 0.5) / numRings;
      const distance = normalizedRadius * radiusKm * 1000; // metros
      
      const lat = center.lat + (distance * Math.cos(angle)) / 111320;
      const lng = center.lng + (distance * Math.sin(angle)) / (111320 * Math.cos(center.lat * Math.PI / 180));
      
      points.push({ lat, lng });
    }
  }
  
  return points;
}
// Calcular centroide de una geometría
function calculateCentroid(geometry) {
  if (!geometry || !geometry.coordinates) return null;
  
  try {
    if (geometry.type === 'Point') {
      return { lat: geometry.coordinates[1], lng: geometry.coordinates[0] };
    }
    
    if (geometry.type === 'Polygon') {
      const coords = geometry.coordinates[0];
      let lat = 0, lng = 0;
      for (const coord of coords) {
        lng += coord[0];
        lat += coord[1];
      }
      return { lat: lat / coords.length, lng: lng / coords.length };
    }
    
    if (geometry.type === 'MultiPolygon') {
      const firstPolygon = geometry.coordinates[0][0];
      let lat = 0, lng = 0;
      for (const coord of firstPolygon) {
        lng += coord[0];
        lat += coord[1];
      }
      return { lat: lat / firstPolygon.length, lng: lng / firstPolygon.length };
    }
    
    return null;
  } catch (error) {
    return null;
  }
}

// Obtener datos detallados de parcela en un punto específico usando GetFeatureInfo
async function getParcelaDataAtPoint(point) {
  try {
    const SIGPAC_WMS = 'https://wms.mapa.gob.es/sigpac/wms';
    const BACKEND = window.BACKEND || 'http://localhost:3996';
    
    // Crear bbox específico centrado en el punto para evitar errores de coordenadas
    const bufferDeg = 0.001; // Buffer pequeño alrededor del punto
    const pointBounds = L.latLngBounds(
      [point.lat - bufferDeg, point.lng - bufferDeg],
      [point.lat + bufferDeg, point.lng + bufferDeg]
    );
    
    const crs = 'EPSG:3857';
    const sw = L.CRS.EPSG3857.project(pointBounds.getSouthWest());
    const ne = L.CRS.EPSG3857.project(pointBounds.getNorthEast());
    const bbox = [sw.x, sw.y, ne.x, ne.y].join(',');
    
    // Usar coordenadas fijas en el centro de una imagen pequeña
    const imageSize = 256;
    const centerPixel = Math.floor(imageSize / 2);
    
    const params = new URLSearchParams({
      service: 'WMS',
      version: '1.3.0',
      request: 'GetFeatureInfo',
      layers: 'AU.Sigpac:linea_declaracion',
      query_layers: 'AU.Sigpac:linea_declaracion',
      info_format: 'text/html',
      i: centerPixel,
      j: centerPixel,
      crs: crs,
      bbox: bbox,
      width: imageSize,
      height: imageSize
    });
    
    const url = `${BACKEND}/proxy?url=${encodeURIComponent(SIGPAC_WMS + '?' + params.toString())}`;
    const html = await (await fetch(url)).text();
    
    // Verificar que no hay errores XML
    if (html && html.trim() && !html.includes('ServiceException') && 
        !html.includes('no features') && !html.includes('<body>\n  \n  </body>')) {
      return parseParcelaFromHTML(html, point);
    }
    
    return null;
  } catch (error) {
    return null;
  }
}

// Parsear información de parcela desde HTML de GetFeatureInfo
function parseParcelaFromHTML(html, point) {
  try {
    // Si el HTML está vacío o solo contiene CSS, no hay datos
    if (!html.includes('<table') && !html.includes('<td')) {
      logAnalysis(`⚠️ HTML sin datos de tabla`);
      return null;
    }
    
    const info = {
      producto: 'DESCONOCIDO',
      superficie: 'DESCONOCIDO', 
      regadio_secano: 'DESCONOCIDO',
      provincia: 'DESCONOCIDO',
      municipio: 'DESCONOCIDO',
      poligono: 'DESCONOCIDO',
      parcela: 'DESCONOCIDO',
      recinto: 'DESCONOCIDO'
    };
    
    // Parsear tabla de Recinto SIGPAC
    if (html.includes('caption class="featureInfo">Recinto</caption>')) {
      const tableMatch = html.match(/<table class="featureInfo">.*?<\/table>/s);
      if (tableMatch) {
        const table = tableMatch[0];
        const rows = table.match(/<tr>.*?<\/tr>/gs);
        
        if (rows && rows.length > 1) {
          // La primera fila son headers, la segunda son datos
          const dataRow = rows[1];
          const cells = dataRow.match(/<td[^>]*>(.*?)<\/td>/gs);
          
          if (cells && cells.length >= 13) {
            // Extraer datos según posición en la tabla
            info.provincia = cells[0].replace(/<[^>]*>/g, '').trim();
            info.municipio = cells[1].replace(/<[^>]*>/g, '').trim();
            info.poligono = cells[4].replace(/<[^>]*>/g, '').trim();
            info.parcela = cells[5].replace(/<[^>]*>/g, '').trim();
            info.recinto = cells[6].replace(/<[^>]*>/g, '').trim();
            info.superficie = cells[7].replace(/<[^>]*>/g, '').trim() + ' ha';
            
            // Determinar regadío/secano del coeficiente
            const coefRegadio = cells[9].replace(/<[^>]*>/g, '').trim();
            info.regadio_secano = coefRegadio === '100' ? 'REGADÍO' : 
                                 coefRegadio === '0' ? 'SECANO' : 'MIXTO';
            
            // Extraer uso/cultivo
            const uso = cells[12].replace(/<[^>]*>/g, '').trim();
            info.producto = uso;
            
            // Crear datos para visualización
            info.lat = point.lat;
            info.lng = point.lng;
            info.cultivoEspecifico = uso;
            info.indiceFloral = getFloralIndexFromCrop(uso, new Date().getMonth() + 1);
            
            // Calcular valor apícola basado en tipo de cultivo
            info.valorApicola = calculateValorApicola(uso, info.regadio_secano, info.indiceFloral);
            
            logAnalysis(`✅ Parcela extraída: ${uso} - ${info.superficie} - ${info.regadio_secano} - Valor: ${(info.valorApicola * 100).toFixed(0)}%`);
            
            // Retornar inmediatamente si encontramos datos válidos
            return info;
          }
        }
      }
    }
    
    // Buscar específicamente la tabla de declaración con estructura completa
    const declaracionMatch = html.match(/DeclaraciónProductoSistema[\s\S]*?<\/table>/i);
    if (declaracionMatch) {
      // Buscar todas las filas de datos (no headers)
      const allRows = declaracionMatch[0].match(/<tr[^>]*>[\s\S]*?<\/tr>/gi);
      
      for (let i = 1; i < allRows.length; i++) { // Saltar header (índice 0)
        const row = allRows[i];
        const cells = row.match(/<td[^>]*>(.*?)<\/td>/gi);
        
        if (cells && cells.length >= 4) {
          const producto = cells[1].replace(/<[^>]*>/g, '').trim();
          const sistema = cells[2].replace(/<[^>]*>/g, '').trim();
          const superficie = cells[3].replace(/<[^>]*>/g, '').trim();
          
          // Validar que es un cultivo válido (código + nombre, no ubicación)
          if (producto && /^\d+\s*-\s*[A-ZÁÉÍÓÚÑ\s]+$/i.test(producto) && 
              !producto.includes('BURGOS') && !producto.includes('QUINTANA') && 
              !producto.includes('LEÓN') && !producto.includes('MADRID')) {
            
            info.producto = producto;
            
            if (sistema && (sistema.includes('Secano') || sistema.includes('Regadío'))) {
              info.regadio_secano = sistema;
            }
            
            if (superficie && /^\d+[.,]?\d*$/.test(superficie)) {
              info.superficie = superficie;
            }
            
            break; // Tomar el primer cultivo válido encontrado
          }
        }
      }
    }
    
    // Buscar datos de recinto en la primera tabla
    const recintoMatch = html.match(/RecintoProvinciaMunicipioAgregadoZonaPoligonoParcelaRecinto[\s\S]*?<tr[^>]*>([\s\S]*?)<\/tr>/i);
    if (recintoMatch) {
      const cells = recintoMatch[1].match(/<td[^>]*>(.*?)<\/td>/gi);
      if (cells && cells.length >= 7) {
        // Extraer solo datos numéricos/válidos, ignorar nombres de lugares
        const provincia = cells[1].replace(/<[^>]*>/g, '').trim();
        const municipio = cells[2].replace(/<[^>]*>/g, '').trim();
        const poligono = cells[5].replace(/<[^>]*>/g, '').trim();
        const parcela = cells[6].replace(/<[^>]*>/g, '').trim();
        const recinto = cells[7] ? cells[7].replace(/<[^>]*>/g, '').trim() : 'DESCONOCIDO';
        
        // Solo asignar si son códigos numéricos válidos
        if (/^\d+$/.test(provincia)) info.provincia = provincia;
        if (/^\d+/.test(municipio)) info.municipio = municipio.split(' ')[0]; // Solo el código
        if (/^\d+$/.test(poligono)) info.poligono = poligono;
        if (/^\d+$/.test(parcela)) info.parcela = parcela;
        if (recinto && recinto.length <= 3) info.recinto = recinto;
      }
    }
    
    // Log de la información extraída
    logAnalysis(`📋 Info extraída: ${JSON.stringify(info)}`);
    
    // Solo retornar parcela si tiene cultivo válido
    if (info.producto === 'DESCONOCIDO') {
      return null;
    }
    
    const cultivoEspecifico = info.producto;
    const tipoCultivo = mapSpecificCropToPhenology(cultivoEspecifico);
    
    return {
      id: `${info.provincia}_${info.municipio}_${info.poligono}_${info.parcela}_${info.recinto}`,
      cultivoEspecifico,
      tipoCultivo,
      superficie: parseFloat(info.superficie.replace(',', '.')) || 0,
      sistemaExplotacion: info.regadio_secano || 'DESCONOCIDO',
      municipio: info.municipio || 'DESCONOCIDO',
      provincia: info.provincia || 'DESCONOCIDO',
      poligono: info.poligono || 'DESCONOCIDO',
      parcela: info.parcela || 'DESCONOCIDO',
      recinto: info.recinto || 'DESCONOCIDO',
      lat: point.lat,
      lng: point.lng,
      indiceFloral: getFloralIndexFromCrop(tipoCultivo, new Date().getMonth() + 1)
    };
    
  } catch (error) {
    logAnalysis(`❌ Error parsing HTML: ${error.message}`);
    return null;
  }
}



// Obtener índice floral de un tipo de cultivo
function getFloralIndexFromCrop(cropType, month) {
  const phenology = CROP_PHENOLOGY[cropType] || CROP_PHENOLOGY['default'];
  return phenology[month - 1] || 0;
}

// Calcular valor apícola de una parcela SIGPAC
function calculateValorApicola(uso, sistemaRiego, indiceFloral) {
  // Valores base por tipo de cultivo SIGPAC
  const valoresApicolas = {
    'VI - VIÑEDO': 0.8,           // Muy bueno para abejas
    'AL - ALMENDROS': 0.9,        // Excelente floración temprana
    'OL - OLIVAR': 0.7,           // Buena floración
    'GI - GIRASOL': 0.95,         // Excelente para abejas
    'TA - TIERRAS ARABLES': 0.6,  // Depende del cultivo específico
    'MT - MATORRAL': 0.8,         // Flora silvestre melífera
    'PR - PASTO ARBUSTIVO': 0.7,  // Flora diversa
    'PA - PASTO CON ARBOLADO': 0.75, // Combinación árboles + pasto
    'FO - FORESTAL': 0.6,         // Árboles forestales
    'AG - CORRIENTES Y SUPERFICIES DE AGUA': 0.3, // Agua necesaria pero no melífera
    'CA - VIALES': 0.1,           // Infraestructura
    'ZU - ZONA URBANA': 0.05,     // Urbano
    'IM - IMPRODUCTIVOS': 0.2,    // Terreno baldío
    'ED - EDIFICACIONES': 0.0     // Construcciones
  };
  
  let valorBase = valoresApicolas[uso] || 0.3;
  
  // Bonificación por regadío (mejor floración)
  if (sistemaRiego === 'REGADÍO' || sistemaRiego === 'MIXTO') {
    valorBase *= 1.2;
  }
  
  // Ajuste por índice floral estacional
  valorBase *= (0.5 + indiceFloral * 0.5);
  
  return Math.min(1.0, valorBase);
}

// Clasificar tipo de zona basado en datos SIGPAC reales
function clasificarZonaPorSIGPAC(sigpacData) {
  // Si no hay datos SIGPAC, es zona no agrícola (monte, urbano, etc.)
  if (!sigpacData || !sigpacData.cultivo || sigpacData.cultivo === 'default') {
    return {
      tipo: 'no_agricola',
      esUrbano: false,
      esMonte: true,
      descripcion: 'Zona sin parcelas SIGPAC - Monte/Natural'
    };
  }
  
  // Detectar zonas urbanas usando Dynamic World (más preciso que listas hardcodeadas)
  // Esta detección se hará en calculateRealScore usando Dynamic World data
  
  const cultivo = sigpacData.cultivo.toLowerCase();
  
  // PRIORIDAD 2: Detectar zonas urbanas por códigos SIGPAC
  const codigosUrbanos = ['urbano', 'edificacion', 'vial', 'zona_urbana', 'suelo_urbano'];
  if (codigosUrbanos.some(codigo => cultivo.includes(codigo))) {
    return {
      tipo: 'urbano',
      esUrbano: true,
      esMonte: false,
      descripcion: `Zona urbana detectada por SIGPAC: ${cultivo}`
    };
  }
  
  // Detectar monte/forestal por códigos SIGPAC
  const codigosMonte = ['monte', 'forestal', 'bosque', 'matorral', 'pasto', 'pastizal'];
  if (codigosMonte.some(codigo => cultivo.includes(codigo))) {
    return {
      tipo: 'monte',
      esUrbano: false,
      esMonte: true,
      descripcion: `Monte/Forestal detectado por SIGPAC: ${cultivo}`
    };
  }
  
  // Es zona agrícola
  return {
    tipo: 'agricola',
    esUrbano: false,
    esMonte: false,
    descripcion: `Zona agrícola SIGPAC: ${cultivo}`
  };
}

// Función principal de análisis profundo con datos reales - BASADO EN PARCELAS
async function performDeepAnalysis(forcedCenter = null, maxPoints = 147) {
  clearPreviousAnalysis();
  startLogging(); // Iniciar logging detallado
  showProgressPopup(); // Mostrar popup de progreso
  
  let center;
  if (forcedCenter) {
    center = forcedCenter;
    console.log('Usando centro forzado:', center);
  } else if (typeof currentCircle !== 'undefined' && currentCircle) {
    center = currentCircle.getLatLng();
    console.log('Usando centro del círculo:', center);
  } else {
    center = map.getCenter();
    console.log('No hay círculo, usando centro del mapa:', center);
  }
  
  const radiusKm = typeof currentCircle !== 'undefined' && currentCircle ? currentCircle.getRadius() / 1000 : 5;
  
  logAnalysis(`🎯 INICIANDO ANÁLISIS BASADO EN PARCELAS: Radio ${radiusKm}km`);
  
  // PASO 1: Obtener todas las parcelas SIGPAC en el área
  updateProgressPopup(1, 4, 25, 'Fetching SIGPAC parcels...');
  const parcelas = await getAllParcelasInArea(center, radiusKm);
  
  if (parcelas.length === 0) {
    logAnalysis(`⚠️ No se encontraron parcelas en el área`);
    hideProgressPopup();
    alert('No SIGPAC parcels found in the selected area');
    return;
  }
  
  // PASO 2: Mostrar parcelas en el mapa
  updateProgressPopup(2, 4, 50, 'Visualising parcels...');
  await visualizeParcelas(parcelas);
  
  // PASO 3: Analizar densidad melífera por zonas
  updateProgressPopup(3, 4, 75, 'Calculating honey-flow density...');
  const zonasRecomendadas = await calcularZonasRecomendadas(parcelas, center, radiusKm);
  
  // PASO 4: Mostrar recomendaciones
  updateProgressPopup(4, 4, 100, 'Generating recommendations...');
  await mostrarRecomendaciones(zonasRecomendadas);
  
  logAnalysis(`🎯 ANÁLISIS COMPLETADO: ${parcelas.length} parcelas analizadas, ${zonasRecomendadas.length} zonas recomendadas`);
  
  stopLogging();
  
  // Cerrar popup de progreso y mostrar resumen
  setTimeout(() => {
    hideProgressPopup();
    // Calcular parcelas válidas (con valor apícola > 0)
    const parcelasValidas = parcelas.filter(p => p.valorApicola && p.valorApicola > 0).length;
    showAnalysisComplete(parcelasValidas, parcelas.length, zonasRecomendadas.length);
  }, 1000);
}

// Visualizar parcelas en el mapa con iconos
async function visualizeParcelas(parcelas) {
  logAnalysis(`🗺️ VISUALIZANDO ${parcelas.length} PARCELAS`);
  
  parcelas.forEach(parcela => {
    if (parcela.lat && parcela.lng) {
      // Obtener icono específico para el cultivo
      const icono = getCropIcon(parcela.cultivoEspecifico);
      
      const marker = L.marker([parcela.lat, parcela.lng], {
        icon: L.divIcon({
          html: `<div style="font-size: 16px; text-align: center; background: rgba(255,255,255,0.8); border-radius: 50%; width: 24px; height: 24px; display: flex; align-items: center; justify-content: center; border: 2px solid #333;">${icono}</div>`,
          className: 'parcela-marker',
          iconSize: [24, 24],
          iconAnchor: [12, 12]
        })
      }).addTo(map);
      
      marker.bindPopup(`
        <div style="font-family: Arial, sans-serif;">
          <h4 style="margin: 0 0 8px 0; color: #2563eb;">${icono} ${parcela.cultivoEspecifico}</h4>
          <div><strong>Superficie:</strong> ${parcela.superficie}</div>
          <div><strong>Sistema:</strong> ${parcela.regadio_secano}</div>
          <div><strong>Municipio:</strong> ${parcela.municipio}</div>
          <div><strong>Valor Apícola:</strong> ${(parcela.valorApicola * 100).toFixed(0)}%</div>
          <div><strong>Ubicación:</strong> ${parcela.provincia}</div>
          <div><strong>Parcela:</strong> ${parcela.poligono}/${parcela.parcela}/${parcela.recinto}</div>
        </div>
      `);
      
      // Marcar como parcela (no zona recomendada) para el toggle
      marker.isZonaRecomendada = false;
      
      analysisMarkers.push(marker);
    }
  });
}

// Calcular zonas recomendadas basándose en densidad de cultivos melíferos
async function calcularZonasRecomendadas(parcelas, center, radiusKm) {
  logAnalysis(`🧮 CALCULANDO ZONAS RECOMENDADAS`);
  
  // Debug: mostrar valores apícolas de todas las parcelas
  parcelas.forEach(p => {
    logAnalysis(`🔍 Parcela ${p.cultivoEspecifico}: valorApicola=${p.valorApicola || 'undefined'}`);
  });
  
  // Filtrar parcelas con buen valor apícola
  const parcelasMeliferas = parcelas.filter(p => p.valorApicola && p.valorApicola > 0.3);
  
  logAnalysis(`🌻 PARCELAS MELÍFERAS: ${parcelasMeliferas.length} de ${parcelas.length}`);
  
  // Crear grid de análisis para encontrar zonas de alta densidad
  const gridSize = 0.01; // ~1km
  const zonas = new Map();
  
  parcelasMeliferas.forEach(parcela => {
    if (parcela.lat && parcela.lng) {
      const gridX = Math.floor(parcela.lng / gridSize);
      const gridY = Math.floor(parcela.lat / gridSize);
      const gridKey = `${gridX}_${gridY}`;
      
      if (!zonas.has(gridKey)) {
        zonas.set(gridKey, {
          lat: gridY * gridSize + gridSize / 2,
          lng: gridX * gridSize + gridSize / 2,
          parcelas: [],
          valorTotal: 0,
          superficieTotal: 0
        });
      }
      
      const zona = zonas.get(gridKey);
      zona.parcelas.push(parcela);
      
      // Extraer superficie numérica
      const superficieNum = parseFloat(parcela.superficie.replace(' ha', '').replace(',', '.')) || 0;
      zona.valorTotal += parcela.valorApicola * superficieNum;
      zona.superficieTotal += superficieNum;
    }
  });
  
  // Convertir a array y ordenar por valor
  const zonasArray = Array.from(zonas.values())
    .filter(zona => zona.parcelas.length >= 1) // Mínimo 1 parcela por zona (reducido)
    .map(zona => ({
      ...zona,
      score: zona.valorTotal / Math.max(zona.superficieTotal, 1),
      densidad: zona.parcelas.length
    }))
    .sort((a, b) => b.score - a.score)
    .slice(0, 10); // Top 10 zonas
  
  return zonasArray;
}

// Generar explicación detallada para zona recomendada
function generarExplicacionZonaRecomendada(zona, ranking) {
  const score = Math.round(zona.score * 100);
  const mes = new Date().getMonth() + 1;
  
  // Analizar composición de cultivos
  const cultivosUnicos = [...new Set(zona.parcelas.map(p => p.cultivo))];
  const cultivosEspecificos = zona.parcelas
    .filter(p => p.cultivoEspecifico && p.cultivoEspecifico !== p.cultivo)
    .map(p => p.cultivoEspecifico);
  
  // Contar tipos de cultivos por categoría
  const categorias = {
    meliferos: 0,
    cereales: 0,
    frutales: 0,
    regadio: 0,
    secano: 0
  };
  
  zona.parcelas.forEach(parcela => {
    const cultivo = (parcela.cultivo || '').toLowerCase();
    const sistema = parcela.regadio_secano || '';
    
    if (cultivo.includes('viñedo') || cultivo.includes('oliv') || cultivo.includes('girasol') || 
        cultivo.includes('almend') || cultivo.includes('cítric') || cultivo.includes('frutal')) {
      categorias.meliferos++;
    }
    if (cultivo.includes('trigo') || cultivo.includes('cebada') || cultivo.includes('arables')) {
      categorias.cereales++;
    }
    if (cultivo.includes('frutal') || cultivo.includes('cítric') || cultivo.includes('almend')) {
      categorias.frutales++;
    }
    if (sistema.includes('REGADÍO')) {
      categorias.regadio++;
    } else {
      categorias.secano++;
    }
  });
  
  let explicacion = '';
  let detallesTecnicos = '';
  let recomendaciones = '';
  
  // Explicación principal basada en ranking
  if (ranking <= 3) {
    explicacion += `Esta zona ocupa el puesto #${ranking} en nuestro análisis por su excepcional concentración de cultivos melíferos. `;
  } else if (ranking <= 6) {
    explicacion += `Esta zona se sitúa en el puesto #${ranking} por su buena combinación de cultivos apícolas. `;
  } else {
    explicacion += `Esta zona está en el puesto #${ranking} con potencial apícola moderado pero aprovechable. `;
  }
  
  // Análisis de densidad
  const densidadPorHa = zona.parcelas.length / zona.superficieTotal;
  if (densidadPorHa > 2) {
    explicacion += `La alta densidad de parcelas (${zona.parcelas.length} parcelas en ${zona.superficieTotal.toFixed(1)} ha) indica un paisaje agrícola diversificado ideal para abejas. `;
  } else if (densidadPorHa > 1) {
    explicacion += `La densidad moderada de parcelas permite un buen equilibrio entre cultivos y espacios naturales. `;
  } else {
    explicacion += `Las parcelas extensas proporcionan recursos abundantes cuando están en floración. `;
  }
  
  // Análisis de cultivos melíferos
  if (categorias.meliferos > zona.parcelas.length * 0.6) {
    detallesTecnicos += `Zona excepcional: ${Math.round((categorias.meliferos/zona.parcelas.length)*100)}% de cultivos altamente melíferos. `;
    if (mes >= 3 && mes <= 6) {
      detallesTecnicos += `En esta época (mes ${mes}) la mayoría de estos cultivos están en plena floración. `;
    }
  } else if (categorias.meliferos > zona.parcelas.length * 0.3) {
    detallesTecnicos += `Buena presencia melífera: ${Math.round((categorias.meliferos/zona.parcelas.length)*100)}% de cultivos favorables para abejas. `;
  }
  
  // Análisis de sistema de riego
  if (categorias.regadio > categorias.secano) {
    detallesTecnicos += `Predominio de regadío (${categorias.regadio} parcelas) garantiza floraciones más prolongadas e intensas. `;
    recomendaciones += `El regadío asegura néctar abundante incluso en años secos. Ideal para producción de miel de calidad. `;
  } else if (categorias.secano > 0) {
    detallesTecnicos += `Cultivos de secano (${categorias.secano} parcelas) ofrecen floraciones naturales adaptadas al clima local. `;
    recomendaciones += `Los cultivos de secano proporcionan mieles con características organolépticas únicas de la zona. `;
  }
  
  // Análisis estacional específico
  if (mes >= 3 && mes <= 5) {
    if (categorias.frutales > 0) {
      recomendaciones += `Primavera ideal: los frutales están en plena floración. Época perfecta para instalación de colmenas. `;
    }
  } else if (mes >= 6 && mes <= 8) {
    if (cultivosUnicos.some(c => c.includes('GIRASOL'))) {
      recomendaciones += `Verano óptimo: si hay girasol en la zona, será la época de máxima producción melífera. `;
    }
  } else if (mes >= 9 && mes <= 11) {
    recomendaciones += `Otoño: época de preparación invernal. Los cultivos de secano pueden ofrecer floraciones tardías. `;
  }
  
  // Recomendaciones técnicas
  const densidadColmenas = Math.min(6, Math.max(2, Math.round(zona.superficieTotal / 50)));
  recomendaciones += `Densidad recomendada: ${densidadColmenas} colmenas por zona para aprovechamiento óptimo sin sobreexplotación. `;
  
  if (score >= 70) {
    recomendaciones += `Score excelente (${score}%): zona prioritaria para ubicación de apiarios comerciales. `;
  } else if (score >= 50) {
    recomendaciones += `Score bueno (${score}%): adecuada para apicultura familiar o complementaria. `;
  } else {
    recomendaciones += `Score moderado (${score}%): considerar como ubicación secundaria o estacional. `;
  }
  
  return {
    explicacion: explicacion.trim(),
    detallesTecnicos: detallesTecnicos.trim(),
    recomendaciones: recomendaciones.trim(),
    densidadColmenas,
    categorias
  };
}

// Mostrar recomendaciones en el mapa
async function mostrarRecomendaciones(zonas) {
  logAnalysis(` MOSTRANDO ${zonas.length} RECOMENDACIONES`);

  zonas.forEach((zona, index) => {
    const color = index < 3 ? '#22c55e' : index < 6 ? '#f59e0b' : '#ef4444';
    const size = index < 3 ? 30 : index < 6 ? 25 : 20;

    const marker = L.marker([zona.lat, zona.lng], {
      icon: L.divIcon({
        html: `<div style="
          background: ${color};
          border-radius: 50%;
          width: ${size}px;
          height: ${size}px;
          display: flex;
          align-items: center;
          justify-content: center;
          color: white;
          font-size: 14px;
          font-weight: bold;
          border: 2px solid white;
          box-shadow: 0 2px 4px rgba(0,0,0,0.3);
        ">${index + 1}</div>`,
        className: 'zone-marker',
        iconSize: [size + 4, size + 4],
        iconAnchor: [(size + 4) / 2, (size + 4) / 2]
      })
    }).addTo(map);

    // Generar explicación detallada
    const analisisZona = generarExplicacionZonaRecomendada(zona, index + 1);

    const cultivosConIconos = [...new Set(zona.parcelas.map(p => {
      const icono = getCropIcon(p.cultivoEspecifico || p.cultivo);
      return `${icono} ${p.cultivoEspecifico || p.cultivo}`;
    }))];

    // Contar sistemas de riego
    const regadio = zona.parcelas.filter(p => p.regadio_secano && p.regadio_secano.includes('REGADÍO')).length;
    const secano = zona.parcelas.length - regadio;

    marker.bindPopup(`
      <div style="width: 60vw; max-width: none; min-width: 450px;">
        <h4 style="margin: 0 0 12px 0; text-align: center; color: #2563eb;">Zona Recomendada #${index + 1}</h4>

        <div style="background: #f8f9fa; padding: 12px; border-radius: 6px; margin-bottom: 12px;">
          <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 10px; font-size: 13px;">
            <div><strong>Score de Idoneidad:</strong> 
              <span style="background: ${color}; color: white; padding: 2px 8px; border-radius: 12px; font-weight: bold;">
                ${Math.round(zona.score * 100)}%
              </span>
            </div>
            <div><strong>Ranking:</strong> #${index + 1} de ${zonas.length}</div>
            <div><strong>Parcelas Analizadas:</strong> ${zona.parcelas.length}</div>
            <div><strong>Superficie Total:</strong> ${zona.superficieTotal.toFixed(1)} ha</div>
            <div><strong>Regadío:</strong> ${regadio} parcelas</div>
            <div><strong>Secano:</strong> ${secano} parcelas</div>
          </div>
        </div>

        <div style="border-left: 4px solid #3b82f6; padding-left: 12px; margin: 12px 0;">
          <div style="font-weight: bold; color: #1e40af; margin-bottom: 6px; font-size: 14px;">
            ¿Por qué recomendamos esta zona?
          </div>
          <div style="font-size: 13px; line-height: 1.4; color: #374151; margin-bottom: 8px;">
            ${analisisZona.explicacion}
          </div>
        </div>

        <div style="border-left: 4px solid #10b981; padding-left: 12px; margin: 12px 0;">
          <div style="font-weight: bold; color: #065f46; margin-bottom: 6px; font-size: 14px;">
            Análisis Técnico
          </div>
          <div style="font-size: 13px; line-height: 1.4; color: #374151; margin-bottom: 8px;">
            ${analisisZona.detallesTecnicos}
          </div>
        </div>

        <div style="border-left: 4px solid #f59e0b; padding-left: 12px; margin: 12px 0;">
          <div style="font-weight: bold; color: #92400e; margin-bottom: 6px; font-size: 14px;">
            Recomendaciones de Manejo
          </div>
          <div style="font-size: 13px; line-height: 1.4; color: #374151; margin-bottom: 8px;">
            ${analisisZona.recomendaciones}
          </div>
        </div>

        <div style="background: #f0f9ff; padding: 10px; border-radius: 6px; margin: 12px 0;">
          <div style="font-weight: bold; color: #0369a1; margin-bottom: 6px; font-size: 13px;">
            Cultivos Detectados en la Zona
          </div>
          <div style="font-size: 12px; line-height: 1.3; color: #374151; max-height: 80px; overflow-y: auto;">
            ${cultivosConIconos.slice(0, 10).join(' • ')}
            ${cultivosConIconos.length > 10 ? ` • ... y ${cultivosConIconos.length - 10} más` : ''}
          </div>
        </div>

        <small style="color: #666; font-size: 11px; text-align: center; display: block;">
          Análisis científico con datos oficiales SIGPAC ${new Date().getFullYear()} + Dynamic World + OSM
        </small>
      </div>
    `, { 
      maxWidth: 'none',
      minWidth: 450,
      className: 'zone-analysis-popup'
    });

    // Marcar como zona recomendada para el toggle
    marker.isZonaRecomendada = true;

    analysisMarkers.push(marker);
  });
}

// Obtener datos reales para un punto específico
async function getRealDataForPoint(point, month, center) {
  // Ejecutar peticiones en secuencia con delays más largos para grid grande
  const sigpacData = await getSIGPACRealData(point);
  await new Promise(resolve => setTimeout(resolve, 300));
  
  const dynamicWorldData = await getDynamicWorldRealData(point);
  await new Promise(resolve => setTimeout(resolve, 300));
  
  const osmData = await getOSMRealData(point);
  
  return {
    floralIndex: getFloralIndexFromSIGPAC(sigpacData, month),
    vegetationScore: getVegetationScoreFromDynamicWorld(dynamicWorldData),
    waterFactor: getWaterFactorFromOSM(osmData),
    accessibilityFactor: getAccessibilityFromOSM(osmData),
    industrialPenalty: getIndustrialPenaltyFromOSM(osmData),
    roadPenalty: getRoadPenaltyFromOSM(osmData),
    slopePenalty: getSlopePenaltyFromDEM(point),
    sigpacData: sigpacData,
    dynamicWorldData: dynamicWorldData,
    osmData: osmData
  };
}

// Consultar SIGPAC WFS real - INCLUYENDO CULTIVO DECLARADO
async function getSIGPACRealData(point) {
  try {
    // Probar diferentes formatos de BBOX y versiones
    const bbox1 = `${point.lng-0.01},${point.lat-0.01},${point.lng+0.01},${point.lat+0.01}`;
    const bbox2 = `${point.lat-0.01},${point.lng-0.01},${point.lat+0.01},${point.lng+0.01}`;
    
    // URLs para ambas capas: recinto Y cultivo_declarado
    const urls = [
      // Versión 1.1.0 con BBOX normal - RECINTO
      `https://wms.mapa.gob.es/sigpac/wfs?service=WFS&version=1.1.0&request=GetFeature&typename=AU.Sigpac:recinto&outputFormat=application/json&srsname=EPSG:4326&bbox=${bbox1}`,
      // Versión 2.0.0 - RECINTO
      `https://wms.mapa.gob.es/sigpac/wfs?service=WFS&version=2.0.0&request=GetFeature&typename=AU.Sigpac:recinto&outputFormat=application/json&srsname=EPSG:4326&bbox=${bbox1}`,
      // Versión 1.1.0 con BBOX invertido (lat,lng) - RECINTO
      `https://wms.mapa.gob.es/sigpac/wfs?service=WFS&version=1.1.0&request=GetFeature&typename=AU.Sigpac:recinto&outputFormat=application/json&srsname=EPSG:4326&bbox=${bbox2}`
    ];
    
    // URLs para cultivo declarado (nombre correcto: linea_declaracion)
    const cultivoUrls = [
      // Versión 1.1.0 con BBOX normal - CULTIVO DECLARADO
      `https://wms.mapa.gob.es/sigpac/wfs?service=WFS&version=1.1.0&request=GetFeature&typename=AU.Sigpac:linea_declaracion&outputFormat=application/json&srsname=EPSG:4326&bbox=${bbox1}`,
      // Versión 2.0.0 - CULTIVO DECLARADO
      `https://wms.mapa.gob.es/sigpac/wfs?service=WFS&version=2.0.0&request=GetFeature&typename=AU.Sigpac:linea_declaracion&outputFormat=application/json&srsname=EPSG:4326&bbox=${bbox1}`,
      // Versión 1.1.0 con BBOX invertido - CULTIVO DECLARADO
      `https://wms.mapa.gob.es/sigpac/wfs?service=WFS&version=1.1.0&request=GetFeature&typename=AU.Sigpac:linea_declaracion&outputFormat=application/json&srsname=EPSG:4326&bbox=${bbox2}`
    ];
    
    console.log(`🔍 SIGPAC CONSULTA MÚLTIPLE para ${point.lat.toFixed(4)}, ${point.lng.toFixed(4)}`);
    console.log(`📍 BBOX1 (lng,lat): ${bbox1}`);
    console.log(`📍 BBOX2 (lat,lng): ${bbox2}`);
    
    let recintoData = null;
    let cultivoData = null;
    
    // Probar todas las URLs de recinto hasta encontrar una que funcione
    for (let i = 0; i < urls.length; i++) {
      const wfsUrl = urls[i];
      console.log(`🔄 Probando URL ${i+1}/3: WFS v${wfsUrl.includes('2.0.0') ? '2.0.0' : '1.1.0'}`);
      
      try {
        const response = await fetch(wfsUrl);
        if (!response.ok) {
          console.warn(`⚠️  URL ${i+1} falló: ${response.status}`);
          continue;
        }
        
        const data = await response.json();
        const featuresCount = data.features?.length || 0;
        
        if (featuresCount > 0) {
          console.log(`✅ SIGPAC RECINTO ÉXITO con URL ${i+1}: ${featuresCount} parcelas encontradas`);
          
          const feature = data.features[0];
          const properties = feature.properties;
          
          // DEBUG: Log completo de la primera parcela
          console.log(`🔬 DEBUG PARCELA COMPLETA:`, {
            totalFeatures: featuresCount,
            allKeys: Object.keys(properties || {}),
            geometry: feature.geometry?.type,
            properties: properties
          });
          
          recintoData = {
            cultivo: properties.uso_sigpac || properties.grupo_cultivo || properties.descripcion || 'default',
            superficie: properties.dn_surface || 0,
            provincia: properties.provincia || properties.prov || '',
            municipio: properties.municipio || properties.mun || '',
            agregado: properties.agregado || '',
            zona: properties.zona || '',
            poligono: properties.poligono || '',
            parcela: properties.parcela || '',
            recinto: properties.recinto || '',
            region: properties.region || '',
            altitud: properties.altitud || 0,
            coordenadas: `${point.lat.toFixed(4)}, ${point.lng.toFixed(4)}`
          };
          
          console.log(`🌾 SIGPAC RECINTO DATOS:`, recintoData);
          
          break; // Salir del bucle si encontramos datos de recinto
        } else {
          console.log(`⚠️  URL ${i+1} sin resultados: 0 parcelas`);
        }
      } catch (urlError) {
        console.warn(`⚠️  Error con URL ${i+1}:`, urlError.message);
        continue;
      }
    }
    
    // Ahora intentar obtener datos de cultivo declarado
    console.log(`🌾 Intentando obtener CULTIVO DECLARADO...`);
    for (let i = 0; i < cultivoUrls.length; i++) {
      const cultivoUrl = cultivoUrls[i];
      console.log(`🔄 Probando CULTIVO URL ${i+1}/3: WFS v${cultivoUrl.includes('2.0.0') ? '2.0.0' : '1.1.0'}`);
      
      try {
        const response = await fetch(cultivoUrl);
        if (!response.ok) {
          console.warn(`⚠️  CULTIVO URL ${i+1} falló: ${response.status}`);
          continue;
        }
        
        const data = await response.json();
        const featuresCount = data.features?.length || 0;
        
        if (featuresCount > 0) {
          logAnalysis(`✅ CULTIVO DECLARADO ÉXITO con URL ${i+1}: ${featuresCount} cultivos encontrados`);
          
          const feature = data.features[0];
          const properties = feature.properties;
          
          logAnalysis(`🌾 DEBUG CULTIVO COMPLETO`, {
            totalFeatures: featuresCount,
            allKeys: Object.keys(properties || {}),
            properties: properties
          });
          
          cultivoData = {
            cultivo: mapSIGPACCropCode(properties.parc_producto_desc || properties.cultivo || 'default'),
            superficieCultivo: properties.parc_supcult || 0,
            campana: properties.exp_ano,
            codigoCultivo: properties.parc_producto,
            municipioNombre: properties.municipio_nombre || properties.municipio
          };
          
          logAnalysis(`🎯 CULTIVO DECLARADO DATOS`, cultivoData);
          break;
        } else {
          console.log(`⚠️  CULTIVO URL ${i+1} sin resultados: 0 cultivos`);
        }
      } catch (urlError) {
        console.warn(`⚠️  Error con CULTIVO URL ${i+1}:`, urlError.message);
        continue;
      }
    }
    
    // Combinar datos de recinto y cultivo
    const finalData = recintoData || { 
      cultivo: 'default', 
      superficie: 0, 
      pendiente: 0,
      municipioNombre: '',
      source: 'Fallback',
      coordenadas: `${point.lat.toFixed(4)}, ${point.lng.toFixed(4)}`
    };
    
    // INTEGRAR DATOS DE CULTIVO ESPECÍFICO
    if (cultivoData && cultivoData.cultivo) {
      finalData.cultivo = cultivoData.cultivo;
      finalData.superficieCultivo = cultivoData.superficieCultivo;
      finalData.campana = cultivoData.campana;
      finalData.codigoCultivo = cultivoData.codigoCultivo;
      finalData.tieneCultivoDeclarado = true;
      
      logAnalysis(`✅ CULTIVO ESPECÍFICO INTEGRADO: ${cultivoData.cultivo}`, cultivoData);
    } else {
      finalData.tieneCultivoDeclarado = false;
    }
    
    // Clasificar zona basado en datos SIGPAC reales
    const clasificacion = clasificarZonaPorSIGPAC(finalData);
    console.log(`📍 CLASIFICACIÓN FINAL: ${clasificacion.descripcion}`);
    
    return {
      ...finalData,
      esUrbano: clasificacion.esUrbano,
      esMonte: clasificacion.esMonte,
      tipoZona: clasificacion.tipo,
      descripcionZona: clasificacion.descripcion
    };
    
  } catch (error) {
    console.error(`💥 ERROR GENERAL SIGPAC para ${point.lat.toFixed(4)}, ${point.lng.toFixed(4)}:`, error.message);
    const clasificacion = clasificarZonaPorSIGPAC(null);
    return { 
      cultivo: 'default', 
      superficie: 0, 
      pendiente: 0,
      esUrbano: clasificacion.esUrbano,
      esMonte: clasificacion.esMonte,
      tipoZona: clasificacion.tipo,
      descripcionZona: clasificacion.descripcion
    };
  }
}

// Consultar Dynamic World real vía backend
async function getDynamicWorldRealData(point) {
  try {
    const response = await fetch(`${BACKEND}/dynamic-world-point?lat=${point.lat}&lng=${point.lng}`);
    
    if (!response.ok) {
      console.warn(`Dynamic World no disponible (${response.status}), usando fallback`);
      // Fallback basado en coordenadas determinísticas
      return getDeterministicFallback(point, 'vegetation');
    }
    
    const data = await response.json();
    return {
      landCover: data.landCover,
      confidence: data.confidence,
      source: 'Dynamic World'
    };
  } catch (error) {
    console.warn('Error consultando Dynamic World, usando fallback:', error);
    return getDeterministicFallback(point, 'vegetation');
  }
}

// Consultar OpenStreetMap Overpass API real
async function getOSMRealData(point) {
  try {
    const bbox = `${point.lat-0.01},${point.lng-0.01},${point.lat+0.01},${point.lng+0.01}`;
    const overpassQuery = `
      [out:json][timeout:10];
      (
        way["natural"="water"](${bbox});
        way["waterway"](${bbox});
        way["highway"](${bbox});
        way["landuse"="industrial"](${bbox});
      );
      out geom;
    `;
    
    const response = await fetch('https://overpass-api.de/api/interpreter', {
      method: 'POST',
      headers: { 'Content-Type': 'text/plain' },
      body: overpassQuery
    });
    
    if (!response.ok) {
      console.warn(`OSM Overpass no disponible (${response.status}), usando fallback`);
      return getDeterministicFallback(point, 'infrastructure');
    }
    
    const data = await response.json();
    
    // Procesar elementos OSM
    const waterFeatures = data.elements.filter(el => 
      el.tags && (el.tags.natural === 'water' || el.tags.waterway)
    );
    const roads = data.elements.filter(el => 
      el.tags && el.tags.highway
    );
    const industrial = data.elements.filter(el => 
      el.tags && el.tags.landuse === 'industrial'
    );
    
    return {
      waterNearby: waterFeatures.length > 0,
      waterCount: waterFeatures.length,
      roadAccess: roads.length > 0,
      roadCount: roads.length,
      industrialNearby: industrial.length > 0,
      industrialCount: industrial.length,
      source: 'OSM Overpass'
    };
  } catch (error) {
    console.warn('Error consultando OSM Overpass, usando fallback:', error);
    return getDeterministicFallback(point, 'infrastructure');
  }
}

// Calcular score con datos reales
async function calculateRealScore(point, month, center) {
  const realData = await getRealDataForPoint(point, month, center);
  
  // Clasificar zona usando datos SIGPAC
  const clasificacion = clasificarZonaPorSIGPAC(realData.sigpacData);
  logAnalysis(`🏷️ CLASIFICACIÓN ZONA`, clasificacion);
  
  // Penalización severa para zonas urbanas
  if (clasificacion.esUrbano) {
    logAnalysis(`🚫 ZONA URBANA - Score penalizado: ${clasificacion.descripcion}`);
    return Math.min(15, 15); // Score muy bajo para zonas urbanas
  }
  
  // Penalización menor para zonas urbanas detectadas solo por Dynamic World
  if (realData.dynamicWorldData.landCover === 'built') {
    logAnalysis(`🏢 Dynamic World detecta zona construida - Score penalizado`);
    return Math.min(25, 25);
  }
  
  // SCORING BASADO EN SIGPAC COMO FUENTE PRINCIPAL (50% del peso total)
  const baseScore = 100 * (
    0.50 * realData.floralIndex +        // SIGPAC: 50% - FUENTE PRINCIPAL
    0.15 * realData.vegetationScore +   // Dynamic World: 15% - Solo complemento
    0.15 * realData.waterFactor +       // OSM: 15%
    0.10 * realData.accessibilityFactor - // OSM: 10%
    0.20 * realData.industrialPenalty -   // OSM: -20%
    0.10 * realData.roadPenalty -         // OSM: -10%
    0.05 * realData.slopePenalty          // DEM: -5%
  );
  
  console.log(`Score para ${point.lat.toFixed(4)}, ${point.lng.toFixed(4)}:`, {
    'SIGPAC floralIndex (50%)': (realData.floralIndex * 50).toFixed(1),
    'Dynamic World (15%)': (realData.vegetationScore * 15).toFixed(1),
    'Cultivo SIGPAC': realData.sigpacData.cultivo,
    'Score final': Math.max(0, Math.min(100, baseScore + 40 - (realData.accessibilityFactor > 0.8 && realData.industrialPenalty > 0.3 ? 50 : 0))).toFixed(1)
  });
  
  // Penalización adicional para zonas que parecen urbanas por otros indicadores
  let urbanPenalty = 0;
  if (realData.accessibilityFactor > 0.8 && realData.industrialPenalty > 0.3) {
    urbanPenalty = 50; // Penalización fuerte si hay mucho acceso + industria
  }
  
  return Math.max(0, Math.min(100, baseScore + 40 - urbanPenalty));
}

// Mapear cultivos específicos declarados a tipos fenológicos
function mapSpecificCropToPhenology(cultivoEspecifico) {
  const cultivoLower = cultivoEspecifico.toLowerCase();
  
  // Mapeo de cultivos específicos SIGPAC a tipos fenológicos
  const mappingEspecifico = {
    // Viñedo
    'viña': 'viñedo',
    'vid': 'viñedo',
    'uva': 'viñedo',
    
    // Olivo
    'olivo': 'olivo',
    'olivar': 'olivo',
    'aceituna': 'olivo',
    
    // Almendro
    'almendro': 'almendro',
    'almendra': 'almendro',
    
    // Cítricos
    'naranjo': 'naranjo',
    'naranja': 'naranjo',
    'limón': 'naranjo',
    'mandarina': 'naranjo',
    'cítrico': 'naranjo',
    
    // Girasol
    'girasol': 'girasol',
    
    // Cereales
    'trigo': 'cereales',
    'cebada': 'cereales',
    'avena': 'cereales',
    'centeno': 'cereales',
    'maíz': 'cereales',
    'arroz': 'cereales',
    'cereal': 'cereales',
    
    // Leguminosas (excelentes para abejas)
    'guisante': 'cereales',
    'haba': 'cereales', 
    'lenteja': 'cereales',
    'garbanzo': 'cereales',
    'judía': 'cereales',
    'alubia': 'cereales',
    
    // Oleaginosas (muy buenas para abejas)
    'girasol': 'girasol',
    'colza': 'girasol', // Similar fenología
    'lino': 'cereales',
    'cártamo': 'girasol',
    
    // Hortalizas
    'tomate': 'cereales',
    'pimiento': 'cereales',
    'lechuga': 'cereales',
    'zanahoria': 'cereales',
    'cebolla': 'cereales',
    
    // Frutales (floración primaveral)
    'manzano': 'frutales',
    'peral': 'frutales',
    'melocotonero': 'frutales',
    'cerezo': 'frutales',
    'ciruelo': 'frutales',
    'frutal': 'frutales',
    
    // Cítricos completos
    'naranjo': 'naranjo',
    'naranja': 'naranjo',
    'limonero': 'naranjo',
    'limón': 'naranjo',
    'mandarino': 'naranjo',
    'mandarina': 'naranjo',
    'pomelo': 'naranjo',
    'cítrico': 'naranjo',
    
    // Frutos secos (muy importantes para abejas)
    'almendro': 'almendro',
    'almendra': 'almendro',
    'avellano': 'almendro', // Similar fenología
    'avellana': 'almendro',
    'nogal': 'frutales',
    'nuez': 'frutales',
    'pistacho': 'almendro',
    
    // Aromáticas (excelentes para abejas)
    'lavanda': 'lavanda',
    'romero': 'matorral',
    'tomillo': 'matorral',
    'orégano': 'matorral',
    'salvia': 'matorral',
    'menta': 'matorral',
    
    // Otros cultivos importantes
    'alfalfa': 'matorral', // Excelente para abejas
    'tabaco': 'cereales',
    'espárrago': 'cereales',
    'algodón': 'cereales',
    'lúpulo': 'matorral',
    
    // Pastos y naturales
    'pasto': 'pastizal',
    'pastizal': 'pastizal',
    'monte': 'matorral',
    'matorral': 'matorral',
    'bosque': 'bosque_frondoso'
  };
  
  // Buscar coincidencia parcial
  for (const [key, value] of Object.entries(mappingEspecifico)) {
    if (cultivoLower.includes(key)) {
      console.log(`🎯 MAPEO ESPECÍFICO: '${cultivoEspecifico}' contiene '${key}' -> '${value}'`);
      return value;
    }
  }
  
  console.log(`⚠️ CULTIVO NO MAPEADO: '${cultivoEspecifico}' -> usando 'default'`);
  return 'default';
}

// Obtener índice floral de datos SIGPAC reales - FUENTE PRINCIPAL (50% peso)
function getFloralIndexFromSIGPAC(sigpacData, month) {
  // PRIORIZAR CULTIVO ESPECÍFICO DECLARADO si está disponible
  if (sigpacData.cultivoEspecifico) {
    const specificCrop = mapSpecificCropToPhenology(sigpacData.cultivoEspecifico);
    const specificPhenology = CROP_PHENOLOGY[specificCrop] || CROP_PHENOLOGY['default'];
    const specificIndex = specificPhenology[month] || 0;
    
    console.log(`🎯 CULTIVO ESPECÍFICO - ${sigpacData.cultivoEspecifico} -> Tipo: ${specificCrop} -> Índice mes ${month}: ${specificIndex}`);
    return specificIndex;
  }
  
  // Fallback al código general SIGPAC
  const cropType = mapSIGPACCropCode(sigpacData.cultivo);
  const phenology = CROP_PHENOLOGY[cropType] || CROP_PHENOLOGY['default'];
  const floralIndex = phenology[month] || 0;
  
  console.log(`SIGPAC general - Cultivo: ${sigpacData.cultivo} -> Tipo: ${cropType} -> Índice mes ${month}: ${floralIndex}`);
  return floralIndex;
}

// Obtener score de vegetación de Dynamic World - SOLO COMPLEMENTO (15% peso)
function getVegetationScoreFromDynamicWorld(dynamicWorldData) {
  const landCover = dynamicWorldData.landCover || 'crops';
  const score = VEGETATION_SCORES[landCover] || 0.5;
  
  console.log(`Dynamic World complemento - LandCover: ${landCover} -> Score: ${score} (Fuente: ${dynamicWorldData.source})`);
  return score;
}

// Calcular factor agua de datos OSM reales
function getWaterFactorFromOSM(osmData) {
  // En zonas rurales de montaña, asumimos mejor acceso a agua natural
  if (osmData.source === 'Fallback determinístico') {
    return osmData.waterNearby ? 0.8 : 0.6; // Más optimista en fallback
  }
  
  if (!osmData.waterFeatures || osmData.waterFeatures.length === 0) {
    return 0.6; // Más optimista para zonas rurales
  }
  
  const waterCount = osmData.waterFeatures.length;
  if (waterCount >= 3) return 1.0;
  if (waterCount >= 1) return 0.8;
  return 0.6;
}

// Calcular accesibilidad de datos OSM reales
function getAccessibilityFromOSM(osmData) {
  // En zonas rurales, el acceso por caminos rurales es suficiente
  if (osmData.source === 'Fallback determinístico') {
    return osmData.roadAccess ? 0.7 : 0.5; // Más optimista en fallback
  }
  
  if (!osmData.roads || osmData.roads.length === 0) {
    return 0.5; // Más optimista para zonas rurales
  }
  
  const roadTypes = osmData.roads.map(r => r.tags.highway);
  if (roadTypes.includes('primary') || roadTypes.includes('secondary')) return 0.9;
  if (roadTypes.includes('tertiary') || roadTypes.includes('unclassified')) return 0.8;
  if (roadTypes.includes('track') || roadTypes.includes('path')) return 0.7;
  return 0.5;
}

// Calcular penalización industrial de datos OSM reales
function getIndustrialPenaltyFromOSM(osmData) {
  if (!osmData.industrial || osmData.industrial.length === 0) {
    return 0; // Sin industria cercana
  }
  
  const industrialCount = osmData.industrial.length;
  return Math.min(1.0, industrialCount * 0.3); // Penalización proporcional
}

// Calcular penalización de carreteras de datos OSM reales
function getRoadPenaltyFromOSM(osmData) {
  if (!osmData.roads || osmData.roads.length === 0) {
    return 0;
  }
  
  const majorRoads = osmData.roads.filter(r => 
    ['motorway', 'trunk', 'primary'].includes(r.tags.highway)
  );
  
  return Math.min(0.5, majorRoads.length * 0.2);
}

// Calcular penalización de pendiente (simplificado)
function getSlopePenaltyFromDEM(point) {
  // En una implementación real, consultaríamos un DEM
  // Por ahora, estimación basada en latitud (zonas montañosas del norte)
  const mountainousRegion = point.lat > 42.5; // Norte de España más montañoso
  return mountainousRegion ? 0.3 : 0.1;
}

// Mapear códigos SIGPAC reales - AMPLIADO para evitar índices 0
function mapSIGPACCropCode(code) {
  const sigpacMapping = {
    // Cultivos principales con alta fenología
    'OV': 'olivo', 'VI': 'viñedo', 'CE': 'cereales', 'GI': 'girasol',
    'AL': 'almendro', 'CI': 'naranjo', 'MT': 'matorral', 'FO': 'bosque_frondoso',
    'PA': 'pastizal', 'IM': 'improductivo', 'ZU': 'urbano', 'AG': 'cereales',
    'TR': 'cereales', 'MA': 'cereales', 'AV': 'cereales',
    
    // Códigos adicionales SIGPAC detectados
    'TA': 'cereales',     // Tierras arables
    'TH': 'huerta',       // Huerta
    'CF': 'citricos',     // Cítricos-frutales  
    'CS': 'citricos',     // Cítricos-frutales cáscara
    'CV': 'citricos',     // Cítricos-viñedo
    'FF': 'frutales',     // Frutales-frutales cáscara
    'FL': 'olivo',        // Frutos secos y olivar
    'FS': 'frutales',     // Frutos secos
    'FV': 'frutales',     // Frutos secos y viñedo
    'FY': 'frutales',     // Frutales
    'OC': 'olivo',        // Olivar-cítricos
    'OF': 'olivo',        // Olivar-frutal
    'VO': 'viñedo',       // Viñedo-olivar
    'VF': 'viñedo',       // Viñedo-frutal
    'PR': 'pastizal',     // Pasto arbustivo
    'PS': 'pastizal',     // Pastizal
    'IV': 'improductivo', // Invernaderos
    'ED': 'urbano',       // Edificaciones
    'CA': 'urbano',       // Viales
    'EP': 'matorral',     // Elemento paisaje
    'default': 'default'
  };
  
  const mappedType = sigpacMapping[code] || 'default';
  console.log(`🔍 MAPEO SIGPAC: Código '${code}' -> Tipo '${mappedType}'`);
  return mappedType;
}

// Mapear cultivos específicos declarados a nombres legibles
function mapSpecificCrop(cultivoCode) {
  const cultivosMapeados = {
    // Cereales
    'TRI': 'Trigo',
    'CEB': 'Cebada', 
    'AVE': 'Avena',
    'CEN': 'Centeno',
    'MAI': 'Maíz',
    'ARR': 'Arroz',
    
    // Leguminosas
    'GUA': 'Guisantes',
    'HAB': 'Habas',
    'LEN': 'Lentejas',
    'GAR': 'Garbanzos',
    'JUD': 'Judías',
    'ALT': 'Altramuces',
    
    // Oleaginosas
    'GIR': 'Girasol',
    'COL': 'Colza',
    'LIN': 'Lino',
    'CAR': 'Cártamo',
    
    // Tubérculos
    'PAT': 'Patata',
    'REM': 'Remolacha',
    
    // Hortalizas
    'TOM': 'Tomate',
    'PIM': 'Pimiento',
    'BER': 'Berenjena',
    'CAL': 'Calabacín',
    'LEC': 'Lechuga',
    'COL': 'Coliflor',
    'BRO': 'Brócoli',
    'ZAN': 'Zanahoria',
    'CEB': 'Cebolla',
    'AJO': 'Ajo',
    
    // Frutales
    'MAN': 'Manzano',
    'PER': 'Peral',
    'MER': 'Melocotonero',
    'CIR': 'Ciruelo',
    'CER': 'Cerezo',
    'ALB': 'Albaricoquero',
    'HIG': 'Higuera',
    'GRA': 'Granado',
    'KAK': 'Caqui',
    
    // Cítricos
    'NAR': 'Naranjo',
    'LIM': 'Limonero',
    'MAN': 'Mandarino',
    'POM': 'Pomelo',
    
    // Frutos secos
    'ALM': 'Almendro',
    'AVE': 'Avellano',
    'NOG': 'Nogal',
    'CAS': 'Castaño',
    'PIS': 'Pistacho',
    
    // Viñedo
    'VIN': 'Viñedo',
    'UVA': 'Uva de mesa',
    'PAS': 'Uva pasa',
    
    // Olivar
    'OLI': 'Olivo',
    'ACE': 'Aceituna de mesa',
    
    // Aromáticas y medicinales
    'LAV': 'Lavanda',
    'ROM': 'Romero',
    'TOM': 'Tomillo',
    'ORE': 'Orégano',
    'SAL': 'Salvia',
    'MEN': 'Menta',
    
    // Forrajes
    'ALF': 'Alfalfa',
    'TRE': 'Trébol',
    'VEZ': 'Veza',
    'RAY': 'Raigrás',
    
    // Otros
    'TAB': 'Tabaco',
    'ALG': 'Algodón',
    'LUP': 'Lúpulo',
    'ESP': 'Espárrago'
  };
  
  const nombreLegible = cultivosMapeados[cultivoCode] || cultivoCode;
  console.log(`🎯 MAPEO CULTIVO ESPECÍFICO: '${cultivoCode}' -> '${nombreLegible}'`);
  return nombreLegible;
}

// Determinar sistema de explotación
function getSistemaExplotacion(codigo) {
  if (!codigo) return 'No especificado';
  
  const sistemas = {
    'R': 'Regadío',
    'S': 'Secano',
    'REG': 'Regadío',
    'SEC': 'Secano'
  };
  
  return sistemas[codigo] || codigo;
}

// Limpiar análisis anterior
function clearPreviousAnalysis() {
  if (window.analysisMarkers) {
    analysisMarkers.forEach(marker => map.removeLayer(marker));
    analysisMarkers.length = 0;
  }
  
  if (window.heatmapLayer) {
    map.removeLayer(heatmapLayer);
    heatmapLayer = null;
  }
}

// Generar rejilla determinística con distribución uniforme
function generateDeterministicGrid(center, maxPoints = 147) {
  const points = [];
  const radiusKm = 5;
  const radiusDeg = radiusKm / 111;
  
  // Ajustar resolución según número de puntos deseados
  let gridResolution;
  if (maxPoints <= 25) {
    gridResolution = 8;   // Grid pequeño para análisis rápido
  } else if (maxPoints <= 60) {
    gridResolution = 12;  // Grid medio
  } else {
    gridResolution = 15;  // Grid completo
  }
  
  console.log(`🎯 Generando grid ${gridResolution}x${gridResolution} para ${maxPoints} puntos máximo`);
  
  for (let i = 0; i < gridResolution; i++) {
    for (let j = 0; j < gridResolution; j++) {
      const x = (i / (gridResolution - 1)) * 2 - 1;
      const y = (j / (gridResolution - 1)) * 2 - 1;
      
      const distance = Math.sqrt(x * x + y * y);
      if (distance <= 1) {
        const lat = center.lat + (y * radiusDeg);
        const lng = center.lng + (x * radiusDeg);
        
        const realDistance = getDistanceKm(center.lat, center.lng, lat, lng);
        if (realDistance <= radiusKm) {
          points.push({ lat, lng });
        }
      }
    }
  }
  
  // Si tenemos más puntos de los necesarios, seleccionar uniformemente distribuidos
  if (points.length > maxPoints) {
    const step = points.length / maxPoints;
    const selectedPoints = [];
    for (let i = 0; i < maxPoints; i++) {
      const index = Math.floor(i * step);
      selectedPoints.push(points[index]);
    }
    console.log(`📊 Seleccionados ${selectedPoints.length} puntos de ${points.length} total (distribución uniforme)`);
    return selectedPoints;
  }
  
  console.log(`📊 Generados ${points.length} puntos dentro del radio`);
  return points;
}

// Calcular distancia en km
function getDistanceKm(lat1, lng1, lat2, lng2) {
  const R = 6371;
  const dLat = (lat2 - lat1) * Math.PI / 180;
  const dLng = (lng2 - lng1) * Math.PI / 180;
  const a = Math.sin(dLat/2) * Math.sin(dLat/2) +
            Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) *
            Math.sin(dLng/2) * Math.sin(dLng/2);
  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
  return R * c;
}

// Crear mapa de calor
function createHeatmap(analysisResults) {
  const filteredResults = analysisResults.filter(result => result.score > 60);
  
  if (filteredResults.length > 0) {
    const heatData = filteredResults.map(result => [
      result.lat,
      result.lng,
      result.intensity
    ]);
    
    heatmapLayer = L.heatLayer(heatData, {
      radius: 30,
      blur: 20,
      maxZoom: 15,
      gradient: {
        0.0: 'rgba(0,255,0,0)',
        0.4: 'rgba(0,255,0,0.6)',
        0.6: 'rgba(255,255,0,0.7)',
        0.8: 'rgba(255,165,0,0.8)',
        1.0: 'rgba(255,0,0,1)'
      }
    }).addTo(map);
    
    console.log('Mapa de calor creado con', heatData.length, 'puntos de alta calidad');
  }
}

// Mostrar todos los puntos con colores según calidad
function showAllLocationsByQuality(sortedResults) {
  sortedResults.forEach((result, index) => {
    const color = getMarkerColor(result.score);
    const size = getMarkerSize(result.score);
    
    const marker = L.marker([result.lat, result.lng], {
      icon: L.divIcon({
        html: `<div style="background: ${color}; border-radius: 50%; width: ${size}px; height: ${size}px; display: flex; align-items: center; justify-content: center; color: white; font-size: ${size > 20 ? '12px' : '10px'}; font-weight: bold; border: 2px solid white; box-shadow: 0 2px 4px rgba(0,0,0,0.3);">${index + 1}</div>`,
        className: 'analysis-location-marker',
        iconSize: [size + 4, size + 4],
        iconAnchor: [(size + 4) / 2, (size + 4) / 2]
      })
    }).addTo(map);
    
    marker.bindPopup(createDetailedPopup(result, index + 1));
    analysisMarkers.push(marker);
  });
}

function getMarkerColor(score) {
  if (score >= 75) return '#22c55e';
  if (score >= 60) return '#f59e0b';
  return '#ef4444';
}

function getMarkerSize(score) {
  if (score >= 75) return 24;
  if (score >= 60) return 20;
  return 16;
}

function createDetailedPopup(result, rank) {
  const quality = getScoreDescription(result.score);
  const color = getMarkerColor(result.score);
  
  // Procesar datos de cultivo específico
  let cultivoInfo = '';
  if (result.sigpacData) {
    const cultivoGeneral = result.sigpacData.cultivo || 'No especificado';
    
    if (result.sigpacData.tieneCultivoDeclarado && result.sigpacData.cultivoEspecifico) {
      const cultivoEspecifico = mapSpecificCrop(result.sigpacData.cultivoEspecifico);
      const sistema = getSistemaExplotacion(result.sigpacData.sistemaExplotacion);
      const superficie = result.sigpacData.superficieCultivo || result.sigpacData.superficie || 0;
      
      cultivoInfo = `
        <div style="margin-top: 8px; padding: 8px; background: #e8f5e8; border-radius: 4px; border-left: 3px solid #22c55e;">
          <div style="font-weight: bold; color: #16a34a; margin-bottom: 4px;">🎯 Cultivo Específico Declarado:</div>
          <div style="font-size: 13px; margin: 2px 0;"><strong>${cultivoEspecifico}</strong></div>
          <div style="font-size: 12px; color: #666; margin: 2px 0;">
            ${sistema} • ${superficie.toFixed(2)} ha
            ${result.sigpacData.campana ? ` • Campaña ${result.sigpacData.campana}` : ''}
          </div>
        </div>
        <div style="margin-top: 4px; padding: 4px; background: #f0f9ff; border-radius: 4px;">
          <div style="font-size: 12px; color: #0369a1;"><strong>📋 Uso General SIGPAC:</strong> ${cultivoGeneral}</div>
        </div>`;
    } else {
      cultivoInfo = `
        <div style="margin-top: 8px; padding: 4px; background: #f0f9ff; border-radius: 4px;">
          <div style="font-size: 12px; color: #0369a1;"><strong>📋 SIGPAC:</strong> ${cultivoGeneral}</div>
          <div style="font-size: 11px; color: #64748b; margin-top: 2px;">Sin cultivo específico declarado</div>
        </div>`;
    }
  }
  
  return `
    <div style="min-width: 320px; font-family: Arial, sans-serif;">
      <h4 style="margin: 0 0 12px 0; color: ${color};">
        🐝 Posición ${rank} - Score: ${Math.round(result.score)}/100
      </h4>
      
      <div style="background: ${color}20; padding: 8px; border-radius: 6px; margin-bottom: 12px;">
        <strong style="color: ${color};">Idoneidad: ${quality}</strong>
      </div>
      
      <div style="margin-bottom: 12px;">
        <strong>📍 Coordenadas:</strong><br>
        ${result.lat.toFixed(4)}, ${result.lng.toFixed(4)}
      </div>
      
      <div style="background: #f8f9fa; padding: 10px; border-radius: 6px; margin-bottom: 8px;">
        <strong style="color: #2c5234;">🔍 Datos Reales:</strong>
        <div style="margin-top: 8px; font-size: 13px;">
          <div style="display: flex; justify-content: space-between; margin: 3px 0;">
            <span>🌸 Índice Floral (SIGPAC):</span>
            <span style="font-weight: bold; color: ${getScoreColor(result.floralIndex * 100)};">${Math.round(result.floralIndex * 100)}%</span>
          </div>
          <div style="display: flex; justify-content: space-between; margin: 3px 0;">
            <span>🌿 Vegetación (Dynamic World):</span>
            <span style="font-weight: bold; color: ${getScoreColor(result.vegetationScore * 100)};">${Math.round(result.vegetationScore * 100)}%</span>
          </div>
          <div style="display: flex; justify-content: space-between; margin: 3px 0;">
            <span>💧 Agua (OSM):</span>
            <span style="font-weight: bold; color: ${getScoreColor(result.waterFactor * 100)};">${Math.round(result.waterFactor * 100)}%</span>
          </div>
          <div style="display: flex; justify-content: space-between; margin: 3px 0;">
            <span>🛤️ Acceso (OSM):</span>
            <span style="font-weight: bold; color: ${getScoreColor(result.accessibilityFactor * 100)};">${Math.round(result.accessibilityFactor * 100)}%</span>
          </div>
          ${cultivoInfo}
        </div>
      </div>
      
      <div style="font-size: 12px; color: #666; text-align: center; margin-top: 8px;">
        Análisis con datos reales - SIGPAC + Cultivo Declarado + Dynamic World + OSM
      </div>
    </div>
  `;
}

function getScoreColor(value) {
  if (value >= 70) return '#22c55e';
  if (value >= 40) return '#f59e0b';
  return '#ef4444';
}

function getScoreDescription(score) {
  if (score >= 80) return 'Excelente';
  if (score >= 60) return 'Muy buena';
  if (score >= 40) return 'Buena';
  if (score >= 20) return 'Moderada';
  return 'Baja';
}
