Country Instability Index (CII)

const eventScore = (
  components.unrest * 0.25 +
  components.conflict * 0.30 +
  components.security * 0.20 +
  components.information * 0.25
);

const blendedScore = (
  baselineRisk * 0.4 +
  eventScore * 0.6 +
  hotspotBoost +
  newsUrgencyBoost +
  focalBoost +
  displacementBoost +
  climateBoost +
  orefBlendBoost +
  advisoryBoost +
  supplementalSignalBoost
);

const floor = Math.max(getUcdpFloor(data), getAdvisoryFloor(data));
const score = Math.round(Math.min(100, Math.max(floor, blendedScore)));

function calcUnrestScore(data: CountryData, countryCode: string): number {
  const protestCount = data.protests.length;
  const multiplier = CURATED_COUNTRIES[countryCode]?.eventMultiplier ?? DEFAULT_EVENT_MULTIPLIER;

  const isHighVolume = multiplier < 0.7;
  const adjustedCount = isHighVolume
    ? Math.log2(protestCount + 1) * multiplier * 5
    : protestCount * multiplier;

  const baseScore = Math.min(50, adjustedCount * 8);
  const fatalityBoost = Math.min(30, fatalities * 5 * multiplier);
  const severityBoost = Math.min(20, highSeverityCount * 10 * multiplier);
  const outageBoost = Math.min(50, totalOutages * 30 + majorOutages * 15 + partialOutages * 5);

  return Math.min(100, baseScore + fatalityBoost + severityBoost + outageBoost);
}

function calcConflictScore(data: CountryData, countryCode: string): number {
  const multiplier = CURATED_COUNTRIES[countryCode]?.eventMultiplier ?? DEFAULT_EVENT_MULTIPLIER;

  const eventScore = Math.min(50, (
    battleCount * 3 +
    explosionCount * 4 +
    civilianCount * 5
  ) * multiplier);

  const fatalityScore = Math.min(40, Math.sqrt(totalFatalities) * 5 * multiplier);
  const civilianBoost = civilianCount > 0 ? Math.min(10, civilianCount * 3) : 0;

  const acledScore = eventScore + fatalityScore + civilianBoost;

  // Fallback to HAPI humanitarian data if ACLED unavailable
  const hapiFallback = events.length === 0 && data.hapiSummary
    ? Math.min(60, data.hapiSummary.eventsPoliticalViolence * 3 * multiplier)
    : 0;

  // News floor: 2+ conflict/military headlines from tier-1/2 sources within 6h
  const newsFloor = calcNewsConflictFloor(data, multiplier);

  const strikeBoost = Math.min(50, recentStrikes.length * 3 + highSeverityStrikes * 5);
  const orefBoost = countryCode === 'IL' && data.orefAlertCount > 0
    ? 25 + Math.min(25, data.orefAlertCount * 5)
    : 0;

  return Math.min(100, Math.max(acledScore, hapiFallback, newsFloor) + strikeBoost + orefBoost);
}

function calcSecurityScore(data: CountryData): number {
  const flightScore = Math.min(50, data.militaryFlights.length * 3);
  const vesselScore = Math.min(30, data.militaryVessels.length * 5);

  const aviationScore = Math.min(40, data.aviationDisruptions.reduce((sum, a) => {
    if (a.delayType === 'closure') return sum + 20;
    if (a.severity === 'severe') return sum + 15;
    if (a.severity === 'major') return sum + 10;
    if (a.severity === 'moderate') return sum + 5;
    return sum;
  }, 0));

  const gpsJammingScore = Math.min(35,
    data.gpsJammingHighCount * 5 +
    data.gpsJammingMediumCount * 2
  );

  return Math.min(100, flightScore + vesselScore + aviationScore + gpsJammingScore);
}

function calcInformationScore(data: CountryData, countryCode: string): number {
  const count = data.newsEvents.length;
  if (count === 0) return 0;

  const multiplier = CURATED_COUNTRIES[countryCode]?.eventMultiplier ?? DEFAULT_EVENT_MULTIPLIER;
  const velocitySum = data.newsEvents.reduce((sum, e) => sum + (e.velocity?.sourcesPerHour || 0), 0);
  const avgVelocity = velocitySum / count;

  const isHighVolume = multiplier < 0.7;
  const adjustedCount = isHighVolume
    ? Math.log2(count + 1) * multiplier * 3
    : count * multiplier;

  const baseScore = Math.min(40, adjustedCount * 5);

  const velocityThreshold = isHighVolume ? 5 : 2;
  const velocityBoost = avgVelocity > velocityThreshold
    ? Math.min(40, (avgVelocity - velocityThreshold) * 10 * multiplier)
    : 0;

  const alertBoost = data.newsEvents.some(e => e.isAlert) ? 20 * multiplier : 0;

  return Math.min(100, baseScore + velocityBoost + alertBoost);
}

function trackHotspotActivity(lat: number, lon: number, weight: number = 1): void {
  for (const hotspot of INTEL_HOTSPOTS) {
    const dist = haversineKm(lat, lon, hotspot.lat, hotspot.lon);
    if (dist < 150) {
      const countryCodes = getHotspotCountries(hotspot.id);
      for (const countryCode of countryCodes) {
        hotspotActivityMap.set(countryCode, (hotspotActivityMap.get(countryCode) || 0) + weight);
      }
    }
  }
}

function getHotspotBoost(countryCode: string): number {
  const activity = hotspotActivityMap.get(countryCode) || 0;
  return Math.min(10, activity * 1.5);
}

function getTrend(code: string, current: number): CountryScore['trend'] {
  const prev = previousScores.get(code);
  if (prev === undefined) return 'stable';
  const diff = current - prev;
  if (diff >= 5) return 'rising';
  if (diff <= -5) return 'falling';
  return 'stable';
}

export function isInLearningMode(): boolean {
  if (hasCachedScoresAvailable) return false;
  if (isLearningComplete) return false;
  if (learningStartTime === null) return true;

  const elapsed = Date.now() - learningStartTime;
  if (elapsed >= LEARNING_DURATION_MS) {
    isLearningComplete = true;
    return false;
  }
  return true;
}