import pandas as pd
from prophet import Prophet

def build_capacity_model(metrics_df, forecast_days=30):
    """Build capacity forecast model
    
    metrics_df: DataFrame with columns ['ds' (date), 'y' (metric value)]
    forecast_days: how many days ahead to forecast
    """
    # Preprocessing: handle missing values and outliers
    metrics_df = preprocess_time_series(metrics_df)
    
    # Initialize Prophet model
    model = Prophet(
        yearly_seasonality=True,   # Annual seasonality (weekday/weekend)
        weekly_seasonality=True,   # Weekly seasonality
        daily_seasonality=False,   # Daily seasonality (hourly data)
        changepoint_prior_scale=0.05,  # Trend change sensitivity
    )
    
    # Add external regressors (e.g., promotion event markers)
    if 'promo_event' in metrics_df.columns:
        model.add_regressor('promo_event')
    
    # Fit model
    model.fit(metrics_df)
    
    # Generate forecast
    future = model.make_future_dataframe(periods=forecast_days, freq='D')
    forecast = model.predict(future)
    
    return model, forecast

def generate_capacity_recommendation(
    current_metrics: dict,
    forecast: dict,
    budget_constraints: dict,
    slas: dict
) -> str:
    """Generate capacity planning recommendations and scaling plan"""
    
    prompt = f"""
You are a senior cloud operations architect doing capacity planning for a fast-growing SaaS company.

【Current Resource Status】
- CPU: {current_metrics['cpu']}% (trend: {current_metrics['cpu_trend']})
- Memory: {current_metrics['memory']}% (trend: {current_metrics['memory_trend']})
- Disk: {current_metrics['disk']}% (trend: {current_metrics['disk_trend']})
- Bandwidth: {current_metrics['bandwidth']}% (trend: {current_metrics['bandwidth_trend']})

【30-Day Forecast】
- CPU expected to reach: {forecast['cpu_30d']}%
- Memory expected to reach: {forecast['memory_30d']}%
- Disk expected to reach: {forecast['disk_30d']}%

【Constraints】
- Monthly budget cap: ${budget_constraints['monthly_budget']}
- Target SLA: {sla_level} availability
- Maximum acceptable downtime: {downtime_tolerance}

【Current Config】
- Current VPS: {current_specs}
- Current monthly cost: ${current_cost}

Please analyze and answer:
1. Which resource dimension will hit the bottleneck first? When?
2. Which scaling strategy do you recommend (vertical/horizontal/hybrid)?
3. What specific resource configuration do you suggest?
4. What will the estimated monthly cost be after scaling? Within budget?
5. What risks should be noted during scaling execution?

Please respond in English with clear, actionable recommendations.
"""
    
    response = call_llm(prompt)
    return response

def calculate_capacity_health(metrics: dict) -> dict:
    """Calculate capacity health score (0-100)
    100 = very ample, 0 = scale immediately
    """
    scores = {}
    
    # CPU health (considering iowait)
    cpu_score = max(0, 100 - metrics['cpu_usage'] * 1.2 - metrics['iowait'] * 0.5)
    scores['cpu'] = cpu_score
    
    # Memory health (considering swap usage)
    memory_score = max(0, 100 - metrics['memory_usage'] * 1.5 - metrics['swap_usage'] * 2.0)
    scores['memory'] = memory_score
    
    # Disk health
    disk_score = max(0, 100 - metrics['disk_usage'] * 1.0)
    scores['disk'] = disk_score
    
    # Bandwidth health
    bandwidth_score = max(0, 100 - metrics['bandwidth_usage'] * 1.3)
    scores['bandwidth'] = bandwidth_score
    
    # Overall health (weighted average, I/O heavy gets higher weight)
    weights = {
        'cpu': 0.25,
        'memory': 0.30,
        'disk': 0.25,
        'bandwidth': 0.20
    }
    overall = sum(scores[k] * weights[k] for k in weights)
    
    return {
        'overall': round(overall, 1),
        'breakdown': {k: round(v, 1) for k, v in scores.items()},
        'risk_level': classify_risk(overall),
        'bottleneck': identify_bottleneck(scores)
    }

def classify_risk(score: float) -> str:
    if score >= 70:
        return "Normal"
    elif score >= 50:
        return "Watch"
    elif score >= 30:
        return "Warning"
    else:
        return "Critical"

def calculate_time_to_exhaustion(
    current_usage: float,
    growth_rate_per_day: float,
    threshold: float = 85.0
) -> int:
    """Calculate days until threshold is reached"""
    if growth_rate_per_day <= 0:
        return 999  # Will not exhaust
    
    remaining_capacity = threshold - current_usage
    days_to_threshold = int(remaining_capacity / growth_rate_per_day)
    
    return max(0, days_to_threshold)

def generate_expansion_plan(
    server_id: str,
    health: dict,
    forecast: dict,
    cloud_providers: list,
    current_config: dict
) -> dict:
    """Generate scaling plan comparison"""
    
    scenarios = []
    
    # Plan 1: Vertical scaling (upgrade current VPS config)
    vertical_plan = {
        'type': 'vertical',
        'description': f"Upgrade current {current_config['specs']} to {current_config['specs']}_upgraded",
        'monthly_cost_increase': calculate_vertical_upgrade_cost(current_config, 'upgraded'),
        'downtime_required': False,
        'risk': 'Low (hot upgrade)',
        'estimated_capacity_headroom_days': 180
    }
    scenarios.append(vertical_plan)
    
    # Plan 2: Horizontal scaling (add replicas)
    horizontal_plan = {
        'type': 'horizontal',
        'description': "Add one same-config VPS with load balancing",
        'monthly_cost_increase': current_config['monthly_cost'],
        'downtime_required': False,
        'risk': 'Medium (needs routing config)',
        'estimated_capacity_headroom_days': 365
    }
    scenarios.append(horizontal_plan)
    
    # Plan 3: Hybrid scaling
    hybrid_plan = {
        'type': 'hybrid',
        'description': f"Upgrade current VPS to {current_config['specs']}_mid + add lightweight instance",
        'monthly_cost_increase': (
            calculate_vertical_upgrade_cost(current_config, 'mid') + 
            current_config['monthly_cost'] * 0.5
        ),
        'downtime_required': False,
        'risk': 'Medium',
        'estimated_capacity_headroom_days': 270
    }
    scenarios.append(hybrid_plan)
    
    return {
        'server_id': server_id,
        'current_health': health,
        'forecast': forecast,
        'scenarios': scenarios,
        'recommendation': select_best_scenario(scenarios, current_config['budget'])
    }

def analyze_cost_impact(
    current_cost: float,
    proposed_cost: float,
    projected_revenue_growth: float,
    service_type: str
) -> dict:
    """Analyze cost impact and ROI of scaling"""
    cost_increase = proposed_cost - current_cost
    cost_increase_pct = (cost_increase / current_cost) * 100
    
    # Calculate cost efficiency per unit capacity
    current_efficiency = current_cost / current_utilization
    proposed_efficiency = proposed_cost / (current_utilization * 1.5)
    
    return {
        'current_monthly_cost': current_cost,
        'proposed_monthly_cost': proposed_cost,
        'cost_increase': cost_increase,
        'cost_increase_percentage': round(cost_increase_pct, 1),
        'annual_cost_increase': round(cost_increase * 12, 2),
        'cost_efficiency_change': 'Improved' if proposed_efficiency < current_efficiency else 'Worse',
        'roi_days': calculate_roi_days(cost_increase, projected_revenue_growth),
        'budget_impact': classify_budget_impact(cost_increase, current_cost)
    }

# 1. Install dependencies
pip install prophet pandas numpy scikit-learn requests

# 2. Install Node Exporter (collect VPS metrics)
wget https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz
tar xvfz node_exporter-1.7.0.linux-amd64.tar.gz
sudo cp node_exporter-1.7.0.linux-amd64/node_exporter /usr/local/bin/

# 3. Create systemd service
sudo tee /etc/systemd/system/node_exporter.service << 'EOF'
[Unit]
Description=Node Exporter
After=network.target

[Service]
User=node_exporter
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl enable node_exporter
sudo systemctl start node_exporter

# prometheus.yml
global:
  scrape_interval: 30s
  evaluation_interval: 30s

scrape_configs:
  - job_name: 'vps-infra'
    static_configs:
      - targets: ['localhost:9100', 'vps2:9100', 'vps3:9100']
  
  - job_name: 'vps-app'
    static_configs:
      - targets: ['app-exporter:8080']

#!/usr/bin/env python3
"""
AI Capacity Planning & Forecasting Script
Usage: python3 capacity_planner.py --server vps1 --forecast-days 30
"""

import argparse
import json
import requests
from datetime import datetime, timedelta
import pandas as pd
from prophet import Prophet

PROMETHEUS_URL = "http://localhost:9090"

def fetch_metrics(query: str, time_range: str = "30d") -> pd.DataFrame:
    """Fetch metric data from Prometheus"""
    url = f"{PROMETHEUS_URL}/api/v1/query"
    params = {
        "query": query,
        "time": datetime.now().isoformat(),
        "range": time_range
    }
    response = requests.get(url, params=params)
    data = response.json()
    
    records = []
    for series in data['data']['result']:
        for timestamp, value in series['values']:
            records.append({
                'ds': pd.to_datetime(float(timestamp), unit='s'),
                'y': float(value),
                'instance': series['metric'].get('instance', 'unknown')
            })
    
    return pd.DataFrame(records)

def analyze_capacity(server: str, forecast_days: int = 30):
    """Analyze capacity status of a single server"""
    
    metrics_to_analyze = [
        ("cpu_usage", '100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)'),
        ("memory_usage", '(1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100'),
        ("disk_usage", '(1 - (node_filesystem_avail_bytes / node_filesystem_size_bytes)) * 100'),
        ("iowait", 'avg by(instance) (rate(node_cpu_seconds_total{mode="iowait"}[5m])) * 100'),
    ]
    
    results = {}
    
    for metric_name, promql in metrics_to_analyze:
        df = fetch_metrics(promql)
        if df.empty:
            continue
        
        model = Prophet(
            yearly_seasonality=True,
            weekly_seasonality=True
        )
        model.fit(df)
        
        future = model.make_future_dataframe(periods=forecast_days)
        forecast = model.predict(future)
        
        last_value = df['y'].iloc[-1]
        trend_slope = forecast['trend'].diff().mean()
        predicted_30d = forecast['yhat'].iloc[-forecast_days]
        
        results[metric_name] = {
            'current': round(last_value, 1),
            'trend': round(trend_slope * 30, 2),
            'predicted_30d': round(float(predicted_30d), 1),
            'data_points': len(df)
        }
    
    health = calculate_capacity_health(results)
    
    return {
        'server': server,
        'timestamp': datetime.now().isoformat(),
        'metrics': results,
        'health': health,
        'forecast_days': forecast_days
    }

#!/usr/bin/env python3
"""LLM Capacity Planning Decision Engine"""

import json
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get('LLM_API_KEY'),
    base_url=os.environ.get('LLM_BASE_URL', 'http://localhost:11434/v1')
)

SYSTEM_PROMPT = """
You are a senior cloud operations architect specializing in VPS capacity planning and cost optimization.
Your task is to analyze server capacity data and provide professional, actionable scaling recommendations.

Requirements:
1. Data-driven decisions based on actual metrics
2. Consider budget constraints, give cost-effective solutions
3. Risk assessment should be specific, not generic
4. Output should be clear and executable for operations teams
"""

def get_capacity_recommendation(capacity_report: dict) -> dict:
    """Get LLM-generated scaling recommendations"""
    
    user_message = f"""
Analyze the following server capacity report and provide scaling recommendations:

```json
{json.dumps(capacity_report, indent=2)}