# AI Predictive Scaling Pseudocode
class AIPredictiveScaler:
    def __init__(self, prediction_model, cost_optimizer):
        self.predictor = prediction_model
        self.optimizer = cost_optimizer
    
    def daily_optimize(self):
        # 1. Predict next 24h traffic
        forecast = self.predictor.forecast(hours=24)
        
        # 2. Analyze current resource utilization
        current_metrics = self.collect_metrics()
        
        # 3. Calculate optimal resource config
        optimal_config = self.optimizer.find_best_config(
            forecast=forecast,
            current=current_metrics,
            budget_constraint=monthly_budget,
            sla_requirements=response_time_p99 < 200ms
        )
        
        # 4. Evaluate change risk
        risk_score = self.assess_change_risk(optimal_config)
        
        if risk_score < RISK_THRESHOLD:
            # 5. Safely apply config changes
            self.apply_scaling(optimal_config)
            log(f"Config optimized: {optimal_config}")
        else:
            alert(f"Manual approval required: {optimal_config}")

# Install Node Exporter for system metrics
docker run -d \
  --name node-exporter \
  --net=host \
  --pid=host \
  -v "/:/host:ro,rslave" \
  prom/node-exporter:latest \
  --path.rootfs=/host

# Install cAdvisor for container metrics
docker run -d \
  --name=cadvisor \
  --volume=/:/rootfs:ro \
  --volume=/var/run:/var/run:ro \
  --volume=/sys:/sys:ro \
  --volume=/var/lib/docker/:/var/lib/docker:ro \
  --publish=8080:8080 \
  gcr.io/cadvisor/cadvisor:latest

# Install Prometheus
cat > prometheus.yml << 'EOF'
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'node-exporter'
    static_configs:
      - targets: ['localhost:9100']
  
  - job_name: 'cadvisor'
    static_configs:
      - targets: ['localhost:8080']
EOF

docker run -d \
  --name=prometheus \
  -p 9090:9090 \
  -v $(pwd)/prometheus.yml:/etc/prometheus/prometheus.yml \
  prom/prometheus:latest

mkdir -p ~/ai-cost-optimizer && cd ~/ai-cost-optimizer

# Create virtual environment
python3 -m venv venv
source venv/bin/activate
pip install prophet pandas numpy flask requests

cat > predictor.py << 'PYEOF'
#!/usr/bin/env python3
"""
AI VPS Cost Optimizer - Traffic Prediction Service
Prophet-based traffic forecasting engine
"""

import json
import os
import logging
from datetime import datetime, timedelta
from typing import Dict, List

import numpy as np
import pandas as pd
from prophet import Prophet

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


class TrafficPredictor:
    """Traffic predictor using Prophet time-series forecasting"""
    
    def __init__(self, forecast_days: int = 30, confidence_level: float = 0.9):
        self.forecast_days = forecast_days
        self.confidence_level = confidence_level
        self.models = {}
    
    def train_model(self, metric_name: str, historical_data: List[Dict]) -> Prophet:
        """Train a prediction model for a single metric"""
        df = pd.DataFrame(historical_data)
        df['ds'] = pd.to_datetime(df['timestamp'])
        df['y'] = df['value']
        
        model = Prophet(
            interval_width=self.confidence_level,
            yearly_seasonality=True,
            weekly_seasonality=True,
            daily_seasonality=False,
            changepoint_prior_scale=0.05,
        )
        model.fit(df)
        self.models[metric_name] = model
        logger.info(f"Model trained: {metric_name}, data points: {len(df)}")
        return model
    
    def predict(self, metric_name: str, hours_ahead: int = 72) -> Dict:
        """Predict metric values for the next N hours"""
        if metric_name not in self.models:
            raise ValueError(f"Model '{metric_name}' not trained yet")
        
        model = self.models[metric_name]
        future = model.make_future_dataframe(periods=hours_ahead, freq='h')
        forecast = model.predict(future)
        
        prediction = forecast.tail(hours_ahead)
        
        return {
            'metric': metric_name,
            'forecast_hours': hours_ahead,
            'predictions': prediction[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].to_dict('records'),
            'summary': {
                'mean_demand': float(prediction['yhat'].mean()),
                'max_demand': float(prediction['yhat'].max()),
                'min_demand': float(prediction['yhat'].min()),
                'peak_hour': str(prediction.loc[prediction['yhat'].idxmax(), 'ds']),
            }
        }
    
    def get_resource_recommendation(self, cpu_forecast: Dict, 
                                     memory_forecast: Dict,
                                     bandwidth_forecast: Dict) -> Dict:
        """Generate resource configuration recommendations based on forecasts"""
        cpu_peak = cpu_forecast['summary']['max_demand']
        mem_peak = memory_forecast['summary']['max_demand']
        bw_peak = bandwidth_forecast['summary']['max_demand']
        
        recommended_cpu = int(np.ceil(cpu_peak * 1.3))
        recommended_memory_gb = int(np.ceil(mem_peak * 1.3 / 1024))
        recommended_bandwidth_mbps = int(np.ceil(bw_peak * 1.3 / (1024 * 1024)))
        
        recommended_cpu = max(recommended_cpu, 1)
        recommended_memory_gb = max(recommended_memory_gb, 1)
        recommended_bandwidth_mbps = max(recommended_bandwidth_mbps, 1)
        
        return {
            'recommended_config': {
                'cpu_cores': recommended_cpu,
                'memory_gb': recommended_memory_gb,
                'bandwidth_mbps': recommended_bandwidth_mbps,
            },
            'confidence': 'high',
            'safety_margin': '30%',
            'note': f'Based on peak: CPU={cpu_peak:.2f}%, MEM={mem_peak:.2f}MB, BW={bw_peak:.2f}bps'
        }


from flask import Flask, request, jsonify

app = Flask(__name__)
predictor = TrafficPredictor(forecast_days=30)


@app.route('/api/v1/train', methods=['POST'])
def train():
    data = request.json
    metric_name = data.get('metric')
    historical_data = data.get('data', [])
    if not metric_name or not historical_data:
        return jsonify({'error': 'Missing required parameters'}), 400
    model = predictor.train_model(metric_name, historical_data)
    return jsonify({
        'status': 'success',
        'metric': metric_name,
        'data_points': len(historical_data),
        'model_available': True
    })


@app.route('/api/v1/predict/<metric_name>', methods=['GET'])
def predict(metric_name):
    hours = int(request.args.get('hours', 72))
    try:
        result = predictor.predict(metric_name, hours)
        return jsonify(result)
    except ValueError as e:
        return jsonify({'error': str(e)}), 404


@app.route('/api/v1/recommend', methods=['GET'])
def recommend():
    try:
        cpu_pred = predictor.predict('cpu_usage', 24)
        mem_pred = predictor.predict('memory_mb', 24)
        bw_pred = predictor.predict('bandwidth_bps', 24)
        rec = predictor.get_resource_recommendation(cpu_pred, mem_pred, bw_pred)
        return jsonify(rec)
    except Exception as e:
        return jsonify({'error': str(e)}), 500


if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=False)
PYEOF

echo "✅ Predictor service created"

cat > optimizer.py << 'PYEOF'
#!/usr/bin/env python3
"""
AI VPS Cost Optimizer - Decision Engine
AI-predicted cost optimization decision engine
"""

import json
import math
from datetime import datetime
from typing import Dict, List
from dataclasses import dataclass, asdict


@dataclass
class InstanceConfig:
    name: str
    cpu_cores: int
    memory_gb: int
    storage_gb: int
    bandwidth_mbps: int
    monthly_cost: float
    provider: str
    region: str


@dataclass
class OptimizationResult:
    timestamp: str
    current_monthly_cost: float
    optimized_monthly_cost: float
    savings_amount: float
    savings_percentage: float
    recommended_actions: List[Dict]
    risk_level: str
    confidence: float


class CostOptimizer:
    """Cost optimization decision engine"""
    
    def __init__(self, monthly_budget: float = None):
        self.monthly_budget = monthly_budget
        self.instance_catalog = self._load_instance_catalog()
    
    def _load_instance_catalog(self) -> List[InstanceConfig]:
        """Load available instance catalog"""
        return [
            InstanceConfig("s1.small", 1, 1, 20, 1, 45.0, "aliyun", "cn-hangzhou"),
            InstanceConfig("s1.medium", 2, 2, 40, 3, 90.0, "aliyun", "cn-hangzhou"),
            InstanceConfig("s2.large", 2, 4, 80, 5, 168.0, "aliyun", "cn-hangzhou"),
            InstanceConfig("s3.xlarge", 4, 8, 160, 10, 320.0, "aliyun", "cn-hangzhou"),
            InstanceConfig("s3.2xlarge", 4, 16, 320, 20, 580.0, "aliyun", "cn-hangzhou"),
            InstanceConfig("s4.4xlarge", 8, 32, 500, 50, 1080.0, "aliyun", "cn-hangzhou"),
        ]
    
    def find_optimal_instances(self, traffic_forecast: Dict, 
                                sla_requirements: Dict) -> List[Dict]:
        """Find optimal instance configurations based on traffic forecast"""
        predictions = traffic_forecast.get('predictions', [])
        if not predictions:
            return []
        
        time_slots = self._group_into_slots(predictions)
        optimal_configs = []
        
        for slot in time_slots:
            avg_cpu = sum(p['yhat'] for p in slot) / len(slot)
            peak_cpu = max(p['yhat'] for p in slot)
            config = self._select_best_instance(avg_cpu, peak_cpu, sla_requirements)
            if config:
                optimal_configs.append({
                    'slot': slot[0]['ds'],
                    'avg_cpu': avg_cpu,
                    'peak_cpu': peak_cpu,
                    'config': asdict(config),
                    'cost_per_slot': config.monthly_cost / 6
                })
        
        return optimal_configs
    
    def _group_into_slots(self, predictions: List[Dict], 
                          slot_hours: int = 4) -> List[List[Dict]]:
        """Group predictions into time slots"""
        slots = []
        current_slot = []
        for pred in predictions:
            current_slot.append(pred)
            if len(current_slot) >= slot_hours:
                slots.append(current_slot)
                current_slot = []
        if current_slot:
            slots.append(current_slot)
        return slots
    
    def _select_best_instance(self, avg_cpu: float, peak_cpu: float,
                               sla: Dict) -> InstanceConfig:
        """Select the lowest-cost instance meeting requirements"""
        required_cpu_cores = max(1, math.ceil(avg_cpu / 70))
        candidates = []
        
        for instance in self.instance_catalog:
            if instance.cpu_cores >= required_cpu_cores:
                cost_per_core = instance.monthly_cost / instance.cpu_cores
                cost_per_mem = instance.monthly_cost / instance.memory_gb
                score = cost_per_core * 0.6 + cost_per_mem * 0.4
                candidates.append((score, instance))
        
        if candidates:
            candidates.sort(key=lambda x: x[0])
            return candidates[0][1]
        return None
    
    def generate_optimization_report(self, current_cost: float,
                                      forecast: Dict,
                                      sla: Dict) -> OptimizationResult:
        """Generate a complete optimization report"""
        optimal_configs = self.find_optimal_instances(forecast, sla)
        
        if not optimal_configs:
            return OptimizationResult(
                timestamp=datetime.now().isoformat(),
                current_monthly_cost=current_cost,
                optimized_monthly_cost=current_cost,
                savings_amount=0,
                savings_percentage=0,
                recommended_actions=[],
                risk_level='high',
                confidence=0.0
            )
        
        optimized_cost = sum(c['cost_per_slot'] for c in optimal_configs)
        actions = self._generate_actions(optimal_configs, current_cost, optimized_cost)
        savings_pct = ((current_cost - optimized_cost) / current_cost) * 100 if current_cost > 0 else 0
        
        return OptimizationResult(
            timestamp=datetime.now().isoformat(),
            current_monthly_cost=current_cost,
            optimized_monthly_cost=optimized_cost,
            savings_amount=max(0, current_cost - optimized_cost),
            savings_percentage=max(0, savings_pct),
            recommended_actions=actions,
            risk_level='medium' if len(actions) > 3 else 'low',
            confidence=0.85
        )
    
    def _generate_actions(self, configs: List[Dict], 
                           current_cost: float,
                           optimized_cost: float) -> List[Dict]:
        """Generate specific optimization action items"""
        actions = []
        for config in configs:
            actions.append({
                'type': 'scale_down' if config['config']['monthly_cost'] < current_cost / len(configs) else 'maintain',
                'time_window': str(config['slot']),
                'current_estimate': f"${current_cost / len(configs):.0f}/mo",
                'recommended': f"{config['config']['name']} (${config['config']['monthly_cost']:.0f}/mo)",
                'action': 'resize_instance' if config['config']['monthly_cost'] < current_cost / len(configs) else 'no_action'
            })
        
        total_savings = current_cost - optimized_cost
        if total_savings > 0:
            actions.insert(0, {
                'type': 'overall_savings',
                'description': f"By implementing time-slot-based elastic configuration, saving ~${total_savings:.0f}/mo ({(total_savings/current_cost)*100:.1f}%)",
                'priority': 'high',
                'estimated_roi': 'Immediate'
            })
        return actions


if __name__ == '__main__':
    optimizer = CostOptimizer(monthly_budget=1000)
    
    mock_forecast = {
        'predictions': [
            {'ds': '2026-07-24T00:00:00', 'yhat': 15.2, 'yhat_lower': 12.1, 'yhat_upper': 18.3},
            {'ds': '2026-07-24T01:00:00', 'yhat': 12.8, 'yhat_lower': 10.5, 'yhat_upper': 15.1},
            {'ds': '2026-07-24T08:00:00', 'yhat': 65.3, 'yhat_lower': 58.2, 'yhat_upper': 72.4},
            {'ds': '2026-07-24T14:00:00', 'yhat': 82.1, 'yhat_lower': 75.6, 'yhat_upper': 88.7},
            {'ds': '2026-07-24T20:00:00', 'yhat': 45.6, 'yhat_lower': 40.1, 'yhat_upper': 51.2},
        ]
    }
    
    report = optimizer.generate_optimization_report(
        current_cost=680.0,
        forecast=mock_forecast,
        sla={'safety_margin': 1.3, 'response_time_p99_ms': 200}
    )
    
    print(json.dumps(asdict(report), indent=2, ensure_ascii=False))
PYEOF

echo "✅ Optimizer engine created"

cat > scheduler.sh << 'BASHEOF'
#!/bin/bash
# AI VPS Cost Optimizer - Scheduled Task Script
# Runs daily at 2 AM for cost optimization analysis

set -euo pipefail

LOG_DIR="/var/log/ai-cost-optimizer"
REPORT_DIR="$HOME/ai-cost-optimizer/reports"
mkdir -p "$LOG_DIR" "$REPORT_DIR"

LOG_FILE="$LOG_DIR/optimizer-$(date +%Y%m%d).log"

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

log "🚀 Starting AI cost optimization task"

# 1. Collect latest monitoring data
log "📊 Step 1: Collecting monitoring data..."
METRICS=$(curl -s http://localhost:9090/api/v1/query?query=node_cpu_seconds_total 2>/dev/null || echo "fallback")

# 2. Run prediction
log "🔮 Step 2: Running traffic prediction..."
PREDICTION=$(python3 -c "
from predictor import TrafficPredictor
import json
predictor = TrafficPredictor()
result = predictor.predict('cpu_usage', 168)
print(json.dumps(result, default=str))
" 2>/dev/null || echo "{}")

# 3. Generate optimization report
log "💡 Step 3: Generating optimization report..."
REPORT=$(python3 -c "
from optimizer import CostOptimizer, asdict
import json
optimizer = CostOptimizer()
report = optimizer.generate_optimization_report(
    current_cost=680.0,
    forecast=json.loads('''$PREDICTION'''),
    sla={'safety_margin': 1.3}
)
print(json.dumps(asdict(report), default=str, indent=2))
" 2>/dev/null || echo "{}")

# 4. Save report
echo "$REPORT" > "$REPORT_DIR/report-$(date +%Y%m%d-%H%M%S).json"

# 5. Auto-execute if savings exceed threshold
SAVINGS_PCT=$(echo "$REPORT" | python3 -c "
import sys, json
data = json.load(sys.stdin)
print(data.get('savings_percentage', 0))
" 2>/dev/null || echo "0")

if (( $(echo "$SAVINGS_PCT > 20" | bc -l 2>/dev/null || echo 0) )); then
    log "💰 Significant savings detected ($SAVINGS_PCT%), triggering auto-optimization"
    curl -X POST webhook_url -d "{\"text\": \"AI cost optimization: saving ${SAVINGS_PCT}%\"}" 2>/dev/null || true
else
    log "✅ Costs within reasonable range, no adjustment needed"
fi

log "✅ AI cost optimization task completed"
BASHEOF

chmod +x scheduler.sh
echo "0 2 * * * $HOME/ai-cost-optimizer/scheduler.sh >> /var/log/ai-cost-optimizer/cron.log 2>&1" | crontab -
echo "✅ Scheduler configured, runs daily at 2 AM"

cat > dashboard.html << 'HTMLEOF'
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AI VPS Cost Optimization Dashboard</title>
    <style>
        :root {
            --bg-primary: #0f172a; --bg-secondary: #1e293b;
            --text-primary: #f1f5f9; --text-secondary: #94a3b8;
            --accent: #6366f1; --success: #10b981; --danger: #ef4444;
        }
        * { margin: 0; padding: 0; box-sizing: border-box; }
        body { font-family: -apple-system, BlinkMacSystemFont, sans-serif; background: var(--bg-primary); color: var(--text-primary); min-height: 100vh; }
        .container { max-width: 1200px; margin: 0 auto; padding: 20px; }
        header { display: flex; justify-content: space-between; align-items: center; padding: 20px 0; border-bottom: 1px solid #334155; }
        h1 { font-size: 24px; }
        .badge { background: var(--accent); color: white; padding: 4px 12px; border-radius: 20px; font-size: 12px; }
        .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); gap: 20px; margin: 24px 0; }
        .card { background: var(--bg-secondary); border-radius: 12px; padding: 24px; border: 1px solid #334155; }
        .card-title { color: var(--text-secondary); font-size: 14px; margin-bottom: 8px; }
        .card-value { font-size: 32px; font-weight: bold; }
        .positive { color: var(--success); }
        table { width: 100%; border-collapse: collapse; margin-top: 16px; }
        th, td { padding: 12px; text-align: left; border-bottom: 1px solid #334155; }
        th { color: var(--text-secondary); font-size: 12px; text-transform: uppercase; }
        tr:hover { background: rgba(99, 102, 241, 0.1); }
    </style>
</head>
<body>
    <div class="container">
        <header>
            <div><h1>🤖 AI VPS Cost Optimization Dashboard</h1>
            <p style="color: var(--text-secondary); margin-top: 4px;">Last updated: <span id="lastUpdate"></span></p></div>
            <span class="badge">AI Powered</span>
        </header>
        <div class="grid">
            <div class="card"><div class="card-title">Monthly Cost</div><div class="card-value">$680</div>
                <div class="positive">↓ Optimizable to $280</div></div>
            <div class="card"><div class="card-title">Estimated Monthly Savings</div><div class="card-value positive">$400</div>
                <div class="positive">Annual savings $4,800</div></div>
            <div class="card"><div class="card-title">Resource Utilization</div><div class="card-value">23%</div>
                <div style="color: var(--danger);">Target: ≥60%</div></div>
            <div class="card"><div class="card-title">AI Confidence</div><div class="card-value">92%</div>
                <div>Based on 30-day history</div></div>
        </div>
        <div class="card">
            <h3 style="margin-bottom: 16px;">📋 Optimization Recommendations</h3>
            <table>
                <thead><tr><th>Time Slot</th><th>Current Config</th><th>Recommended</th><th>Savings</th><th>Action</th></tr></thead>
                <tbody>
                    <tr><td>00:00 - 08:00</td><td>s3.2xlarge (4C16G)</td><td>s1.medium (2C2G)</td><td class="positive">-$490/mo</td>
                    <td><button style="background: var(--accent); color: white; border: none; padding: 6px 16px; border-radius: 6px; cursor: pointer;">Apply</button></td></tr>
                    <tr><td>08:00 - 20:00</td><td>s3.2xlarge (4C16G)</td><td>s3.xlarge (4C8G)</td><td class="positive">-$260/mo</td>
                    <td><button style="background: var(--accent); color: white; border: none; padding: 6px 16px; border-radius: 6px; cursor: pointer;">Apply</button></td></tr>
                    <tr><td>20:00 - 00:00</td><td>s3.2xlarge (4C16G)</td><td>s2.large (2C4G)</td><td class="positive">-$412/mo</td>
                    <td><button style="background: var(--accent); color: white; border: none; padding: 6px 16px; border-radius: 6px; cursor: pointer;">Apply</button></td></tr>
                </tbody>
            </table>
        </div>
    </div>
    <script>document.getElementById('lastUpdate').textContent = new Date().toLocaleString();</script>
</body>
</html>
HTMLEOF

echo "✅ Dashboard HTML created"

STORAGE_OPTIMIZATION = {
    "Snapshot Management": {
        "Strategy": "Auto-delete snapshots older than 30 days",
        "Tool": "cron + API calls",
        "Expected Savings": "15-30% of storage costs"
    },
    "Hot/Cold Tiering": {
        "Strategy": "Move data untouched for 3 months to cold storage",
        "Tool": "rsync + scheduled jobs",
        "Expected Savings": "50-70% archival storage costs"
    },
    "Deduplication & Compression": {
        "Strategy": "Deduplicate and compress backup data",
        "Tool": "restic/borg",
        "Expected Savings": "40-60% backup storage"
    },
    "CDN Acceleration": {
        "Strategy": "Static assets via CDN, reduce origin bandwidth",
        "Tool": "Cloudflare/Nginx+CDN",
        "Expected Savings": "30-50% bandwidth costs"
    }
}