Sustainability in Logistics: Driving Green Innovation in Consumer Goods and Distribution

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
from dataclasses import dataclass
from typing import Dict, List, Optional

@dataclass
class EmissionFactor:
    vehicle_type: str
    fuel_type: str
    co2_per_km: float  # kg CO2 per kilometer
    co2_per_liter: float  # kg CO2 per liter of fuel

@dataclass
class DeliveryRoute:
    route_id: str
    vehicle_type: str
    fuel_type: str
    distance_km: float
    fuel_consumed: float
    delivery_date: datetime
    packages_delivered: int

class SustainabilityTracker:
    def __init__(self):
        self.emission_factors = {
            ('diesel_truck', 'diesel'): EmissionFactor('diesel_truck', 'diesel', 0.85, 2.68),
            ('electric_truck', 'electric'): EmissionFactor('electric_truck', 'electric', 0.12, 0.0),
            ('hybrid_truck', 'hybrid'): EmissionFactor('hybrid_truck', 'hybrid', 0.45, 1.8),
            ('diesel_van', 'diesel'): EmissionFactor('diesel_van', 'diesel', 0.25, 2.68),
            ('electric_van', 'electric'): EmissionFactor('electric_van', 'electric', 0.08, 0.0),
            ('hydrogen_truck', 'hydrogen'): EmissionFactor('hydrogen_truck', 'hydrogen', 0.0, 0.0)
        }
        
        self.routes_data = []
        self.sustainability_targets = {
            'co2_reduction_target': 0.30,  # 30% reduction target
            'renewable_energy_target': 0.60,  # 60% renewable energy
            'waste_reduction_target': 0.40  # 40% waste reduction
        }
    
    def add_delivery_route(self, route: DeliveryRoute):
        """Add a delivery route to tracking system"""
        self.routes_data.append(route)
    
    def calculate_route_emissions(self, route: DeliveryRoute) -> Dict[str, float]:
        """Calculate emissions for a specific route"""
        key = (route.vehicle_type, route.fuel_type)
        
        if key not in self.emission_factors:
            raise ValueError(f"Emission factor not found for {key}")
        
        factor = self.emission_factors[key]
        
        # Calculate emissions
        distance_emissions = route.distance_km * factor.co2_per_km
        fuel_emissions = route.fuel_consumed * factor.co2_per_liter
        
        # Use the higher of the two methods for accuracy
        total_emissions = max(distance_emissions, fuel_emissions)
        
        return {
            'total_co2_kg': total_emissions,
            'co2_per_package': total_emissions / max(route.packages_delivered, 1),
            'co2_per_km': total_emissions / route.distance_km,
            'emission_factor_used': factor.vehicle_type
        }
    
    def generate_sustainability_report(self, start_date: datetime, end_date: datetime) -> Dict:
        """Generate comprehensive sustainability report"""
        period_routes = [
            route for route in self.routes_data 
            if start_date <= route.delivery_date <= end_date
        ]
        
        if not period_routes:
            return {'error': 'No data available for the specified period'}
        
        # Calculate total emissions
        total_emissions = 0
        total_distance = 0
        total_packages = 0
        vehicle_type_emissions = {}
        
        for route in period_routes:
            emissions_data = self.calculate_route_emissions(route)
            total_emissions += emissions_data['total_co2_kg']
            total_distance += route.distance_km
            total_packages += route.packages_delivered
            
            # Track by vehicle type
            vehicle_key = f"{route.vehicle_type}_{route.fuel_type}"
            if vehicle_key not in vehicle_type_emissions:
                vehicle_type_emissions[vehicle_key] = {
                    'emissions': 0, 'routes': 0, 'distance': 0
                }
            
            vehicle_type_emissions[vehicle_key]['emissions'] += emissions_data['total_co2_kg']
            vehicle_type_emissions[vehicle_key]['routes'] += 1
            vehicle_type_emissions[vehicle_key]['distance'] += route.distance_km
        
        # Calculate fleet composition
        total_routes = len(period_routes)
        electric_routes = len([r for r in period_routes if 'electric' in r.fuel_type])
        green_vehicle_percentage = (electric_routes / total_routes) * 100 if total_routes > 0 else 0
        
        # Generate recommendations
        recommendations = self._generate_recommendations(vehicle_type_emissions, total_emissions)
        
        report = {
            'period': {
                'start_date': start_date.isoformat(),
                'end_date': end_date.isoformat(),
                'days': (end_date - start_date).days
            },
            'summary': {
                'total_routes': total_routes,
                'total_emissions_kg': round(total_emissions, 2),
                'total_emissions_tonnes': round(total_emissions / 1000, 2),
                'total_distance_km': round(total_distance, 2),
                'total_packages': total_packages,
                'avg_emissions_per_route': round(total_emissions / total_routes, 2) if total_routes > 0 else 0,
                'avg_emissions_per_package': round(total_emissions / total_packages, 4) if total_packages > 0 else 0,
                'avg_emissions_per_km': round(total_emissions / total_distance, 4) if total_distance > 0 else 0
            },
            'fleet_composition': {
                'green_vehicle_percentage': round(green_vehicle_percentage, 1),
                'vehicle_breakdown': vehicle_type_emissions
            },
            'sustainability_metrics': self._calculate_sustainability_metrics(period_routes),
            'recommendations': recommendations,
            'carbon_offset_required': {
                'tonnes_to_offset': round(total_emissions / 1000, 2),
                'estimated_cost_usd': round((total_emissions / 1000) * 50, 2)  # Assume $50/tonne
            }
        }
        
        return report
    
    def _calculate_sustainability_metrics(self, routes: List[DeliveryRoute]) -> Dict:
        """Calculate sustainability performance metrics"""
        if not routes:
            return {}
        
        # Calculate green vehicle adoption
        green_vehicles = ['electric', 'hydrogen', 'hybrid']
        green_route_count = sum(1 for route in routes if any(fuel in route.fuel_type for fuel in green_vehicles))
        green_adoption_rate = (green_route_count / len(routes)) * 100
        
        # Calculate efficiency metrics
        total_distance = sum(route.distance_km for route in routes)
        total_packages = sum(route.packages_delivered for route in routes)
        
        avg_distance_per_route = total_distance / len(routes)
        avg_packages_per_route = total_packages / len(routes)
        delivery_density = total_packages / total_distance if total_distance > 0 else 0
        
        return {
            'green_adoption_rate_percent': round(green_adoption_rate, 1),
            'avg_distance_per_route_km': round(avg_distance_per_route, 2),
            'avg_packages_per_route': round(avg_packages_per_route, 1),
            'delivery_density_packages_per_km': round(delivery_density, 2),
            'sustainability_score': min(100, round(green_adoption_rate + (delivery_density * 10), 1))
        }
    
    def _generate_recommendations(self, vehicle_emissions: Dict, total_emissions: float) -> List[str]:
        """Generate sustainability improvement recommendations"""
        recommendations = []
        
        # Analyze vehicle composition
        diesel_emissions = sum(
            data['emissions'] for key, data in vehicle_emissions.items() 
            if 'diesel' in key
        )
        
        if diesel_emissions > total_emissions * 0.7:
            recommendations.append(
                "High diesel vehicle usage detected. Consider transitioning to electric or hybrid vehicles for urban deliveries."
            )
        
        # Check route efficiency
        avg_emissions_per_route = total_emissions / len(vehicle_emissions) if vehicle_emissions else 0
        if avg_emissions_per_route > 50:  # kg CO2 per route
            recommendations.append(
                "Route optimization recommended. Consider consolidating deliveries and implementing smart routing algorithms."
            )
        
        # Suggest green initiatives
        recommendations.extend([
            "Implement driver eco-training programs to improve fuel efficiency by 10-15%",
            "Consider installing telematics systems to monitor and optimize driving behavior",
            "Explore partnerships with renewable energy providers for electric vehicle charging",
            "Investigate carbon offset programs for remaining emissions"
        ])
        
        return recommendations

# Example usage:
# tracker = SustainabilityTracker()
# 
# # Add sample routes
# routes = [
#     DeliveryRoute('R001', 'diesel_truck', 'diesel', 150.5, 35.2, datetime(2025, 8, 1), 25),
#     DeliveryRoute('R002', 'electric_van', 'electric', 85.3, 0.0, datetime(2025, 8, 1), 18),
#     DeliveryRoute('R003', 'hybrid_truck', 'hybrid', 200.1, 28.5, datetime(2025, 8, 2), 35)
# ]
# 
# for route in routes:
#     tracker.add_delivery_route(route)
# 
# # Generate report
# report = tracker.generate_sustainability_report(
#     datetime(2025, 8, 1), datetime(2025, 8, 31)
# )
# print(json.dumps(report, indent=2))

class GreenLogisticsMonitor {
  constructor() {
    this.sensors = new Map();
    this.energyData = [];
    this.emissionFactors = {
      electricity_grid: 0.5, // kg CO2 per kWh
      solar: 0.05,
      diesel: 2.68, // kg CO2 per liter
      electric: 0.12 // kg CO2 per kWh (cleaner grid)
    };
  }

  // Register IoT sensors for monitoring
  registerSensor(sensorId, type, location, energySource) {
    const sensor = {
      id: sensorId,
      type: type, // 'lighting', 'hvac', 'vehicle', 'warehouse_equipment'
      location: location,
      energySource: energySource,
      status: 'active',
      lastReading: null,
      totalConsumption: 0
    };
    
    this.sensors.set(sensorId, sensor);
    return sensor;
  }

  // Process real-time energy consumption data
  async processEnergyReading(sensorId, consumption, timestamp = new Date()) {
    const sensor = this.sensors.get(sensorId);
    if (!sensor) {
      throw new Error(`Sensor ${sensorId} not registered`);
    }

    // Calculate emissions based on energy source
    const emissionFactor = this.emissionFactors[sensor.energySource] || 0.5;
    const co2Emissions = consumption * emissionFactor;

    const energyReading = {
      sensorId: sensorId,
      timestamp: timestamp,
      consumption: consumption, // kWh or liters
      co2Emissions: co2Emissions, // kg CO2
      energySource: sensor.energySource,
      location: sensor.location,
      sensorType: sensor.type
    };

    this.energyData.push(energyReading);
    sensor.lastReading = energyReading;
    sensor.totalConsumption += consumption;

    // Check for anomalies or efficiency opportunities
    await this.analyzeConsumption(energyReading);
    
    return energyReading;
  }

  // Analyze consumption patterns for optimization opportunities
  async analyzeConsumption(reading) {
    const historicalData = this.energyData.filter(data => 
      data.sensorId === reading.sensorId &&
      data.timestamp > new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) // Last 7 days
    );

    if (historicalData.length < 7) return; // Need at least a week of data

    const avgConsumption = historicalData.reduce((sum, data) => sum + data.consumption, 0) / historicalData.length;
    const threshold = avgConsumption * 1.2; // 20% above average

    if (reading.consumption > threshold) {
      await this.triggerAlert({
        type: 'HIGH_CONSUMPTION',
        sensorId: reading.sensorId,
        currentConsumption: reading.consumption,
        averageConsumption: avgConsumption,
        excessPercentage: ((reading.consumption - avgConsumption) / avgConsumption * 100).toFixed(1)
      });
    }

    // Suggest renewable energy if high consumption detected
    if (reading.energySource === 'electricity_grid' && reading.consumption > avgConsumption * 1.5) {
      await this.suggestRenewableEnergy(reading.sensorId, reading.location);
    }
  }

  // Generate sustainability dashboard data
  generateDashboard(timeRange = '24h') {
    const cutoffTime = this.getTimeRangeStart(timeRange);
    const recentData = this.energyData.filter(data => data.timestamp >= cutoffTime);

    // Aggregate by energy source
    const energyBySource = {};
    const emissionsBySource = {};
    const consumptionByLocation = {};

    recentData.forEach(reading => {
      // By energy source
      if (!energyBySource[reading.energySource]) {
        energyBySource[reading.energySource] = 0;
        emissionsBySource[reading.energySource] = 0;
      }
      energyBySource[reading.energySource] += reading.consumption;
      emissionsBySource[reading.energySource] += reading.co2Emissions;

      // By location
      if (!consumptionByLocation[reading.location]) {
        consumptionByLocation[reading.location] = { energy: 0, emissions: 0 };
      }
      consumptionByLocation[reading.location].energy += reading.consumption;
      consumptionByLocation[reading.location].emissions += reading.co2Emissions;
    });

    // Calculate renewable energy percentage
    const renewableEnergy = (energyBySource.solar || 0);
    const totalEnergy = Object.values(energyBySource).reduce((sum, val) => sum + val, 0);
    const renewablePercentage = totalEnergy > 0 ? (renewableEnergy / totalEnergy * 100) : 0;

    // Calculate total emissions
    const totalEmissions = Object.values(emissionsBySource).reduce((sum, val) => sum + val, 0);

    return {
      period: timeRange,
      summary: {
        totalEnergyConsumption: totalEnergy.toFixed(2),
        totalCO2Emissions: totalEmissions.toFixed(2),
        renewablePercentage: renewablePercentage.toFixed(1),
        activeSensors: this.sensors.size
      },
      energyBySource: energyBySource,
      emissionsBySource: emissionsBySource,
      consumptionByLocation: consumptionByLocation,
      sustainabilityScore: this.calculateSustainabilityScore(renewablePercentage, totalEmissions),
      recommendations: this.generateRecommendations(energyBySource, emissionsBySource)
    };
  }

  calculateSustainabilityScore(renewablePercentage, totalEmissions) {
    // Score based on renewable energy usage and emission levels
    let score = renewablePercentage; // Base score from renewable percentage
    
    // Bonus for low emissions (adjust thresholds as needed)
    if (totalEmissions < 100) score += 20;
    else if (totalEmissions < 500) score += 10;
    
    // Cap at 100
    return Math.min(100, Math.round(score));
  }

  generateRecommendations(energyBySource, emissionsBySource) {
    const recommendations = [];
    
    const totalEnergy = Object.values(energyBySource).reduce((sum, val) => sum + val, 0);
    const renewableEnergy = energyBySource.solar || 0;
    const renewablePercentage = totalEnergy > 0 ? (renewableEnergy / totalEnergy * 100) : 0;
    
    if (renewablePercentage < 30) {
      recommendations.push({
        priority: 'HIGH',
        category: 'Renewable Energy',
        action: 'Install solar panels or switch to renewable energy provider',
        potential_savings: 'Up to 70% reduction in energy-related emissions'
      });
    }
    
    if (energyBySource.electricity_grid > totalEnergy * 0.6) {
      recommendations.push({
        priority: 'MEDIUM',
        category: 'Energy Efficiency',
        action: 'Implement smart lighting and HVAC controls',
        potential_savings: '15-25% reduction in energy consumption'
      });
    }
    
    return recommendations;
  }

  async triggerAlert(alert) {
    console.log('SUSTAINABILITY ALERT:', alert);
    // In production, send to monitoring system
  }

  async suggestRenewableEnergy(sensorId, location) {
    console.log(`Renewable energy opportunity at ${location} for sensor ${sensorId}`);
    // Implementation for renewable energy suggestions
  }

  getTimeRangeStart(range) {
    const now = new Date();
    switch (range) {
      case '1h': return new Date(now.getTime() - 60 * 60 * 1000);
      case '24h': return new Date(now.getTime() - 24 * 60 * 60 * 1000);
      case '7d': return new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
      case '30d': return new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
      default: return new Date(now.getTime() - 24 * 60 * 60 * 1000);
    }
  }
}

// Example usage:
// const monitor = new GreenLogisticsMonitor();
// 
// // Register sensors
// monitor.registerSensor('LED_001', 'lighting', 'warehouse_zone_a', 'solar');
// monitor.registerSensor('HVAC_001', 'hvac', 'warehouse_main', 'electricity_grid');
// monitor.registerSensor('TRUCK_001', 'vehicle', 'delivery_fleet', 'electric');
// 
// // Process energy readings
// await monitor.processEnergyReading('LED_001', 2.5); // 2.5 kWh
// await monitor.processEnergyReading('HVAC_001', 15.3); // 15.3 kWh
// 
// // Generate dashboard
// const dashboard = monitor.generateDashboard('24h');
// console.log('Sustainability Dashboard:', dashboard);