const SHORT_TERM_STRATEGY = {
  primary: {
    usa: ['HRRR', 'NAM', 'NBM'],  // NBM = National Blend of Models
    europe: ['ICON-EU', 'AROME', 'ICON-D2'],
    asia: ['JMA', 'ICON'],
    global: ['GFS', 'ICON']
  },
  confidence: 0.90 - 0.95,
  updateFrequency: '1h',
  sources: {
    aviation: 'METAR/TAF via AviationWeather.gov',
    realtime: 'Open-Meteo avec modèles locaux'
  }
};

const MEDIUM_TERM_STRATEGY = {
  primary: ['ECMWF', 'GFS', 'ICON'],
  ensemble: true,  // Utiliser les ensembles pour la confiance
  confidence: 0.75 - 0.85,
  updateFrequency: '6h',
  consensusMethod: 'weighted_median',
  weights: {
    ecmwf: 1.0,   // Gold standard
    gfs: 0.85,
    icon: 0.90,
    ukmo: 0.85
  }
};

const EXTENDED_TERM_STRATEGY = {
  primary: ['ECMWF', 'GFS'],
  ensemble: 'required',
  confidence: 0.55 - 0.70,
  // Utiliser la dispersion de l'ensemble pour ajuster la confiance
  confidenceFormula: (ensembleSpread) => {
    // Plus la dispersion est faible, plus la confiance est haute
    return Math.max(0.40, 0.75 - (ensembleSpread * 0.05));
  }
};

const OPENMETEO_CONFIG = {
  // Endpoint principal avec multi-modèles
  forecast: {
    url: 'https://api.open-meteo.com/v1/forecast',
    params: {
      models: [
        'ecmwf_ifs04',        // ECMWF haute résolution
        'gfs_seamless',       // GFS avec HRRR intégré
        'icon_seamless',      // ICON avec local
        'gem_seamless',       // GEM Canada
        'jma_seamless',       // JMA Japon
        'meteofrance_seamless' // AROME/Arpège
      ],
      daily: 'temperature_2m_max,temperature_2m_min',
      timezone: 'auto',
      forecast_days: 10
    }
  },
  
  // ECMWF dédié (plus précis pour medium-range)
  ecmwf: {
    url: 'https://api.open-meteo.com/v1/ecmwf',
    params: {
      daily: 'temperature_2m_max,temperature_2m_min',
      forecast_days: 10
    }
  },
  
  // GFS avec HRRR (USA, court terme)
  gfsHrrr: {
    url: 'https://api.open-meteo.com/v1/gfs',
    params: {
      daily: 'temperature_2m_max,temperature_2m_min',
      minutely_15: 'temperature_2m', // HRRR 15-min pour USA
      forecast_days: 7
    }
  },
  
  // Ensemble API (pour calcul de confiance)
  ensemble: {
    url: 'https://api.open-meteo.com/v1/ensemble',
    params: {
      models: 'ecmwf_ifs025,gfs025,icon_seamless',
      daily: 'temperature_2m_max,temperature_2m_min'
    }
  }
};

function calculateEnsembleConsensus(forecasts) {
  const values = forecasts.map(f => f.tempMax);
  
  // Statistiques robustes
  const sorted = [...values].sort((a, b) => a - b);
  const median = sorted[Math.floor(sorted.length / 2)];
  const mean = values.reduce((a, b) => a + b) / values.length;
  const stdDev = Math.sqrt(
    values.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / values.length
  );
  
  // Coefficient de variation = mesure de l'accord entre modèles
  const cv = stdDev / Math.abs(mean);
  const agreement = Math.max(0, Math.min(1, 1 - cv));
  
  return {
    prediction: median,  // Médiane plus robuste que moyenne
    mean,
    stdDev,
    range: sorted[sorted.length - 1] - sorted[0],
    agreement,           // 0-1, 1 = accord parfait
    confidence: calculateConfidence(agreement, stdDev)
  };
}

const AVIATION_CONFIG = {
  metar: {
    url: 'https://aviationweather.gov/api/data/metar',
    params: {
      ids: 'KJFK,KLAX,KORD', // Codes ICAO
      format: 'json'
    },
    // Limitations
    rateLimit: '100 req/min',
    cors: 'blocked', // Nécessite proxy ou backend
  },
  
  taf: {
    url: 'https://aviationweather.gov/api/data/taf',
    params: {
      ids: 'KJFK',
      format: 'json'
    },
    // TAF = prévisions 24-30h aéroport
    horizon: '30h',
    precision: 'très haute pour J+0/J+1'
  }
};

// Mapping ville -> ICAO
const CITY_ICAO = {
  'NYC': 'KLGA',      // LaGuardia (utilisé par Polymarket)
  'Los Angeles': 'KLAX',
  'Chicago': 'KORD',
  'Miami': 'KMIA',
  'London': 'EGLC',   // London City (pas Heathrow!)
  'Paris': 'LFPG',
  'Tokyo': 'RJTT',
  // ...
};

const CACHE_STRATEGY = {
  // Les modèles se mettent à jour à heures fixes
  ecmwf: { updateTimes: ['00:00', '12:00'], cacheTTL: '6h' },
  gfs: { updateTimes: ['00:00', '06:00', '12:00', '18:00'], cacheTTL: '3h' },
  hrrr: { updateTimes: 'every_hour', cacheTTL: '1h' },
  
  // Invalider le cache après update
  shouldInvalidate: (model, lastFetch) => {
    const nextUpdate = getNextUpdateTime(model);
    return Date.now() > nextUpdate && lastFetch < nextUpdate;
  }
};

async function getForecastWithFallback(city, date) {
  const strategies = [
    () => fetchOpenMeteoMultiModel(city, date),
    () => fetchECMWFDirect(city, date),
    () => fetchGFSOnly(city, date),
    () => fetchVisualCrossing(city, date) // Backup payant
  ];
  
  for (const strategy of strategies) {
    try {
      const result = await strategy();
      if (result && result.confidence > 0.5) return result;
    } catch (e) {
      console.warn('Fallback to next source:', e.message);
    }
  }
  
  throw new Error('All weather sources failed');
}

function validateForecast(primary, secondary) {
  const diff = Math.abs(primary.tempMax - secondary.tempMax);
  
  // Si les sources divergent fortement, réduire la confiance
  if (diff > 5) {
    console.warn(`Large divergence: ${diff}°F between sources`);
    return {
      ...primary,
      confidence: primary.confidence * 0.7,
      warning: 'HIGH_MODEL_DIVERGENCE'
    };
  }
  
  return primary;
}