EcoField Safety Dashboard

// ERS Calculation Implementation
export function calculateRiskScore(pollutants: Pollutants): number {
  // Normalize each pollutant against regulatory limits
  const pm2_5_pct = (pollutants.pm2_5 / REGULATORY_LIMITS.pm2_5.limit) * 100;
  const no2_pct = (pollutants.no2 / REGULATORY_LIMITS.no2.limit) * 100;
  const o3_pct = (pollutants.o3 / REGULATORY_LIMITS.o3.limit) * 100;
  const co_pct = (pollutants.co / REGULATORY_LIMITS.co.limit) * 100;
  const so2_pct = (pollutants.so2 / REGULATORY_LIMITS.so2.limit) * 100;
  
  // Apply health impact weights
  const ers = 
    pm2_5_pct * RISK_WEIGHTS.pm2_5 +  // 35%
    no2_pct * RISK_WEIGHTS.no2 +       // 25%
    o3_pct * RISK_WEIGHTS.o3 +         // 25%
    co_pct * RISK_WEIGHTS.co +         // 10%
    so2_pct * RISK_WEIGHTS.so2;        // 5%
  
  return Math.min(Math.round(ers), 100); // Cap at 100
}

// Risk level categorization
export function getRiskLevel(ers: number): RiskLevel {
  if (ers <= 30) return 'low';
  if (ers <= 60) return 'moderate';
  return 'high';
}

// Compliance Check Implementation
export function checkCompliance(pollutants: Pollutants): ComplianceStatus[] {
  const compliance: ComplianceStatus[] = [];
  
  Object.entries(pollutants).forEach(([key, value]) => {
    const limit = REGULATORY_LIMITS[key];
    const percentage = (value / limit.limit) * 100;
    
    // Three-tier classification
    let status: 'safe' | 'warning' | 'danger';
    if (percentage <= 50) status = 'safe';
    else if (percentage <= 80) status = 'warning';
    else status = 'danger';
    
    compliance.push({
      pollutant: limit.name,
      current: value,
      limit: limit.limit,
      percentage: Math.min(percentage, 100),
      status,
      unit: limit.unit
    });
  });
  
  return compliance;
}

// Predictive Recommendation Engine
export function getSmartRecommendation(
  currentERS: number,
  forecast: ForecastData[],
  currentWindSpeed: number
): string {
  const riskLevel = getRiskLevel(currentERS);
  
  // Analyze 24-hour forecast trends
  const next24Hours = forecast.slice(0, 8); // 8 points = 24 hours
  const avgFutureERS = next24Hours.reduce((sum, f) => sum + f.ers, 0) / 
                       next24Hours.length;
  const avgFutureWind = next24Hours.reduce((sum, f) => sum + f.windSpeed, 0) / 
                        next24Hours.length;
  
  // Identify safe operational windows
  const safeWindows = next24Hours.filter(
    f => f.ers <= 30 && f.windSpeed >= WIND_THRESHOLDS.medium
  );
  
  // HIGH RISK scenarios
  if (riskLevel === 'high') {
    if (safeWindows.length > 0) {
      const hours = Math.round(
        (safeWindows[0].timestamp - Date.now()) / (1000 * 60 * 60)
      );
      return `⚠️ UNSAFE - High Risk Detected. Operations NOT recommended. ` +
             `Air quality expected to improve in approximately ${hours} hours.`;
    }
    return `⛔ UNSAFE - High Risk Detected. No improvement expected in ` +
           `next 24 hours. Recommend postponing all non-essential operations.`;
  }
  
  // MODERATE RISK scenarios
  if (riskLevel === 'moderate') {
    if (currentWindSpeed >= WIND_THRESHOLDS.medium && 
        avgFutureWind >= WIND_THRESHOLDS.medium) {
      return `⚡ PROCEED WITH CAUTION - Moderate risk levels. Wind ` +
             `conditions (${currentWindSpeed.toFixed(1)} m/s) support ` +
             `dispersion. Limit exposure time.`;
    }
    if (avgFutureERS < currentERS) {
      return `⏳ WAIT RECOMMENDED - Moderate risk with improving trends. ` +
             `Air quality expected to improve over next 6-12 hours.`;
    }
    return `⚡ PROCEED WITH CAUTION - Moderate risk levels. Implement ` +
           `enhanced safety protocols and monitor real-time conditions.`;
  }
  
  // LOW RISK scenarios
  if (currentWindSpeed >= WIND_THRESHOLDS.high) {
    return `✅ SAFE TO PROCEED - Low risk with excellent wind dispersion ` +
           `(${currentWindSpeed.toFixed(1)} m/s). Ideal for field operations.`;
  }
  return `✅ SAFE TO PROCEED - Low risk conditions detected. Air quality ` +
         `within acceptable limits. Maintain standard safety protocols.`;
}

// Parallel API Integration
const fetchData = async (city: City) => {
  try {
    // Fetch all 4 APIs in parallel (~500ms total)
    const [currentWeather, currentPollution, pollutionForecast, weatherForecast] = 
      await Promise.all([
        openWeatherService.getCurrentWeather(city.lat, city.lon),
        openWeatherService.getCurrentPollution(city.lat, city.lon),
        openWeatherService.getPollutionForecast(city.lat, city.lon),
        openWeatherService.getWeatherForecast(city.lat, city.lon)
      ]);
    
    // Process current data
    const currentData: CurrentData = {
      temperature: currentWeather.main.temp,
      windSpeed: currentWeather.wind.speed,
      humidity: currentWeather.main.humidity,
      aqi: currentPollution.list[0].main.aqi,
      pollutants: {
        pm2_5: currentPollution.list[0].components.pm2_5,
        no2: currentPollution.list[0].components.no2,
        o3: currentPollution.list[0].components.o3,
        co: currentPollution.list[0].components.co,
        so2: currentPollution.list[0].components.so2
      }
    };
    
    // Calculate ERS and compliance
    const ers = calculateRiskScore(currentData.pollutants);
    const compliance = checkCompliance(currentData.pollutants);
    
    // Process forecast (combine pollution + weather)
    const forecastData: ForecastData[] = pollutionForecast.list.map((pollItem, index) => {
      const weatherItem = weatherForecast.list[index];
      return {
        time: new Date(pollItem.dt * 1000).toLocaleTimeString(),
        pm2_5: pollItem.components.pm2_5,
        no2: pollItem.components.no2,
        o3: pollItem.components.o3,
        ers: calculateRiskScore(pollItem.components),
        windSpeed: weatherItem.wind.speed,
        aqi: pollItem.main.aqi
      };
    });
    
    // Generate recommendation
    const recommendation = getSmartRecommendation(ers, forecastData, currentData.windSpeed);
    
    setDashboardData({ current, forecast, compliance, ers, recommendation });
  } catch (err) {
    setError('Failed to fetch environmental data');
  }
};