#!/bin/bash
# E-FIRE-1 Master Orchestrator
# Ultimate autonomous income generation system

set -e

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color

# Logging function
log() {
    echo -e "${GREEN}[$(date '+%Y-%m-%d %H:%M:%S')]${NC} $1"
}

error() {
    echo -e "${RED}[ERROR]${NC} $1" >&2
}

warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

info() {
    echo -e "${CYAN}[INFO]${NC} $1"
}

# System banner
banner() {
    echo -e "${PURPLE}"
    cat << "EOF"
    ███████╗ ███████╗███████╗██╗██████╗ ███████╗
    ██╔════╝ ██╔════╝██╔════╝██║██╔══██╗██╔════╝
    █████╗   █████╗  █████╗  ██║██████╔╝█████╗
    ██╔══╝   ██╔══╝  ██╔══╝  ██║██╔══██╗██╔══╝
    ███████╗ ██║     ██║     ██║██║  ██║███████╗
    ╚══════╝ ╚═╝     ╚═╝     ╚═╝╚═╝  ╚═╝╚══════╝
    
    ███████╗██╗███████╗████████╗███████╗██╗    ██╗ █████╗ ████████╗ ██████╗██╗  ██╗
    ██╔════╝██║██╔════╝╚══██╔══╝██╔════╝██║    ██║██╔══██╗╚══██╔══╝██╔════╝██║  ██║
    █████╗  ██║███████╗   ██║   █████╗  ██║ █╗ ██║███████║   ██║   ██║     ███████║
    ██╔══╝  ██║╚════██║   ██║   ██╔══╝  ██║███╗██║██╔══██║   ██║   ██║     ██╔══██║
    ██║     ██║███████║   ██║   ███████╗╚███╔███╔╝██║  ██║   ██║   ╚██████╗██║  ██║
    ╚═╝     ╚═╝╚══════╝   ╚═╝   ╚══════╝ ╚══╝╚══╝ ╚═╝  ╚═╝   ╚═╝    ╚═════╝╚═╝  ╚═╝
    
    Autonomous Income Generation System
    Zero Human Intervention | 24/7 Operation | Self-Healing
    EOF
    echo -e "${NC}"
}

# Check prerequisites
check_prerequisites() {
    log "Checking prerequisites..."
    
    # Check Python version
    if ! command -v python3 &> /dev/null; then
        error "Python 3 not found. Please install Python 3.8+"
        exit 1
    fi
    
    # Check required Python packages
    local packages=("asyncio" "websockets" "sqlite3" "logging")
    for package in "${packages[@]}"; do
        if ! python3 -c "import $package" 2>/dev/null; then
            warning "Package $package not found, installing..."
            pip3 install $package || error "Failed to install $package"
        fi
    done
    
    # Check disk space
    local disk_space=$(df / | tail -1 | awk '{print $4}')
    if [ $disk_space -lt 1000000 ]; then  # Less than 1GB
        warning "Low disk space detected: ${disk_space}KB available"
    fi
    
    log "✅ Prerequisites check complete"
}

# Install dependencies
install_dependencies() {
    log "Installing dependencies..."
    
    # Create virtual environment if it doesn't exist
    if [ ! -d "venv" ]; then
        python3 -m venv venv
    fi
    
    # Activate virtual environment
    source venv/bin/activate
    
    # Install required packages
    pip3 install --upgrade pip
    pip3 install websockets aiohttp sqlite3 logging
    
    log "✅ Dependencies installed"
}

# Initialize system
initialize_system() {
    log "Initializing E-FIRE-1 system..."
    
    # Create system directories
    mkdir -p {logs,backups,data,strategies,agents,cache,reports,configs,secrets,tmp,engines}
    
    # Set permissions
    chmod +x *.py *.sh
    
    # Create systemd service for 24/7 operation
    create_systemd_service
    
    log "✅ System initialized"
}

# Create systemd service
create_systemd_service() {
    log "Creating systemd service for 24/7 operation..."
    
    cat > /etc/systemd/system/efire1.service << EOF
[Unit]
Description=E-FIRE-1 Autonomous Income System
After=network.target
Wants=network.target

[Service]
Type=simple
User=$USER
WorkingDirectory=$(pwd)
ExecStart=$(pwd)/venv/bin/python3 $(pwd)/deploy_autonomous.py
Restart=always
RestartSec=10
StandardOutput=append:$(pwd)/logs/system.log
StandardError=append:$(pwd)/logs/error.log
Environment=PYTHONPATH=$(pwd)

[Install]
WantedBy=multi-user.target
EOF
    
    sudo systemctl daemon-reload
    sudo systemctl enable efire1.service
    
    log "✅ Systemd service created"
}

# Start autonomous operation
start_autonomous() {
    log "🚀 Starting autonomous 24/7 operation..."
    
    # Start in background
    nohup python3 deploy_autonomous.py > logs/autonomous.log 2>&1 &
    echo $! > pid.txt
    
    log "✅ Autonomous system started (PID: $(cat pid.txt))"
}

# Monitor system
monitor_system() {
    log "📊 Monitoring system..."
    
    while true; do
        clear
        banner
        
        # Display system status
        echo -e "${CYAN}System Status:${NC}"
        echo "===================="
        
        # Check if processes are running
        if pgrep -f "deploy_autonomous.py" > /dev/null; then
            echo -e "${GREEN}✅ Autonomous System: RUNNING${NC}"
        else
            echo -e "${RED}❌ Autonomous System: STOPPED${NC}"
        fi
        
        # Display earnings
        if [ -f "earnings.log" ]; then
            local total_earnings=$(tail -1 earnings.log | grep -o '[0-9.]*' || echo "0.00")
            echo -e "${GREEN}💰 Total Earnings: \$${total_earnings}${NC}"
        fi
        
        # Display uptime
        if [ -f "pid.txt" ]; then
            local pid=$(cat pid.txt)
            if ps -p $pid > /dev/null; then
                local uptime=$(ps -o etime= -p $pid)
                echo -e "${CYAN}⏱️  Uptime: ${uptime}${NC}"
            fi
        fi
        
        # Display logs
        echo -e "${YELLOW}Recent Logs:${NC}"
        tail -5 logs/autonomous.log 2>/dev/null || echo "No logs yet"
        
        sleep 10
    done
}

# Stop system
stop_system() {
    log "🛑 Stopping E-FIRE-1 system..."
    
    if [ -f "pid.txt" ]; then
        local pid=$(cat pid.txt)
        if ps -p $pid > /dev/null; then
            kill $pid
            rm pid.txt
            log "✅ System stopped gracefully"
        else
            log "ℹ️  System already stopped"
        fi
    else
        pkill -f "deploy_autonomous.py"
        log "✅ System stopped forcefully"
    fi
}

# Backup system
backup_system() {
    log "💾 Creating system backup..."
    
    local backup_name="efire1_backup_$(date +%Y%m%d_%H%M%S)"
    mkdir -p backups/$backup_name
    
    # Backup critical files
    cp *.py backups/$backup_name/
    cp -r logs backups/$backup_name/
    cp -r data backups/$backup_name/
    cp -r configs backups/$backup_name/
    
    # Create backup manifest
    cat > backups/$backup_name/manifest.txt << EOF
E-FIRE-1 Backup
Created: $(date)
Files: $(ls *.py | wc -l) Python files
Logs: $(ls logs/ | wc -l) log files
EOF
    
    log "✅ Backup created: backups/$backup_name"
}

# Emergency recovery
emergency_recovery() {
    log "🚨 Emergency recovery mode activated"
    
    # Stop all processes
    pkill -f "python" || true
    
    # Restore from latest backup
    local latest_backup=$(ls -t backups/ | head -1)
    if [ -n "$latest_backup" ]; then
        cp -r backups/$latest_backup/* .
        log "✅ Recovered from backup: $latest_backup"
    else
        log "⚠️  No backup found, initializing fresh"
        initialize_system
    fi
    
    # Restart system
    start_autonomous
}

# Health check
health_check() {
    log "🏥 Performing health check..."
    
    # Check system resources
    local cpu_usage=$(top -bn1 | grep "Cpu(s)" | awk "{print \$2}" | awk -F'%' '{print $1}')
    local memory_usage=$(free | grep Mem | awk '{printf "%.1f", $3/$2 * 100.0}')
    local disk_usage=$(df / | tail -1 | awk '{print $5}' | sed 's/%//')
    
    echo -e "${CYAN}Health Report:${NC}"
    echo "==============="
    echo "CPU Usage: ${cpu_usage}%"
    echo "Memory Usage: ${memory_usage}%"
    echo "Disk Usage: ${disk_usage}%"
    
    if [ $(echo "$cpu_usage < 80" | bc -l) -eq 1 ] && 
       [ $(echo "$memory_usage < 80" | bc -l) -eq 1 ] && 
       [ $(echo "$disk_usage < 80" | bc -l) -eq 1 ]; then
        echo -e "${GREEN}✅ System healthy${NC}"
    else
        echo -e "${RED}⚠️  System under stress${NC}"
    fi
}

# Usage information
usage() {
    echo "Usage: $0 [COMMAND]"
    echo ""
    echo "Commands:"
    echo "  deploy     - Deploy complete system"
    echo "  start      - Start autonomous operation"
    echo "  stop       - Stop system"
    echo "  monitor    - Monitor system status"
    echo "  backup     - Create system backup"
    echo "  recovery   - Emergency recovery"
    echo "  health     - Health check"
    echo "  logs       - View system logs"
    echo "  restart    - Restart system"
    echo ""
    echo "Examples:"
    echo "  $0 deploy   # Deploy and start system"
    echo "  $0 monitor  # Monitor system in real-time"
    echo "  $0 backup   # Create backup"
}

# Main execution
main() {
    banner
    
    case "${1:-deploy}" in
        "deploy")
            check_prerequisites
            install_dependencies
            initialize_system
            start_autonomous
            monitor_system
            ;;
        "start")
            start_autonomous
            ;;
        "stop")
            stop_system
            ;;
        "monitor")
            monitor_system
            ;;
        "backup")
            backup_system
            ;;
        "recovery")
            emergency_recovery
            ;;
        "health")
            health_check
            ;;
        "logs")
            tail -f logs/autonomous.log
            ;;
        "restart")
            stop_system
            sleep 2
            start_autonomous
            ;;
        *)
            usage
            ;;
    esac
}

# Execute main function
main "$@"