# Professional IoT deployment script template
#!/bin/bash
# IoT System Deployment Script
# Purpose: Automated setup of IoT gateway with all required services
# Author: IoT Engineering Team
# Version: 2.1.0

set -euo pipefail  # Exit on error, undefined variables, pipe failures

# Configuration variables
readonly SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
readonly LOG_FILE="/var/log/iot-deployment.log"
readonly CONFIG_FILE="${SCRIPT_DIR}/iot-config.conf"
readonly BACKUP_DIR="/opt/iot/backups/$(date +%Y%m%d_%H%M%S)"

# Logging functions
log_info() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') [INFO] $*" | tee -a "$LOG_FILE"
}

log_error() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') [ERROR] $*" | tee -a "$LOG_FILE" >&2
}

log_warning() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') [WARN] $*" | tee -a "$LOG_FILE"
}

# Error handling
cleanup() {
    local exit_code=$?
    if [ $exit_code -ne 0 ]; then
        log_error "Script failed with exit code $exit_code"
        log_info "Check log file: $LOG_FILE"
    fi
    exit $exit_code
}

trap cleanup EXIT

# System requirements check
check_system_requirements() {
    log_info "Checking system requirements..."
    
    # Check if running as root
    if [[ $EUID -eq 0 ]]; then
        log_error "This script should not be run as root"
        exit 1
    fi
    
    # Check Ubuntu/Debian
    if ! command -v apt &> /dev/null; then
        log_error "This script requires a Debian/Ubuntu system"
        exit 1
    fi
    
    # Check available disk space (minimum 2GB)
    local available_space=$(df / | awk 'NR==2 {print $4}')
    if [ "$available_space" -lt 2097152 ]; then  # 2GB in KB
        log_error "Insufficient disk space. Need at least 2GB free"
        exit 1
    fi
    
    # Check internet connectivity
    if ! ping -c 1 google.com &> /dev/null; then
        log_error "No internet connectivity detected"
        exit 1
    fi
    
    log_info "System requirements check passed"
}

# Package installation with error handling
install_packages() {
    log_info "Installing IoT packages..."
    
    local packages=(
        "python3" "python3-pip" "python3-venv"
        "nodejs" "npm"
        "mosquitto" "mosquitto-clients"
        "influxdb" "influxdb-client"
        "docker.io" "docker-compose"
        "nginx"
        "git" "curl" "wget"
        "htop" "tree" "jq"
    )
    
    # Update package lists
    sudo apt update || {
        log_error "Failed to update package lists"
        exit 1
    }
    
    # Install packages one by one with error checking
    for package in "${packages[@]}"; do
        log_info "Installing $package..."
        if sudo apt install -y "$package"; then
            log_info "Successfully installed $package"
        else
            log_error "Failed to install $package"
            exit 1
        fi
    done
    
    log_info "All packages installed successfully"
}

# IoT service configuration
configure_iot_services() {
    log_info "Configuring IoT services..."
    
    # Create IoT user and directories
    sudo useradd -r -s /bin/false iot 2>/dev/null || log_warning "IoT user already exists"
    sudo mkdir -p /opt/iot/{bin,config,data,logs}
    sudo mkdir -p /var/lib/iot
    sudo mkdir -p /var/log/iot
    sudo chown -R iot:iot /opt/iot /var/lib/iot /var/log/iot
    
    # Configure MQTT broker
    sudo tee /etc/mosquitto/conf.d/iot.conf > /dev/null << 'EOF'
# IoT MQTT Configuration
listener 1883
allow_anonymous false
password_file /etc/mosquitto/passwd
log_dest file /var/log/mosquitto/mosquitto.log
log_type all
connection_messages true
log_timestamp true
EOF
    
    # Create MQTT user
    sudo mosquitto_passwd -c -b /etc/mosquitto/passwd iot_device "$(openssl rand -base64 32)"
    
    # Start and enable services
    sudo systemctl enable mosquitto
    sudo systemctl start mosquitto
    sudo systemctl enable influxdb
    sudo systemctl start influxdb
    
    log_info "IoT services configured successfully"
}

# Python virtual environment setup
setup_python_environment() {
    log_info "Setting up Python IoT environment..."
    
    local venv_dir="/opt/iot/python-env"
    sudo -u iot python3 -m venv "$venv_dir"
    
    # Install IoT Python packages
    sudo -u iot "$venv_dir/bin/pip" install --upgrade pip
    sudo -u iot "$venv_dir/bin/pip" install \
        paho-mqtt \
        influxdb-client \
        flask \
        requests \
        pyserial \
        schedule \
        psutil
    
    # Create activation script
    sudo tee /opt/iot/bin/activate-python > /dev/null << EOF
#!/bin/bash
source /opt/iot/python-env/bin/activate
export PYTHONPATH="/opt/iot/lib:\$PYTHONPATH"
EOF
    sudo chmod +x /opt/iot/bin/activate-python
    
    log_info "Python environment setup complete"
}

# System monitoring setup
setup_monitoring() {
    log_info "Setting up system monitoring..."
    
    # Create monitoring script
    sudo tee /opt/iot/bin/system-monitor.sh > /dev/null << 'EOF'
#!/bin/bash
# IoT System Monitor

LOGFILE="/var/log/iot/system-monitor.log"
ALERT_EMAIL="admin@example.com"

check_services() {
    local services=("mosquitto" "influxdb" "nginx")
    for service in "${services[@]}"; do
        if ! systemctl is-active --quiet "$service"; then
            echo "$(date): ALERT - $service is not running" >> "$LOGFILE"
            systemctl restart "$service"
        fi
    done
}

check_disk_space() {
    local usage=$(df / | awk 'NR==2 {print $5}' | sed 's/%//')
    if [ "$usage" -gt 85 ]; then
        echo "$(date): ALERT - Disk usage is ${usage}%" >> "$LOGFILE"
    fi
}

check_memory() {
    local mem_usage=$(free | grep Mem | awk '{printf "%.0f", $3/$2 * 100.0}')
    if [ "$mem_usage" -gt 90 ]; then
        echo "$(date): ALERT - Memory usage is ${mem_usage}%" >> "$LOGFILE"
    fi
}

# Run checks
check_services
check_disk_space  
check_memory

echo "$(date): System check completed" >> "$LOGFILE"
EOF

    sudo chmod +x /opt/iot/bin/system-monitor.sh
    
    # Add to crontab for iot user
    (sudo -u iot crontab -l 2>/dev/null; echo "*/5 * * * * /opt/iot/bin/system-monitor.sh") | sudo -u iot crontab -
    
    log_info "System monitoring setup complete"
}

# Main execution
main() {
    log_info "Starting IoT system deployment..."
    
    check_system_requirements
    install_packages
    configure_iot_services
    setup_python_environment
    setup_monitoring
    
    log_info "IoT system deployment completed successfully!"
    log_info "Services status:"
    systemctl status mosquitto --no-pager -l
    systemctl status influxdb --no-pager -l
    
    log_info "Next steps:"
    log_info "1. Configure your IoT applications in /opt/iot/"
    log_info "2. Review logs in /var/log/iot/"
    log_info "3. Monitor system with: sudo journalctl -f"
}

# Execute main function
main "$@"

# IoT Device Management Script with Advanced Features
#!/bin/bash
# Advanced IoT Device Management System

# Configuration management with validation
load_config() {
    local config_file="${1:-/etc/iot/device-config.conf}"
    
    if [[ ! -f "$config_file" ]]; then
        log_error "Configuration file not found: $config_file"
        return 1
    fi
    
    # Source configuration with validation
    source "$config_file"
    
    # Validate required variables
    local required_vars=("DEVICE_ID" "MQTT_BROKER" "DATA_INTERVAL")
    for var in "${required_vars[@]}"; do
        if [[ -z "${!var}" ]]; then
            log_error "Required configuration variable $var is not set"
            return 1
        fi
    done
    
    log_info "Configuration loaded successfully"
}

# Network connectivity check with retry logic
check_connectivity() {
    local host="${1:-8.8.8.8}"
    local max_attempts=5
    local attempt=1
    
    while [ $attempt -le $max_attempts ]; do
        if ping -c 1 -W 2 "$host" &>/dev/null; then
            log_info "Network connectivity confirmed"
            return 0
        fi
        
        log_warning "Network check attempt $attempt/$max_attempts failed"
        sleep $((attempt * 2))  # Exponential backoff
        ((attempt++))
    done
    
    log_error "Network connectivity check failed after $max_attempts attempts"
    return 1
}

# MQTT message publishing with error handling
publish_sensor_data() {
    local topic="$1"
    local payload="$2"
    local qos="${3:-1}"
    
    # Validate inputs
    if [[ -z "$topic" || -z "$payload" ]]; then
        log_error "Topic and payload are required for MQTT publish"
        return 1
    fi
    
    # Publish with timeout and retry
    local max_retries=3
    local retry=0
    
    while [ $retry -lt $max_retries ]; do
        if timeout 10 mosquitto_pub \
            -h "$MQTT_BROKER" \
            -p "${MQTT_PORT:-1883}" \
            -u "$MQTT_USER" \
            -P "$MQTT_PASS" \
            -t "$topic" \
            -m "$payload" \
            -q "$qos"; then
            log_info "Successfully published to topic: $topic"
            return 0
        fi
        
        ((retry++))
        log_warning "MQTT publish attempt $retry/$max_retries failed"
        sleep 2
    done
    
    log_error "Failed to publish MQTT message after $max_retries attempts"
    return 1
}

# Sensor data collection with validation
collect_sensor_data() {
    local sensor_type="$1"
    local data_file="/tmp/sensor_${sensor_type}_$(date +%s).json"
    
    case "$sensor_type" in
        "temperature")
            # Simulate temperature sensor reading
            local temp=$(awk "BEGIN {printf \"%.2f\", 20 + rand() * 15}")
            local humidity=$(awk "BEGIN {printf \"%.2f\", 40 + rand() * 20}")
            
            cat > "$data_file" << EOF
{
    "device_id": "$DEVICE_ID",
    "sensor_type": "temperature_humidity",
    "timestamp": "$(date -Iseconds)",
    "data": {
        "temperature": $temp,
        "humidity": $humidity,
        "unit_temp": "celsius",
        "unit_humidity": "percent"
    }
}
EOF
            ;;
        "motion")
            # Simulate motion sensor
            local motion=$((RANDOM % 2))
            cat > "$data_file" << EOF
{
    "device_id": "$DEVICE_ID",
    "sensor_type": "motion",
    "timestamp": "$(date -Iseconds)",
    "data": {
        "motion_detected": $motion,
        "confidence": 0.95
    }
}
EOF
            ;;
        *)
            log_error "Unknown sensor type: $sensor_type"
            return 1
            ;;
    esac
    
    # Validate JSON
    if ! jq empty "$data_file" 2>/dev/null; then
        log_error "Invalid JSON generated for sensor data"
        rm -f "$data_file"
        return 1
    fi
    
    echo "$data_file"
}

# Data processing pipeline
process_sensor_data() {
    local data_file="$1"
    
    if [[ ! -f "$data_file" ]]; then
        log_error "Data file not found: $data_file"
        return 1
    fi
    
    # Extract key information
    local device_id=$(jq -r '.device_id' "$data_file")
    local sensor_type=$(jq -r '.sensor_type' "$data_file")
    local timestamp=$(jq -r '.timestamp' "$data_file")
    
    # Create MQTT topic
    local topic="iot/devices/$device_id/sensors/$sensor_type"
    
    # Publish data
    if publish_sensor_data "$topic" "$(cat "$data_file")"; then
        # Archive successful data
        local archive_dir="/var/lib/iot/data/$(date +%Y/%m/%d)"
        sudo mkdir -p "$archive_dir"
        sudo mv "$data_file" "$archive_dir/"
        log_info "Data processed and archived successfully"
    else
        # Move failed data to error directory
        local error_dir="/var/lib/iot/errors"
        sudo mkdir -p "$error_dir"
        sudo mv "$data_file" "$error_dir/"
        log_error "Data processing failed, moved to error directory"
        return 1
    fi
}

# System health monitoring
monitor_system_health() {
    local health_data="/tmp/system_health_$(date +%s).json"
    
    # Collect system metrics
    local cpu_usage=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
    local mem_usage=$(free | grep Mem | awk '{printf "%.1f", $3/$2 * 100.0}')
    local disk_usage=$(df / | tail -1 | awk '{print $5}' | cut -d'%' -f1)
    local load_avg=$(cat /proc/loadavg | cut -d' ' -f1)
    local uptime_seconds=$(cat /proc/uptime | cut -d' ' -f1)
    
    # Get temperature if available
    local temp="null"
    if [[ -f /sys/class/thermal/thermal_zone0/temp ]]; then
        temp=$(($(cat /sys/class/thermal/thermal_zone0/temp) / 1000))
    fi
    
    # Create health report
    cat > "$health_data" << EOF
{
    "device_id": "$DEVICE_ID",
    "report_type": "system_health",
    "timestamp": "$(date -Iseconds)",
    "metrics": {
        "cpu_usage_percent": $cpu_usage,
        "memory_usage_percent": $mem_usage,
        "disk_usage_percent": $disk_usage,
        "load_average": $load_avg,
        "uptime_seconds": $uptime_seconds,
        "temperature_celsius": $temp
    }
}
EOF
    
    # Publish health data
    local topic="iot/devices/$DEVICE_ID/health"
    publish_sensor_data "$topic" "$(cat "$health_data")"
    
    # Check for alerts
    if (( $(echo "$cpu_usage > 80" | bc -l) )); then
        log_warning "High CPU usage detected: ${cpu_usage}%"
    fi
    
    if (( $(echo "$mem_usage > 85" | bc -l) )); then
        log_warning "High memory usage detected: ${mem_usage}%"
    fi
    
    if [ "$disk_usage" -gt 90 ]; then
        log_warning "High disk usage detected: ${disk_usage}%"
    fi
    
    rm -f "$health_data"
}

# Main IoT device loop
main_device_loop() {
    log_info "Starting IoT device main loop..."
    
    # Load configuration
    load_config || exit 1
    
    # Check initial connectivity
    check_connectivity || {
        log_error "Initial connectivity check failed"
        exit 1
    }
    
    local iteration=0
    while true; do
        ((iteration++))
        log_info "Starting iteration $iteration"
        
        # Collect and process sensor data
        for sensor in temperature motion; do
            local data_file
            if data_file=$(collect_sensor_data "$sensor"); then
                process_sensor_data "$data_file"
            fi
        done
        
        # System health monitoring every 10 iterations
        if (( iteration % 10 == 0 )); then
            monitor_system_health
        fi
        
        # Sleep for configured interval
        sleep "$DATA_INTERVAL"
    done
}

# Signal handling for graceful shutdown
graceful_shutdown() {
    log_info "Received shutdown signal, cleaning up..."
    # Add cleanup code here
    exit 0
}

trap graceful_shutdown SIGTERM SIGINT

# Execute main function if script is run directly
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
    main_device_loop "$@"
fi