The Future of Supply Chain Technology: Transforming Consumer Goods and Distribution

import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestRegressor
from sklearn.preprocessing import StandardScaler
from datetime import datetime, timedelta
import joblib

class DemandForecastingEngine:
    def __init__(self):
        self.model = RandomForestRegressor(
            n_estimators=200,
            max_depth=10,
            random_state=42
        )
        self.scaler = StandardScaler()
        self.is_trained = False
        
    def prepare_features(self, sales_data, external_data):
        """Prepare features for demand forecasting"""
        # Time-based features
        sales_data['day_of_week'] = sales_data['date'].dt.dayofweek
        sales_data['month'] = sales_data['date'].dt.month
        sales_data['quarter'] = sales_data['date'].dt.quarter
        sales_data['is_weekend'] = sales_data['day_of_week'].isin([5, 6])
        
        # Rolling statistics
        sales_data['sales_7d_avg'] = sales_data['sales'].rolling(window=7).mean()
        sales_data['sales_30d_avg'] = sales_data['sales'].rolling(window=30).mean()
        sales_data['sales_7d_std'] = sales_data['sales'].rolling(window=7).std()
        
        # Lag features
        for lag in [1, 7, 14, 30]:
            sales_data[f'sales_lag_{lag}'] = sales_data['sales'].shift(lag)
        
        # External factors
        combined_data = sales_data.merge(
            external_data[['date', 'weather_temp', 'economic_index', 'competitor_price']],
            on='date',
            how='left'
        )
        
        # Price elasticity
        combined_data['price_change'] = combined_data['price'].pct_change()
        combined_data['competitor_price_diff'] = combined_data['price'] - combined_data['competitor_price']
        
        return combined_data.dropna()
    
    def train_model(self, prepared_data):
        """Train the demand forecasting model"""
        feature_columns = [
            'day_of_week', 'month', 'quarter', 'is_weekend',
            'sales_7d_avg', 'sales_30d_avg', 'sales_7d_std',
            'sales_lag_1', 'sales_lag_7', 'sales_lag_14', 'sales_lag_30',
            'weather_temp', 'economic_index', 'price_change', 'competitor_price_diff'
        ]
        
        X = prepared_data[feature_columns]
        y = prepared_data['sales']
        
        # Scale features
        X_scaled = self.scaler.fit_transform(X)
        
        # Train model
        self.model.fit(X_scaled, y)
        self.is_trained = True
        
        # Calculate feature importance
        feature_importance = pd.DataFrame({
            'feature': feature_columns,
            'importance': self.model.feature_importances_
        }).sort_values('importance', ascending=False)
        
        return feature_importance
    
    def forecast_demand(self, forecast_data, forecast_horizon=30):
        """Generate demand forecasts"""
        if not self.is_trained:
            raise ValueError("Model must be trained before forecasting")
        
        forecasts = []
        current_data = forecast_data.copy()
        
        for day in range(forecast_horizon):
            # Prepare features for current day
            feature_columns = [
                'day_of_week', 'month', 'quarter', 'is_weekend',
                'sales_7d_avg', 'sales_30d_avg', 'sales_7d_std',
                'sales_lag_1', 'sales_lag_7', 'sales_lag_14', 'sales_lag_30',
                'weather_temp', 'economic_index', 'price_change', 'competitor_price_diff'
            ]
            
            X_current = current_data[feature_columns].iloc[-1:]
            X_scaled = self.scaler.transform(X_current)
            
            # Generate prediction
            prediction = self.model.predict(X_scaled)[0]
            forecasts.append({
                'date': current_data['date'].iloc[-1] + timedelta(days=1),
                'predicted_sales': max(0, prediction),  # Ensure non-negative
                'confidence_interval': self._calculate_confidence_interval(prediction)
            })
            
            # Update rolling features for next iteration
            current_data = self._update_rolling_features(current_data, prediction)
        
        return pd.DataFrame(forecasts)
    
    def _calculate_confidence_interval(self, prediction, confidence=0.95):
        """Calculate confidence interval for predictions"""
        # Simplified confidence interval calculation
        std_error = prediction * 0.15  # Assume 15% standard error
        z_score = 1.96 if confidence == 0.95 else 1.645  # 95% or 90%
        
        return {
            'lower': max(0, prediction - z_score * std_error),
            'upper': prediction + z_score * std_error
        }
    
    def _update_rolling_features(self, data, new_value):
        """Update data with new prediction for rolling calculations"""
        # This is a simplified implementation
        # In practice, you'd update all rolling statistics
        return data
    
    def save_model(self, filepath):
        """Save trained model"""
        if self.is_trained:
            joblib.dump({
                'model': self.model,
                'scaler': self.scaler
            }, filepath)
    
    def load_model(self, filepath):
        """Load trained model"""
        components = joblib.load(filepath)
        self.model = components['model']
        self.scaler = components['scaler']
        self.is_trained = True

# Example usage:
# forecasting_engine = DemandForecastingEngine()
# prepared_data = forecasting_engine.prepare_features(sales_data, external_data)
# feature_importance = forecasting_engine.train_model(prepared_data)
# forecasts = forecasting_engine.forecast_demand(latest_data, forecast_horizon=30)

class WarehouseAutomationController {
  constructor() {
    this.robots = new Map();
    this.tasks = [];
    this.inventory = new Map();
    this.zones = new Map();
  }

  async initializeRobot(robotId, type, capabilities) {
    const robot = {
      id: robotId,
      type: type, // 'picker', 'packer', 'transporter'
      capabilities: capabilities,
      status: 'idle',
      currentTask: null,
      location: { x: 0, y: 0, zone: 'charging' },
      batteryLevel: 100,
      lastMaintenance: new Date()
    };
    
    this.robots.set(robotId, robot);
    await this.sendCommand(robotId, 'initialize', { zone: 'ready' });
    return robot;
  }

  async assignTask(task) {
    const availableRobots = Array.from(this.robots.values())
      .filter(robot => 
        robot.status === 'idle' && 
        robot.batteryLevel > 20 &&
        robot.capabilities.includes(task.type)
      );

    if (availableRobots.length === 0) {
      this.tasks.push(task);
      return null;
    }

    // Select optimal robot based on location and capabilities
    const optimalRobot = this.selectOptimalRobot(availableRobots, task);
    
    optimalRobot.status = 'assigned';
    optimalRobot.currentTask = task;
    
    await this.executeTask(optimalRobot, task);
    return optimalRobot;
  }

  selectOptimalRobot(robots, task) {
    // Simple distance-based selection (in practice, use more sophisticated algorithms)
    return robots.reduce((best, current) => {
      const currentDistance = this.calculateDistance(current.location, task.location);
      const bestDistance = this.calculateDistance(best.location, task.location);
      return currentDistance < bestDistance ? current : best;
    });
  }

  async executeTask(robot, task) {
    try {
      robot.status = 'executing';
      
      switch (task.type) {
        case 'pick':
          await this.executePicking(robot, task);
          break;
        case 'pack':
          await this.executePacking(robot, task);
          break;
        case 'transport':
          await this.executeTransport(robot, task);
          break;
        case 'inventory':
          await this.executeInventoryCount(robot, task);
          break;
      }
      
      robot.status = 'idle';
      robot.currentTask = null;
      
      // Process queued tasks
      if (this.tasks.length > 0) {
        const nextTask = this.tasks.shift();
        await this.assignTask(nextTask);
      }
      
    } catch (error) {
      robot.status = 'error';
      await this.handleRobotError(robot, error);
    }
  }

  async executePicking(robot, task) {
    const { items, location } = task;
    
    // Navigate to picking location
    await this.sendCommand(robot.id, 'navigate', { destination: location });
    robot.location = location;
    
    // Pick each item
    for (const item of items) {
      const inventoryData = this.inventory.get(item.sku);
      
      if (!inventoryData || inventoryData.quantity < item.quantity) {
        throw new Error(`Insufficient inventory for ${item.sku}`);
      }
      
      await this.sendCommand(robot.id, 'pick', {
        sku: item.sku,
        quantity: item.quantity,
        location: item.location
      });
      
      // Update inventory
      inventoryData.quantity -= item.quantity;
      this.inventory.set(item.sku, inventoryData);
    }
    
    return { status: 'completed', itemsPicked: items.length };
  }

  async executeTransport(robot, task) {
    const { from, to, items } = task;
    
    // Navigate to pickup location
    await this.sendCommand(robot.id, 'navigate', { destination: from });
    robot.location = from;
    
    // Load items
    await this.sendCommand(robot.id, 'load', { items });
    
    // Navigate to destination
    await this.sendCommand(robot.id, 'navigate', { destination: to });
    robot.location = to;
    
    // Unload items
    await this.sendCommand(robot.id, 'unload', { items });
    
    return { status: 'completed', itemsTransported: items.length };
  }

  async sendCommand(robotId, command, parameters) {
    // Simulate robot communication
    return new Promise((resolve) => {
      setTimeout(() => {
        console.log(`Robot ${robotId}: ${command}`, parameters);
        resolve({ success: true });
      }, Math.random() * 1000); // Simulate variable execution time
    });
  }

  calculateDistance(location1, location2) {
    const dx = location1.x - location2.x;
    const dy = location1.y - location2.y;
    return Math.sqrt(dx * dx + dy * dy);
  }

  async handleRobotError(robot, error) {
    console.error(`Robot ${robot.id} error:`, error.message);
    
    // Send robot for maintenance if necessary
    if (error.message.includes('mechanical')) {
      robot.status = 'maintenance';
      await this.sendCommand(robot.id, 'navigate', { destination: 'maintenance' });
    } else {
      robot.status = 'idle'; // Reset for software errors
    }
  }

  getWarehouseStatus() {
    const status = {
      totalRobots: this.robots.size,
      activeRobots: Array.from(this.robots.values()).filter(r => r.status === 'executing').length,
      idleRobots: Array.from(this.robots.values()).filter(r => r.status === 'idle').length,
      queuedTasks: this.tasks.length,
      averageBatteryLevel: this.getAverageBatteryLevel()
    };
    
    return status;
  }

  getAverageBatteryLevel() {
    const robots = Array.from(this.robots.values());
    const totalBattery = robots.reduce((sum, robot) => sum + robot.batteryLevel, 0);
    return robots.length > 0 ? (totalBattery / robots.length).toFixed(1) : 0;
  }
}