The Impact of IoT on Industries in 2025: Transforming Business Operations Through Connected Intelligence and Smart Automation

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
from typing import Dict, List, Optional, Any
from dataclasses import dataclass, field
import json
import uuid
from enum import Enum
import random
import time

class AlertLevel(Enum):
    NORMAL = "normal"
    WARNING = "warning"
    CRITICAL = "critical"
    EMERGENCY = "emergency"

class DeviceType(Enum):
    SENSOR = "sensor"
    ACTUATOR = "actuator"
    GATEWAY = "gateway"
    CONTROLLER = "controller"

@dataclass
class IoTDevice:
    """IoT device with monitoring capabilities"""
    device_id: str
    device_type: DeviceType
    location: str
    manufacturer: str
    model: str
    firmware_version: str
    installation_date: datetime
    last_maintenance: Optional[datetime] = None
    status: str = "active"
    battery_level: float = 100.0
    signal_strength: float = -70.0  # dBm
    
@dataclass
class SensorReading:
    """Individual sensor reading with metadata"""
    reading_id: str
    device_id: str
    timestamp: datetime
    sensor_type: str
    value: float
    unit: str
    quality_score: float = 1.0
    anomaly_detected: bool = False
    
@dataclass
class MaintenanceEvent:
    """Predictive maintenance event"""
    event_id: str
    device_id: str
    predicted_failure_date: datetime
    confidence_score: float
    failure_type: str
    recommended_actions: List[str] = field(default_factory=list)
    priority_level: AlertLevel = AlertLevel.NORMAL
    estimated_cost: float = 0.0
    
@dataclass
class ProductionLine:
    """Production line with IoT integration"""
    line_id: str
    name: str
    devices: List[str] = field(default_factory=list)
    target_oee: float = 85.0
    current_oee: float = 0.0
    production_count: int = 0
    quality_rate: float = 98.0
    availability: float = 95.0
    performance_rate: float = 90.0
    
class IndustrialIoTSystem:
    """Comprehensive Industrial IoT monitoring and analytics system"""
    
    def __init__(self, facility_name: str):
        self.facility_name = facility_name
        self.devices: Dict[str, IoTDevice] = {}
        self.sensor_readings: List[SensorReading] = []
        self.maintenance_events: List[MaintenanceEvent] = []
        self.production_lines: Dict[str, ProductionLine] = {}
        
        # Analytics and ML models (simplified)
        self.anomaly_detection_enabled = True
        self.predictive_maintenance_enabled = True
        self.optimization_models = {
            'energy_consumption': True,
            'production_scheduling': True,
            'quality_prediction': True
        }
        
        # Alert thresholds
        self.alert_thresholds = {
            'temperature': {'min': -10, 'max': 80, 'critical': 100},
            'vibration': {'normal': 5.0, 'warning': 15.0, 'critical': 25.0},
            'pressure': {'min': 0.5, 'max': 10.0, 'critical': 12.0},
            'humidity': {'min': 20, 'max': 80, 'critical': 95},
            'energy_consumption': {'baseline': 100, 'warning_factor': 1.2, 'critical_factor': 1.5}
        }
        
        # Communication protocols
        self.protocols = {
            'mqtt': {'enabled': True, 'broker': 'industrial.mqtt.broker'},
            'opcua': {'enabled': True, 'server': 'opcua.industrial.server'},
            'modbus': {'enabled': True, 'gateway': 'modbus.gateway'},
            'http': {'enabled': True, 'api_endpoint': 'https://api.industrial.iot'}
        }
        
        # Edge computing configuration
        self.edge_computing = {
            'enabled': True,
            'processing_nodes': 5,
            'ai_inference': True,
            'local_storage': '1TB',
            'latency_target': 10  # milliseconds
        }
        
    def register_device(self, device: IoTDevice) -> bool:
        """Register new IoT device in the system"""
        self.devices[device.device_id] = device
        print(f"Registered {device.device_type.value}: {device.device_id} at {device.location}")
        
        # Initialize device monitoring
        self._setup_device_monitoring(device)
        
        return True
        
    def register_production_line(self, production_line: ProductionLine) -> bool:
        """Register production line with associated IoT devices"""
        self.production_lines[production_line.line_id] = production_line
        print(f"Registered production line: {production_line.name} with {len(production_line.devices)} devices")
        return True
        
    def collect_sensor_data(self, device_id: str, sensor_type: str, value: float, unit: str) -> SensorReading:
        """Collect and process sensor reading"""
        if device_id not in self.devices:
            raise ValueError(f"Device {device_id} not registered")
            
        reading = SensorReading(
            reading_id=f"READ_{uuid.uuid4()}",
            device_id=device_id,
            timestamp=datetime.now(),
            sensor_type=sensor_type,
            value=value,
            unit=unit,
            quality_score=random.uniform(0.9, 1.0)  # Simulate data quality
        )
        
        # Perform real-time analytics
        if self.anomaly_detection_enabled:
            reading.anomaly_detected = self._detect_anomaly(reading)
            
        # Check alert conditions
        alert_level = self._check_alert_conditions(reading)
        
        if alert_level != AlertLevel.NORMAL:
            self._trigger_alert(reading, alert_level)
            
        # Store reading
        self.sensor_readings.append(reading)
        
        # Update device status
        self._update_device_status(device_id, reading)
        
        return reading
        
    def run_predictive_maintenance(self) -> List[MaintenanceEvent]:
        """Run predictive maintenance analysis across all devices"""
        if not self.predictive_maintenance_enabled:
            return []
            
        new_maintenance_events = []
        
        for device_id, device in self.devices.items():
            # Analyze device sensor history
            device_readings = [r for r in self.sensor_readings if r.device_id == device_id]
            
            if len(device_readings) >= 10:  # Minimum data required
                maintenance_prediction = self._predict_maintenance_needs(device, device_readings)
                
                if maintenance_prediction:
                    event = MaintenanceEvent(
                        event_id=f"MAINT_{uuid.uuid4()}",
                        device_id=device_id,
                        predicted_failure_date=maintenance_prediction['failure_date'],
                        confidence_score=maintenance_prediction['confidence'],
                        failure_type=maintenance_prediction['failure_type'],
                        recommended_actions=maintenance_prediction['actions'],
                        priority_level=maintenance_prediction['priority'],
                        estimated_cost=maintenance_prediction['cost']
                    )
                    
                    new_maintenance_events.append(event)
                    self.maintenance_events.append(event)
                    
        return new_maintenance_events
        
    def calculate_production_oee(self, line_id: str, time_period_hours: int = 8) -> Dict[str, float]:
        """Calculate Overall Equipment Effectiveness for production line"""
        if line_id not in self.production_lines:
            return {'error': 'Production line not found'}
            
        line = self.production_lines[line_id]
        
        # Get recent sensor data for line devices
        cutoff_time = datetime.now() - timedelta(hours=time_period_hours)
        line_readings = [
            r for r in self.sensor_readings 
            if r.device_id in line.devices and r.timestamp >= cutoff_time
        ]
        
        # Calculate OEE components
        availability = self._calculate_availability(line, line_readings)
        performance = self._calculate_performance(line, line_readings)
        quality = self._calculate_quality(line, line_readings)
        
        oee = (availability / 100) * (performance / 100) * (quality / 100) * 100
        
        # Update production line metrics
        line.availability = availability
        line.performance_rate = performance
        line.quality_rate = quality
        line.current_oee = oee
        
        oee_analysis = {
            'line_id': line_id,
            'time_period_hours': time_period_hours,
            'availability': availability,
            'performance': performance,
            'quality': quality,
            'oee': oee,
            'target_oee': line.target_oee,
            'variance': oee - line.target_oee,
            'improvement_opportunities': self._identify_oee_improvements(availability, performance, quality)
        }
        
        return oee_analysis
        
    def optimize_energy_consumption(self) -> Dict[str, Any]:
        """Analyze and optimize energy consumption across facility"""
        energy_readings = [
            r for r in self.sensor_readings 
            if r.sensor_type == 'energy_consumption'
        ]
        
        if not energy_readings:
            return {'error': 'No energy consumption data available'}
            
        # Analyze energy patterns
        hourly_consumption = self._analyze_hourly_energy_patterns(energy_readings)
        device_consumption = self._analyze_device_energy_usage(energy_readings)
        
        # Identify optimization opportunities
        optimization_opportunities = []
        
        for device_id, consumption in device_consumption.items():
            if consumption['average'] > consumption['baseline'] * 1.2:
                optimization_opportunities.append({
                    'device_id': device_id,
                    'type': 'high_consumption',
                    'current_usage': consumption['average'],
                    'baseline_usage': consumption['baseline'],
                    'potential_savings': (consumption['average'] - consumption['baseline']) * 0.15,
                    'recommendation': 'Schedule maintenance check and efficiency audit'
                })
                
        # Calculate total facility metrics
        total_consumption = sum(r.value for r in energy_readings[-24:])  # Last 24 hours
        baseline_consumption = sum(device_consumption[d]['baseline'] for d in device_consumption) * 24
        
        energy_analysis = {
            'total_consumption_24h': total_consumption,
            'baseline_consumption': baseline_consumption,
            'efficiency_ratio': baseline_consumption / total_consumption if total_consumption > 0 else 1.0,
            'optimization_opportunities': optimization_opportunities,
            'hourly_patterns': hourly_consumption,
            'device_rankings': sorted(device_consumption.items(), key=lambda x: x['average'], reverse=True)[:5],
            'estimated_annual_savings': sum(opp['potential_savings'] for opp in optimization_opportunities) * 365
        }
        
        return energy_analysis
        
    def generate_facility_dashboard(self) -> Dict[str, Any]:
        """Generate comprehensive facility dashboard with IoT insights"""
        dashboard = {
            'facility_name': self.facility_name,
            'timestamp': datetime.now().isoformat(),
            'device_summary': {
                'total_devices': len(self.devices),
                'active_devices': len([d for d in self.devices.values() if d.status == 'active']),
                'device_types': self._get_device_type_distribution(),
                'devices_needing_maintenance': len([d for d in self.devices.values() if d.battery_level < 20])
            },
            'production_summary': {
                'total_lines': len(self.production_lines),
                'average_oee': np.mean([line.current_oee for line in self.production_lines.values()]),
                'lines_below_target': len([line for line in self.production_lines.values() if line.current_oee < line.target_oee]),
                'total_production_count': sum(line.production_count for line in self.production_lines.values())
            },
            'maintenance_summary': {
                'pending_events': len([e for e in self.maintenance_events if e.priority_level in [AlertLevel.WARNING, AlertLevel.CRITICAL]]),
                'critical_events': len([e for e in self.maintenance_events if e.priority_level == AlertLevel.CRITICAL]),
                'estimated_maintenance_cost': sum(e.estimated_cost for e in self.maintenance_events),
                'next_scheduled_maintenance': self._get_next_maintenance_date()
            },
            'data_quality': {
                'total_readings_24h': len([r for r in self.sensor_readings if r.timestamp >= datetime.now() - timedelta(hours=24)]),
                'average_quality_score': np.mean([r.quality_score for r in self.sensor_readings[-1000:]]) if self.sensor_readings else 0,
                'anomalies_detected': len([r for r in self.sensor_readings if r.anomaly_detected]),
                'communication_health': self._assess_communication_health()
            },
            'alerts_and_notifications': {
                'active_alerts': self._get_active_alerts(),
                'alert_trend': self._analyze_alert_trends(),
                'resolution_rate': self._calculate_alert_resolution_rate()
            }
        }
        
        return dashboard
        
    def simulate_real_time_monitoring(self, duration_minutes: int = 60):
        """Simulate real-time IoT data collection and monitoring"""
        print(f"Starting {duration_minutes}-minute IoT monitoring simulation...")
        
        start_time = time.time()
        simulation_readings = 0
        
        while time.time() - start_time < duration_minutes * 60:
            # Simulate sensor readings from all devices
            for device_id, device in self.devices.items():
                if device.status == 'active':
                    # Generate realistic sensor data based on device type
                    sensor_data = self._generate_realistic_sensor_data(device)
                    
                    for sensor_type, (value, unit) in sensor_data.items():
                        reading = self.collect_sensor_data(device_id, sensor_type, value, unit)
                        simulation_readings += 1
                        
            # Run periodic maintenance analysis
            if simulation_readings % 100 == 0:
                maintenance_events = self.run_predictive_maintenance()
                if maintenance_events:
                    print(f"Generated {len(maintenance_events)} maintenance predictions")
                    
            # Calculate OEE for production lines
            if simulation_readings % 50 == 0:
                for line_id in self.production_lines:
                    oee_analysis = self.calculate_production_oee(line_id)
                    if oee_analysis.get('oee', 0) < 80:
                        print(f"Line {line_id} OEE below target: {oee_analysis['oee']:.1f}%")
                        
            time.sleep(1)  # 1-second intervals
            
        print(f"Simulation completed: {simulation_readings} readings collected")
        
        # Generate final dashboard
        dashboard = self.generate_facility_dashboard()
        return dashboard
        
    # Helper methods for IoT analytics and operations
    def _setup_device_monitoring(self, device: IoTDevice):
        """Initialize monitoring configuration for device"""
        monitoring_config = {
            'data_collection_interval': 30,  # seconds
            'anomaly_detection': True,
            'predictive_maintenance': True,
            'alert_notifications': True
        }
        return monitoring_config
        
    def _detect_anomaly(self, reading: SensorReading) -> bool:
        """Simple anomaly detection using statistical thresholds"""
        thresholds = self.alert_thresholds.get(reading.sensor_type, {})
        
        if 'min' in thresholds and reading.value < thresholds['min']:
            return True
        if 'max' in thresholds and reading.value > thresholds['max']:
            return True
        if 'critical' in thresholds and reading.value > thresholds['critical']:
            return True
            
        # Statistical anomaly detection (simplified)
        recent_readings = [
            r.value for r in self.sensor_readings[-50:] 
            if r.device_id == reading.device_id and r.sensor_type == reading.sensor_type
        ]
        
        if len(recent_readings) >= 10:
            mean_val = np.mean(recent_readings)
            std_val = np.std(recent_readings)
            z_score = abs(reading.value - mean_val) / std_val if std_val > 0 else 0
            return z_score > 3  # 3-sigma rule
            
        return False
        
    def _check_alert_conditions(self, reading: SensorReading) -> AlertLevel:
        """Check if reading triggers any alert conditions"""
        thresholds = self.alert_thresholds.get(reading.sensor_type, {})
        
        if 'critical' in thresholds and reading.value >= thresholds['critical']:
            return AlertLevel.CRITICAL
        elif 'warning' in thresholds and reading.value >= thresholds.get('warning', thresholds.get('max', float('inf'))):
            return AlertLevel.WARNING
        elif reading.anomaly_detected:
            return AlertLevel.WARNING
        else:
            return AlertLevel.NORMAL
            
    def _trigger_alert(self, reading: SensorReading, alert_level: AlertLevel):
        """Trigger alert notification for critical conditions"""
        alert = {
            'timestamp': reading.timestamp.isoformat(),
            'device_id': reading.device_id,
            'sensor_type': reading.sensor_type,
            'value': reading.value,
            'alert_level': alert_level.value,
            'message': f"{alert_level.value.upper()}: {reading.sensor_type} reading {reading.value} {reading.unit}"
        }
        
        print(f"ALERT: {alert['message']} from device {reading.device_id}")
        
    def _predict_maintenance_needs(self, device: IoTDevice, readings: List[SensorReading]) -> Optional[Dict]:
        """Predict maintenance needs based on device sensor data"""
        # Simplified predictive maintenance model
        recent_readings = readings[-20:]  # Last 20 readings
        
        if len(recent_readings) < 10:
            return None
            
        # Check for degradation patterns
        vibration_readings = [r for r in recent_readings if r.sensor_type == 'vibration']
        temperature_readings = [r for r in recent_readings if r.sensor_type == 'temperature']
        
        failure_indicators = 0
        failure_type = 'general_maintenance'
        confidence = 0.5
        
        if vibration_readings:
            avg_vibration = np.mean([r.value for r in vibration_readings])
            if avg_vibration > 15.0:
                failure_indicators += 1
                failure_type = 'bearing_replacement'
                
        if temperature_readings:
            avg_temp = np.mean([r.value for r in temperature_readings])
            if avg_temp > 70.0:
                failure_indicators += 1
                failure_type = 'cooling_system_maintenance'
                
        # Check device age and usage
        days_since_installation = (datetime.now() - device.installation_date).days
        if days_since_installation > 365:  # Over 1 year old
            failure_indicators += 0.5
            
        if device.last_maintenance:
            days_since_maintenance = (datetime.now() - device.last_maintenance).days
            if days_since_maintenance > 180:  # Over 6 months
                failure_indicators += 0.5
                
        confidence = min(failure_indicators / 3.0, 0.95)
        
        if confidence > 0.6:  # Threshold for maintenance recommendation
            days_to_failure = max(30 - int(failure_indicators * 10), 7)
            
            return {
                'failure_date': datetime.now() + timedelta(days=days_to_failure),
                'confidence': confidence,
                'failure_type': failure_type,
                'actions': self._get_maintenance_actions(failure_type),
                'priority': AlertLevel.WARNING if confidence > 0.8 else AlertLevel.NORMAL,
                'cost': self._estimate_maintenance_cost(failure_type)
            }
            
        return None
        
    def _calculate_availability(self, line: ProductionLine, readings: List[SensorReading]) -> float:
        """Calculate equipment availability percentage"""
        # Simplified availability calculation
        downtime_readings = [r for r in readings if r.sensor_type == 'machine_status' and r.value == 0]
        total_readings = [r for r in readings if r.sensor_type == 'machine_status']
        
        if not total_readings:
            return 95.0  # Default availability
            
        uptime_percentage = ((len(total_readings) - len(downtime_readings)) / len(total_readings)) * 100
        return max(uptime_percentage, 0)
        
    def _calculate_performance(self, line: ProductionLine, readings: List[SensorReading]) -> float:
        """Calculate performance rate based on production speed"""
        speed_readings = [r for r in readings if r.sensor_type == 'production_speed']
        
        if not speed_readings:
            return 85.0  # Default performance
            
        avg_speed = np.mean([r.value for r in speed_readings])
        target_speed = 100.0  # Units per hour (example)
        
        performance = (avg_speed / target_speed) * 100
        return min(performance, 100)
        
    def _calculate_quality(self, line: ProductionLine, readings: List[SensorReading]) -> float:
        """Calculate quality rate based on defect detection"""
        quality_readings = [r for r in readings if r.sensor_type == 'quality_check']
        
        if not quality_readings:
            return 98.0  # Default quality
            
        good_parts = len([r for r in quality_readings if r.value == 1])
        total_parts = len(quality_readings)
        
        quality_rate = (good_parts / total_parts) * 100 if total_parts > 0 else 100
        return quality_rate
        
    # Simplified helper methods
    def _identify_oee_improvements(self, availability: float, performance: float, quality: float) -> List[str]:
        improvements = []
        if availability < 90: improvements.append('Reduce unplanned downtime')
        if performance < 85: improvements.append('Optimize production speed')
        if quality < 95: improvements.append('Improve quality control processes')
        return improvements
        
    def _analyze_hourly_energy_patterns(self, readings: List[SensorReading]) -> Dict[int, float]:
        hourly_data = {}
        for r in readings[-168:]:  # Last week
            hour = r.timestamp.hour
            if hour not in hourly_data: hourly_data[hour] = []
            hourly_data[hour].append(r.value)
        return {hour: np.mean(values) for hour, values in hourly_data.items()}
        
    def _analyze_device_energy_usage(self, readings: List[SensorReading]) -> Dict[str, Dict[str, float]]:
        device_usage = {}
        for r in readings[-100:]:
            if r.device_id not in device_usage:
                device_usage[r.device_id] = {'values': [], 'baseline': 50.0}
            device_usage[r.device_id]['values'].append(r.value)
            
        for device_id, data in device_usage.items():
            data['average'] = np.mean(data['values'])
            
        return device_usage
        
    def _update_device_status(self, device_id: str, reading: SensorReading):
        device = self.devices[device_id]
        if reading.sensor_type == 'battery_level':
            device.battery_level = reading.value
        elif reading.sensor_type == 'signal_strength':
            device.signal_strength = reading.value
            
    def _generate_realistic_sensor_data(self, device: IoTDevice) -> Dict[str, tuple]:
        """Generate realistic sensor data based on device type and location"""
        base_temp = 25.0 + random.uniform(-5, 15)
        base_humidity = 50.0 + random.uniform(-20, 30)
        
        data = {
            'temperature': (base_temp + random.uniform(-2, 2), '°C'),
            'humidity': (max(0, min(100, base_humidity + random.uniform(-5, 5))), '%'),
            'vibration': (random.uniform(1, 8), 'mm/s'),
            'energy_consumption': (random.uniform(40, 120), 'kWh'),
            'machine_status': (random.choice([0, 1, 1, 1, 1]), 'binary'),  # 80% uptime
            'production_speed': (random.uniform(80, 110), 'units/hr'),
            'quality_check': (random.choice([0, 1, 1, 1, 1, 1, 1, 1, 1, 1]), 'binary'),  # 90% quality
        }
        
        return data
        
    # Additional simplified helper methods
    def _get_device_type_distribution(self): return {dt.value: random.randint(5, 20) for dt in DeviceType}
    def _get_next_maintenance_date(self): return (datetime.now() + timedelta(days=14)).isoformat()
    def _assess_communication_health(self): return random.uniform(0.85, 0.98)
    def _get_active_alerts(self): return random.randint(0, 5)
    def _analyze_alert_trends(self): return {'trend': 'stable', 'change_rate': random.uniform(-0.1, 0.1)}
    def _calculate_alert_resolution_rate(self): return random.uniform(0.8, 0.95)
    def _get_maintenance_actions(self, failure_type): return [f'Inspect {failure_type}', f'Replace components for {failure_type}']
    def _estimate_maintenance_cost(self, failure_type): return random.uniform(500, 5000)

# Example usage and demonstration
def run_industrial_iot_demo():
    print("=== Industrial IoT System Demo ===")
    
    # Initialize IoT system
    iot_system = IndustrialIoTSystem("Smart Manufacturing Facility")
    
    # Register IoT devices
    devices = [
        IoTDevice(
            device_id="TEMP_001",
            device_type=DeviceType.SENSOR,
            location="Production Line A",
            manufacturer="SensorTech",
            model="ST-TEMP-2025",
            firmware_version="2.1.3",
            installation_date=datetime(2024, 6, 15)
        ),
        IoTDevice(
            device_id="VIB_001",
            device_type=DeviceType.SENSOR,
            location="Motor Assembly",
            manufacturer="VibSense",
            model="VS-VIB-Pro",
            firmware_version="1.8.2",
            installation_date=datetime(2024, 3, 22)
        ),
        IoTDevice(
            device_id="ENERGY_001",
            device_type=DeviceType.SENSOR,
            location="Main Distribution Panel",
            manufacturer="PowerMon",
            model="PM-EN-4000",
            firmware_version="3.2.1",
            installation_date=datetime(2023, 11, 8)
        )
    ]
    
    for device in devices:
        iot_system.register_device(device)
        
    # Register production lines
    production_lines = [
        ProductionLine(
            line_id="LINE_A",
            name="Assembly Line A",
            devices=["TEMP_001", "VIB_001", "ENERGY_001"],
            target_oee=85.0
        ),
        ProductionLine(
            line_id="LINE_B",
            name="Packaging Line B",
            devices=["TEMP_001", "ENERGY_001"],
            target_oee=90.0
        )
    ]
    
    for line in production_lines:
        iot_system.register_production_line(line)
        
    print(f"\nRegistered {len(devices)} IoT devices and {len(production_lines)} production lines")
    
    # Simulate data collection
    print("\n=== Simulating Sensor Data Collection ===")
    
    # Collect sample sensor readings
    sample_readings = [
        ("TEMP_001", "temperature", 45.2, "°C"),
        ("TEMP_001", "humidity", 65.5, "%"),
        ("VIB_001", "vibration", 12.8, "mm/s"),
        ("ENERGY_001", "energy_consumption", 156.7, "kWh"),
        ("TEMP_001", "temperature", 78.9, "°C"),  # High temperature - should trigger alert
        ("VIB_001", "vibration", 23.5, "mm/s")   # High vibration - should trigger alert
    ]
    
    for device_id, sensor_type, value, unit in sample_readings:
        reading = iot_system.collect_sensor_data(device_id, sensor_type, value, unit)
        status = "ANOMALY" if reading.anomaly_detected else "NORMAL"
        print(f"{device_id}: {sensor_type} = {value} {unit} [{status}]")
        
    # Run predictive maintenance
    print("\n=== Predictive Maintenance Analysis ===")
    maintenance_events = iot_system.run_predictive_maintenance()
    
    if maintenance_events:
        for event in maintenance_events:
            print(f"Maintenance Alert: {event.device_id}")
            print(f"  Predicted failure: {event.failure_type}")
            print(f"  Confidence: {event.confidence_score:.1%}")
            print(f"  Estimated date: {event.predicted_failure_date.strftime('%Y-%m-%d')}")
            print(f"  Priority: {event.priority_level.value}")
            print(f"  Estimated cost: ${event.estimated_cost:.0f}")
    else:
        print("No immediate maintenance needs detected")
        
    # Calculate OEE
    print("\n=== Production Line OEE Analysis ===")
    for line_id in iot_system.production_lines:
        oee_analysis = iot_system.calculate_production_oee(line_id)
        
        print(f"\n{iot_system.production_lines[line_id].name}:")
        print(f"  Availability: {oee_analysis['availability']:.1f}%")
        print(f"  Performance: {oee_analysis['performance']:.1f}%")
        print(f"  Quality: {oee_analysis['quality']:.1f}%")
        print(f"  Overall OEE: {oee_analysis['oee']:.1f}%")
        print(f"  Target OEE: {oee_analysis['target_oee']:.1f}%")
        print(f"  Variance: {oee_analysis['variance']:+.1f}%")
        
        if oee_analysis['improvement_opportunities']:
            print(f"  Improvements needed: {', '.join(oee_analysis['improvement_opportunities'])}")
            
    # Energy optimization
    print("\n=== Energy Consumption Analysis ===")
    energy_analysis = iot_system.optimize_energy_consumption()
    
    if 'error' not in energy_analysis:
        print(f"Total 24h consumption: {energy_analysis['total_consumption_24h']:.1f} kWh")
        print(f"Baseline consumption: {energy_analysis['baseline_consumption']:.1f} kWh")
        print(f"Efficiency ratio: {energy_analysis['efficiency_ratio']:.2f}")
        print(f"Optimization opportunities: {len(energy_analysis['optimization_opportunities'])}")
        print(f"Estimated annual savings: ${energy_analysis['estimated_annual_savings']:.0f}")
        
    # Generate facility dashboard
    print("\n=== Facility Dashboard Summary ===")
    dashboard = iot_system.generate_facility_dashboard()
    
    print(f"Facility: {dashboard['facility_name']}")
    print(f"Active devices: {dashboard['device_summary']['active_devices']}/{dashboard['device_summary']['total_devices']}")
    print(f"Average OEE: {dashboard['production_summary']['average_oee']:.1f}%")
    print(f"Pending maintenance events: {dashboard['maintenance_summary']['pending_events']}")
    print(f"24h data points: {dashboard['data_quality']['total_readings_24h']}")
    print(f"Data quality score: {dashboard['data_quality']['average_quality_score']:.2f}")
    print(f"Active alerts: {dashboard['alerts_and_notifications']['active_alerts']}")
    
    return iot_system

# Run demonstration
if __name__ == "__main__":
    demo_iot_system = run_industrial_iot_demo()