#!/usr/bin/env python3
"""
Monolith Cost Calculator - See what you'd save by consolidating
No AWS access needed - just count your resources and edit below
"""

# ============================================================
# EDIT THIS SECTION WITH YOUR ACTUAL INFRASTRUCTURE
# ============================================================

my_services = {
    'ec2': {
        't3.micro': 0,      # How many t3.micro instances?
        't3.small': 5,      # How many t3.small instances?
        't3.medium': 15,    # How many t3.medium instances?
        't3.large': 0,      # How many t3.large instances?
        't3.xlarge': 0,     # How many t3.xlarge instances?
        't3.2xlarge': 0,    # How many t3.2xlarge instances?
        'm5.large': 3,      # How many m5.large instances?
        'm5.xlarge': 0,     # How many m5.xlarge instances?
        'm5.2xlarge': 0,    # How many m5.2xlarge instances?
    },
    'rds': {
        'db.t3.micro': 0,    # How many db.t3.micro databases?
        'db.t3.small': 8,    # How many db.t3.small databases?
        'db.t3.medium': 3,   # How many db.t3.medium databases?
        'db.t3.large': 0,    # How many db.t3.large databases?
        'db.t4g.medium': 0,  # How many db.t4g.medium databases?
        'db.t4g.large': 0,   # How many db.t4g.large databases?
        'db.m5.large': 0,    # How many db.m5.large databases?
        'db.m5.xlarge': 0,   # How many db.m5.xlarge databases?
    },
    'alb_count': 20,        # How many Application Load Balancers?
    'nat_gateway_count': 3,  # How many NAT Gateways?
}

# ============================================================
# DON'T EDIT BELOW THIS LINE
# ============================================================

def calculate_current_costs(services):
    """Calculate current microservices infrastructure costs"""
    
    # AWS pricing (us-east-1, on-demand, monthly)
    ec2_monthly = {
        't3.micro': 7.49,
        't3.small': 15.18,
        't3.medium': 30.37,
        't3.large': 60.74,
        't3.xlarge': 121.47,
        't3.2xlarge': 242.94,
        'm5.large': 69.12,
        'm5.xlarge': 138.24,
        'm5.2xlarge': 276.48,
    }
    
    rds_monthly = {
        'db.t3.micro': 12.41,
        'db.t3.small': 24.82,
        'db.t3.medium': 49.64,
        'db.t3.large': 99.28,
        'db.t4g.medium': 45.26,
        'db.t4g.large': 90.52,
        'db.m5.large': 128.52,
        'db.m5.xlarge': 257.04,
    }
    
    total = 0
    breakdown = {}
    
    # EC2 costs
    for instance_type, count in services['ec2'].items():
        if count > 0:
            cost = ec2_monthly.get(instance_type, 50) * count
            total += cost
            breakdown[f'EC2 {instance_type}'] = {'count': count, 'monthly': cost}
    
    # RDS costs
    for instance_type, count in services['rds'].items():
        if count > 0:
            cost = rds_monthly.get(instance_type, 100) * count
            total += cost
            breakdown[f'RDS {instance_type}'] = {'count': count, 'monthly': cost}
    
    # Load balancers
    alb_cost = services.get('alb_count', 0) * 18
    if alb_cost > 0:
        total += alb_cost
        breakdown['Load Balancers'] = {'count': services.get('alb_count', 0), 'monthly': alb_cost}
    
    # NAT Gateways
    nat_cost = services.get('nat_gateway_count', 0) * 32
    if nat_cost > 0:
        total += nat_cost
        breakdown['NAT Gateways'] = {'count': services.get('nat_gateway_count', 0), 'monthly': nat_cost}
    
    # Data transfer estimate (inter-service communication)
    service_count = sum(services['ec2'].values())
    if service_count > 1:
        # Rough estimate: each service talks to 3 others, 100GB/month each
        transfer_cost = min(service_count * 3, service_count * (service_count-1) / 2) * 1.0  # $1 per connection
        total += transfer_cost
        breakdown['Data Transfer (est)'] = {'count': f'{service_count} services', 'monthly': transfer_cost}
    
    return total, breakdown

def calculate_monolith_costs(services):
    """Calculate equivalent monolith infrastructure costs"""
    
    # Calculate total compute needed
    total_vcpus = 0
    vcpu_map = {
        't3.micro': 2, 't3.small': 2, 't3.medium': 2, 
        't3.large': 2, 't3.xlarge': 4, 't3.2xlarge': 8,
        'm5.large': 2, 'm5.xlarge': 4, 'm5.2xlarge': 8
    }
    
    for instance_type, count in services['ec2'].items():
        total_vcpus += vcpu_map.get(instance_type, 2) * count
    
    # Monolith is 30% more efficient (no network overhead, better resource usage)
    needed_vcpus = int(total_vcpus * 0.7)
    
    # Size the monolith
    monolith = {}
    if needed_vcpus <= 4:
        monolith['ec2'] = {'t3.xlarge': 1}
    elif needed_vcpus <= 8:
        monolith['ec2'] = {'t3.2xlarge': 1}
    elif needed_vcpus <= 16:
        monolith['ec2'] = {'m5.2xlarge': 2}
    else:
        instance_count = max(3, needed_vcpus // 8)  # At least 3 for HA
        monolith['ec2'] = {'m5.2xlarge': instance_count}
    
    # Database consolidation
    total_db_count = sum(services['rds'].values())
    if total_db_count == 0:
        monolith['rds'] = {}
    elif total_db_count <= 3:
        monolith['rds'] = {'db.t4g.large': 1}
    elif total_db_count <= 10:
        monolith['rds'] = {'db.m5.xlarge': 1}
    else:
        monolith['rds'] = {'db.m5.xlarge': 2}
    
    # Monolith needs minimal infrastructure
    monolith['alb_count'] = 1  # Just one ALB
    monolith['nat_gateway_count'] = 0  # Public subnet with security groups
    
    return calculate_current_costs(monolith)

def generate_report(services):
    """Generate the cost comparison report"""
    
    current_cost, current_breakdown = calculate_current_costs(services)
    monolith_cost, monolith_breakdown = calculate_monolith_costs(services)
    monthly_savings = current_cost - monolith_cost
    
    print("\n" + "="*60)
    print("💰 MICROSERVICES VS MONOLITH COST ANALYSIS")
    print("="*60)
    
    print("\n📊 CURRENT MICROSERVICES SETUP:")
    for item, details in current_breakdown.items():
        print(f"  {item}: {details['count']} × ${details['monthly']/details['count'] if details['count'] else 0:.2f} = ${details['monthly']:.2f}/mo")
    print(f"\n  TOTAL: ${current_cost:,.2f}/month (${current_cost*12:,.2f}/year)")
    
    print("\n🎯 EQUIVALENT MONOLITH SETUP:")
    for item, details in monolith_breakdown.items():
        if details['monthly'] > 0:
            print(f"  {item}: {details['count']} × ${details['monthly']/details['count'] if details['count'] else 0:.2f} = ${details['monthly']:.2f}/mo")
    print(f"\n  TOTAL: ${monolith_cost:,.2f}/month (${monolith_cost*12:,.2f}/year)")
    
    print("\n" + "="*60)
    print(f"💸 MONTHLY SAVINGS: ${monthly_savings:,.2f}")
    print(f"💰 ANNUAL SAVINGS: ${monthly_savings * 12:,.2f}")
    print(f"📉 COST REDUCTION: {(monthly_savings/current_cost)*100:.1f}%")
    print("="*60)
    
    if monthly_savings > 10000:
        print("\n🚨 HOLY SH*T: You're burning a senior engineer's salary on complexity!")
    elif monthly_savings > 5000:
        print("\n⚠️  WARNING: That's a junior engineer's salary in savings!")
    elif monthly_savings > 1000:
        print("\n💡 That's real money. Time to consolidate.")
    else:
        print("\n✅ Your architecture is reasonably cost-efficient.")
    
    return monthly_savings

if __name__ == "__main__":
    savings = generate_report(my_services)
    
    if savings > 1000:
        print("\n📝 NEXT STEPS:")
        print("1. Start with services owned by the same team")
        print("2. Consolidate read-heavy services first")
        print("3. Keep services with different scaling patterns separate")
        print("4. Use the strangler pattern - no big bang 
rewrites")

$ python monolith_calculator.py

============================================================
💰 MICROSERVICES VS MONOLITH COST ANALYSIS
============================================================

📊 CURRENT MICROSERVICES SETUP:
  EC2 t3.small: 5 × $15.18 = $75.90/mo
  EC2 t3.medium: 15 × $30.37 = $455.55/mo
  EC2 m5.large: 3 × $69.12 = $207.36/mo
  RDS db.t3.small: 8 × $24.82 = $198.56/mo
  RDS db.t3.medium: 3 × $49.64 = $148.92/mo
  Load Balancers: 20 × $18.00 = $360.00/mo
  NAT Gateways: 3 × $32.00 = $96.00/mo
  Data Transfer (est): 23 services = $23.00/mo

  TOTAL: $1,565.29/month ($18,783.48/year)

🎯 EQUIVALENT MONOLITH SETUP:
  EC2 m5.2xlarge: 3 × $276.48 = $829.44/mo
  RDS db.m5.xlarge: 1 × $257.04 = $257.04/mo
  Load Balancers: 1 × $18.00 = $18.00/mo

  TOTAL: $1,104.48/month ($13,253.76/year)

============================================================
💸 MONTHLY SAVINGS: $460.81
💰 ANNUAL SAVINGS: $5,529.72
📉 COST REDUCTION: 29.4%
============================================================

💡 That's real money. Time to consolidate.

📝 NEXT STEPS:
1. Start with services owned by the same team
2. Consolidate read-heavy services first
3. Keep services with different scaling patterns separate
4. Use the strangler pattern - no big bang rewrites

# nginx.conf snippet for shadow testing
upstream microservices {
    server user-service.internal:8080;
    server order-service.internal:8080;
}

upstream monolith {
    server monolith.internal:8080;
}

location /api/ {
    proxy_pass http://microservices;
    
    # Shadow traffic to monolith (doesn't affect response)
    mirror /shadow;
}

location /shadow {
    internal;
    proxy_pass http://monolith$request_uri;
}

# Create new RDS instance with multiple schemas
aws rds create-db-instance \
    --db-instance-identifier monolith-db \
    --db-instance-class db.m5.xlarge \
    --engine postgres \
    --master-username admin \
    --master-user-password $PASSWORD \
    --allocated-storage 500

# Zero-downtime connection switch using environment variables
# Deploy this to your services gradually
import os

def get_db_connection():
    if os.getenv('USE_MONOLITH_DB', 'false').lower() == 'true':
        return {
            'host': 'monolith-db.internal',
            'port': 5432,
            'database': 'monolith',
            'schema': os.getenv('SERVICE_NAME')  # Each keeps its schema
        }
    else:
        # Original microservice DB
        return {
            'host': f"{os.getenv('SERVICE_NAME')}-db.internal",
            'port': 5432,
            'database': os.getenv('SERVICE_NAME')
        }

monolith/
├── docker-compose.yml       # Local dev matching prod
├── Dockerfile
├── src/
│   ├── api/                # HTTP layer
│   │   ├── users.py
│   │   ├── orders.py
│   │   └── router.py
│   ├── domains/            # Business logic
│   │   ├── users/
│   │   │   ├── service.py
│   │   │   ├── repository.py
│   │   │   └── models.py
│   │   ├── orders/
│   │   └── shared/
│   └── infrastructure/     # Cross-cutting concerns
│       ├── database.py
│       └── messaging.py

# docker-compose.yml
version: '3.8'
services:
  monolith:
    build: .
    ports:
      - "8080:8080"
    environment:
      - DB_HOST=postgres
      - REDIS_HOST=redis
    depends_on:
      - postgres
      - redis
  
  postgres:
    image: postgres:14
    environment:
      POSTGRES_DB: monolith
    volumes:
      - ./init-schemas.sql:/docker-entrypoint-initdb.d/init.sql
  
  redis:
    image: redis:7