Gcp Cloud Architect

"""
GCP architecture design and service recommendation module.
Generates architecture patterns based on application requirements.
"""

import argparse
import json
import sys
from typing import Dict, List, Any
from enum import Enum


class ApplicationType(Enum):
    """Types of applications supported."""
    WEB_APP = "web_application"
    MOBILE_BACKEND = "mobile_backend"
    DATA_PIPELINE = "data_pipeline"
    MICROSERVICES = "microservices"
    SAAS_PLATFORM = "saas_platform"
    ML_PLATFORM = "ml_platform"


class ArchitectureDesigner:
    """Design GCP architectures based on requirements."""

    def __init__(self, requirements: Dict[str, Any]):
        """
        Initialize with application requirements.

        Args:
            requirements: Dictionary containing app type, traffic, budget, etc.
        """
        self.app_type = requirements.get('application_type', 'web_application')
        self.expected_users = requirements.get('expected_users', 1000)
        self.requests_per_second = requirements.get('requests_per_second', 10)
        self.budget_monthly = requirements.get('budget_monthly_usd', 500)
        self.team_size = requirements.get('team_size', 3)
        self.gcp_experience = requirements.get('gcp_experience', 'beginner')
        self.compliance_needs = requirements.get('compliance', [])
        self.data_size_gb = requirements.get('data_size_gb', 10)

    def recommend_architecture_pattern(self) -> Dict[str, Any]:
        """
        Recommend architecture pattern based on requirements.

        Returns:
            Dictionary with recommended pattern and services
        """
        if self.app_type in ['web_application', 'saas_platform']:
            if self.expected_users < 10000:
                return self._serverless_web_architecture()
            elif self.expected_users < 100000:
                return self._gke_microservices_architecture()
            else:
                return self._multi_region_architecture()

        elif self.app_type == 'mobile_backend':
            return self._serverless_mobile_backend()

        elif self.app_type == 'data_pipeline':
            return self._data_pipeline_architecture()

        elif self.app_type == 'microservices':
            return self._gke_microservices_architecture()

        elif self.app_type == 'ml_platform':
            return self._ml_platform_architecture()

        else:
            return self._serverless_web_architecture()

    def _serverless_web_architecture(self) -> Dict[str, Any]:
        """Serverless web application pattern using Cloud Run."""
        return {
            'pattern_name': 'Serverless Web Application',
            'description': 'Fully serverless architecture with Cloud Run and Firestore',
            'use_case': 'SaaS platforms, low to medium traffic websites, MVPs',
            'services': {
                'frontend': {
                    'service': 'Cloud Storage + Cloud CDN',
                    'purpose': 'Static website hosting with global CDN',
                    'configuration': {
                        'bucket': 'Website bucket with public access',
                        'cdn': 'Cloud CDN with custom domain and HTTPS',
                        'caching': 'Cache-Control headers, edge caching'
                    }
                },
                'api': {
                    'service': 'Cloud Run',
                    'purpose': 'Containerized API backend with auto-scaling',
                    'configuration': {
                        'cpu': '1 vCPU',
                        'memory': '512 Mi',
                        'min_instances': '0 (scale to zero)',
                        'max_instances': '10',
                        'concurrency': '80 requests per instance',
                        'timeout': '300 seconds'
                    }
                },
                'database': {
                    'service': 'Firestore',
                    'purpose': 'NoSQL document database with real-time sync',
                    'configuration': {
                        'mode': 'Native mode',
                        'location': 'Regional or multi-region',
                        'security_rules': 'Firestore security rules',
                        'backup': 'Scheduled exports to Cloud Storage'
                    }
                },
                'authentication': {
                    'service': 'Identity Platform',
                    'purpose': 'User authentication and authorization',
                    'configuration': {
                        'providers': 'Email/password, Google, Apple, OIDC',
                        'mfa': 'SMS or TOTP multi-factor authentication',
                        'token_expiration': '1 hour access, 30 days refresh'
                    }
                },
                'cicd': {
                    'service': 'Cloud Build',
                    'purpose': 'Automated build and deployment from Git',
                    'configuration': {
                        'source': 'GitHub or Cloud Source Repositories',
                        'build': 'Automatic on commit',
                        'environments': 'dev, staging, production'
                    }
                }
            },
            'estimated_cost': {
                'monthly_usd': self._calculate_serverless_cost(),
                'breakdown': {
                    'Cloud CDN': '5-20 USD',
                    'Cloud Run': '5-25 USD',
                    'Firestore': '5-30 USD',
                    'Identity Platform': '0-10 USD (free tier: 50k MAU)',
                    'Cloud Storage': '1-5 USD'
                }
            },
            'pros': [
                'No server management',
                'Auto-scaling with scale-to-zero',
                'Pay only for what you use',
                'No cold starts with min instances',
                'Container-based (no runtime restrictions)'
            ],
            'cons': [
                'Vendor lock-in to GCP',
                'Regional availability considerations',
                'Debugging distributed systems complex',
                'Firestore query limitations vs SQL'
            ],
            'scaling_characteristics': {
                'users_supported': '1k - 100k',
                'requests_per_second': '100 - 10,000',
                'scaling_method': 'Automatic (Cloud Run auto-scaling)'
            }
        }

    def _gke_microservices_architecture(self) -> Dict[str, Any]:
        """GKE-based microservices architecture."""
        return {
            'pattern_name': 'Microservices on GKE',
            'description': 'Kubernetes-native architecture with managed services',
            'use_case': 'SaaS platforms, complex microservices, enterprise applications',
            'services': {
                'load_balancer': {
                    'service': 'Cloud Load Balancing',
                    'purpose': 'Global HTTP(S) load balancing',
                    'configuration': {
                        'type': 'External Application Load Balancer',
                        'ssl': 'Google-managed SSL certificate',
                        'health_checks': '/health endpoint, 10s interval',
                        'cdn': 'Cloud CDN enabled for static content'
                    }
                },
                'compute': {
                    'service': 'GKE Autopilot',
                    'purpose': 'Managed Kubernetes for containerized workloads',
                    'configuration': {
                        'mode': 'Autopilot (fully managed node provisioning)',
                        'scaling': 'Horizontal Pod Autoscaler',
                        'networking': 'VPC-native with Alias IPs',
                        'workload_identity': 'Enabled for secure service account binding'
                    }
                },
                'database': {
                    'service': 'Cloud SQL (PostgreSQL)',
                    'purpose': 'Managed relational database',
                    'configuration': {
                        'tier': 'db-custom-2-8192 (2 vCPU, 8 GB RAM)',
                        'high_availability': 'Regional with automatic failover',
                        'read_replicas': '1-2 for read scaling',
                        'backup': 'Automated daily backups, 7-day retention',
                        'encryption': 'Customer-managed encryption key (CMEK)'
                    }
                },
                'cache': {
                    'service': 'Memorystore (Redis)',
                    'purpose': 'Session storage, application caching',
                    'configuration': {
                        'tier': 'Basic (1 GB) or Standard (HA)',
                        'version': 'Redis 7.0',
                        'eviction_policy': 'allkeys-lru'
                    }
                },
                'messaging': {
                    'service': 'Pub/Sub',
                    'purpose': 'Asynchronous messaging between services',
                    'configuration': {
                        'topics': 'Per-domain event topics',
                        'subscriptions': 'Pull or push delivery',
                        'dead_letter': 'Dead letter topic after 5 retries',
                        'ordering': 'Ordering keys for ordered delivery'
                    }
                },
                'storage': {
                    'service': 'Cloud Storage',
                    'purpose': 'User uploads, backups, logs',
                    'configuration': {
                        'storage_class': 'Standard with lifecycle policies',
                        'versioning': 'Enabled for important buckets',
                        'lifecycle': 'Transition to Nearline after 30 days'
                    }
                }
            },
            'estimated_cost': {
                'monthly_usd': self._calculate_gke_cost(),
                'breakdown': {
                    'Cloud Load Balancing': '20-40 USD',
                    'GKE Autopilot': '75-250 USD',
                    'Cloud SQL': '80-250 USD',
                    'Memorystore': '30-80 USD',
                    'Pub/Sub': '5-20 USD',
                    'Cloud Storage': '5-20 USD'
                }
            },
            'pros': [
                'Kubernetes ecosystem compatibility',
                'Fine-grained scaling control',
                'Multi-cloud portability',
                'Rich service mesh (Anthos Service Mesh)',
                'Managed node provisioning with Autopilot'
            ],
            'cons': [
                'Higher baseline costs than serverless',
                'Kubernetes learning curve',
                'More operational complexity',
                'GKE management fee ($74.40/month per cluster)'
            ],
            'scaling_characteristics': {
                'users_supported': '10k - 500k',
                'requests_per_second': '1,000 - 50,000',
                'scaling_method': 'HPA + Cluster Autoscaler'
            }
        }

    def _serverless_mobile_backend(self) -> Dict[str, Any]:
        """Serverless mobile backend with Firebase."""
        return {
            'pattern_name': 'Serverless Mobile Backend',
            'description': 'Mobile-first backend with Firebase and Cloud Functions',
            'use_case': 'Mobile apps, real-time applications, offline-first apps',
            'services': {
                'api': {
                    'service': 'Cloud Functions (2nd gen)',
                    'purpose': 'Event-driven API handlers',
                    'configuration': {
                        'runtime': 'Node.js 20 or Python 3.12',
                        'memory': '256 MB - 1 GB',
                        'timeout': '60 seconds',
                        'concurrency': 'Up to 1000 concurrent'
                    }
                },
                'database': {
                    'service': 'Firestore',
                    'purpose': 'Real-time NoSQL database with offline sync',
                    'configuration': {
                        'mode': 'Native mode',
                        'multi_region': 'nam5 or eur3 for HA',
                        'security_rules': 'Client-side access control',
                        'indexes': 'Composite indexes for queries'
                    }
                },
                'file_storage': {
                    'service': 'Cloud Storage (Firebase)',
                    'purpose': 'User uploads (images, videos, documents)',
                    'configuration': {
                        'access': 'Firebase Security Rules',
                        'resumable_uploads': 'Enabled for large files',
                        'cdn': 'Automatic via Firebase Hosting CDN'
                    }
                },
                'authentication': {
                    'service': 'Firebase Authentication',
                    'purpose': 'User management and federation',
                    'configuration': {
                        'providers': 'Email, Google, Apple, Phone',
                        'anonymous_auth': 'Enabled for guest access',
                        'custom_claims': 'Role-based access control',
                        'multi_tenancy': 'Supported via Identity Platform'
                    }
                },
                'push_notifications': {
                    'service': 'Firebase Cloud Messaging (FCM)',
                    'purpose': 'Push notifications to mobile devices',
                    'configuration': {
                        'platforms': 'iOS (APNs), Android, Web',
                        'topics': 'Topic-based group messaging',
                        'analytics': 'Notification delivery tracking'
                    }
                },
                'analytics': {
                    'service': 'Google Analytics (Firebase)',
                    'purpose': 'User analytics and event tracking',
                    'configuration': {
                        'events': 'Custom and automatic events',
                        'audiences': 'User segmentation',
                        'bigquery_export': 'Raw event export to BigQuery'
                    }
                }
            },
            'estimated_cost': {
                'monthly_usd': 40 + (self.expected_users * 0.004),
                'breakdown': {
                    'Cloud Functions': '5-30 USD',
                    'Firestore': '10-50 USD',
                    'Cloud Storage': '5-20 USD',
                    'Identity Platform': '0-15 USD',
                    'FCM': '0 USD (free)',
                    'Analytics': '0 USD (free)'
                }
            },
            'pros': [
                'Real-time data sync built-in',
                'Offline-first support',
                'Firebase SDKs for iOS/Android/Web',
                'Free tier covers most MVPs',
                'Rapid development with Firebase console'
            ],
            'cons': [
                'Firestore query limitations',
                'Vendor lock-in to Firebase/GCP',
                'Cost scaling can be unpredictable',
                'Limited server-side control'
            ],
            'scaling_characteristics': {
                'users_supported': '1k - 1M',
                'requests_per_second': '100 - 100,000',
                'scaling_method': 'Automatic (Firebase managed)'
            }
        }

    def _data_pipeline_architecture(self) -> Dict[str, Any]:
        """Serverless data pipeline with BigQuery."""
        return {
            'pattern_name': 'Serverless Data Pipeline',
            'description': 'Scalable data ingestion, processing, and analytics',
            'use_case': 'Analytics, IoT data, log processing, ETL, data warehousing',
            'services': {
                'ingestion': {
                    'service': 'Pub/Sub',
                    'purpose': 'Real-time event and data ingestion',
                    'configuration': {
                        'throughput': 'Unlimited (auto-scaling)',
                        'retention': '7 days (configurable to 31 days)',
                        'ordering': 'Ordering keys for ordered delivery',
                        'dead_letter': 'Dead letter topic for failed messages'
                    }
                },
                'processing': {
                    'service': 'Dataflow (Apache Beam)',
                    'purpose': 'Stream and batch data processing',
                    'configuration': {
                        'mode': 'Streaming or batch',
                        'autoscaling': 'Horizontal autoscaling',
                        'workers': f'{max(1, self.data_size_gb // 20)} initial workers',
                        'sdk': 'Python or Java Apache Beam SDK'
                    }
                },
                'warehouse': {
                    'service': 'BigQuery',
                    'purpose': 'Serverless data warehouse and analytics',
                    'configuration': {
                        'pricing': 'On-demand ($6.25/TB queried) or slots',
                        'partitioning': 'By ingestion time or custom field',
                        'clustering': 'Up to 4 clustering columns',
                        'streaming_insert': 'Real-time data availability'
                    }
                },
                'storage': {
                    'service': 'Cloud Storage (Data Lake)',
                    'purpose': 'Raw data lake and archival storage',
                    'configuration': {
                        'format': 'Parquet or Avro (columnar)',
                        'partitioning': 'By date (year/month/day)',
                        'lifecycle': 'Transition to Coldline after 90 days',
                        'catalog': 'Dataplex for data governance'
                    }
                },
                'visualization': {
                    'service': 'Looker / Looker Studio',
                    'purpose': 'Business intelligence dashboards',
                    'configuration': {
                        'source': 'BigQuery direct connection',
                        'refresh': 'Real-time or scheduled',
                        'sharing': 'Embedded or web dashboards'
                    }
                },
                'orchestration': {
                    'service': 'Cloud Composer (Airflow)',
                    'purpose': 'Workflow orchestration for batch pipelines',
                    'configuration': {
                        'environment': 'Cloud Composer 2 (auto-scaling)',
                        'dags': 'Python DAG definitions',
                        'scheduling': 'Cron-based scheduling'
                    }
                }
            },
            'estimated_cost': {
                'monthly_usd': self._calculate_data_pipeline_cost(),
                'breakdown': {
                    'Pub/Sub': '5-30 USD',
                    'Dataflow': '20-150 USD',
                    'BigQuery': '10-100 USD (on-demand)',
                    'Cloud Storage': '5-30 USD',
                    'Looker Studio': '0 USD (free)',
                    'Cloud Composer': '300+ USD (if used)'
                }
            },
            'pros': [
                'Fully serverless data stack',
                'BigQuery scales to petabytes',
                'Real-time and batch in same pipeline',
                'Cost-effective with on-demand pricing',
                'ML integration via BigQuery ML'
            ],
            'cons': [
                'Dataflow has steep learning curve (Beam SDK)',
                'BigQuery costs based on data scanned',
                'Cloud Composer expensive for small workloads',
                'Schema evolution requires planning'
            ],
            'scaling_characteristics': {
                'events_per_second': '1,000 - 10,000,000',
                'data_volume': '1 GB - 1 PB per day',
                'scaling_method': 'Automatic (all services auto-scale)'
            }
        }

    def _ml_platform_architecture(self) -> Dict[str, Any]:
        """ML platform architecture with Vertex AI."""
        return {
            'pattern_name': 'ML Platform',
            'description': 'End-to-end machine learning platform',
            'use_case': 'Model training, serving, MLOps, feature engineering',
            'services': {
                'ml_platform': {
                    'service': 'Vertex AI',
                    'purpose': 'Training, tuning, and serving ML models',
                    'configuration': {
                        'training': 'Custom or AutoML training jobs',
                        'prediction': 'Online or batch prediction endpoints',
                        'pipelines': 'Vertex AI Pipelines for MLOps',
                        'feature_store': 'Vertex AI Feature Store'
                    }
                },
                'data': {
                    'service': 'BigQuery',
                    'purpose': 'Feature engineering and data exploration',
                    'configuration': {
                        'ml': 'BigQuery ML for in-warehouse models',
                        'export': 'Export to Cloud Storage for training',
                        'feature_engineering': 'SQL-based transformations'
                    }
                },
                'storage': {
                    'service': 'Cloud Storage',
                    'purpose': 'Datasets, model artifacts, experiment logs',
                    'configuration': {
                        'buckets': 'Separate buckets for data/models/logs',
                        'versioning': 'Enabled for model artifacts',
                        'lifecycle': 'Archive old experiment data'
                    }
                },
                'triggers': {
                    'service': 'Cloud Functions',
                    'purpose': 'Event-driven preprocessing and triggers',
                    'configuration': {
                        'triggers': 'Cloud Storage, Pub/Sub, Scheduler',
                        'preprocessing': 'Data validation and transforms',
                        'notifications': 'Training completion alerts'
                    }
                },
                'monitoring': {
                    'service': 'Vertex AI Model Monitoring',
                    'purpose': 'Detect data drift and model degradation',
                    'configuration': {
                        'skew_detection': 'Training-serving skew alerts',
                        'drift_detection': 'Feature drift monitoring',
                        'alerting': 'Cloud Monitoring integration'
                    }
                }
            },
            'estimated_cost': {
                'monthly_usd': 200 + (self.data_size_gb * 2),
                'breakdown': {
                    'Vertex AI Training': '50-500 USD (GPU dependent)',
                    'Vertex AI Prediction': '30-200 USD',
                    'BigQuery': '20-100 USD',
                    'Cloud Storage': '10-50 USD',
                    'Cloud Functions': '5-20 USD'
                }
            },
            'pros': [
                'End-to-end ML lifecycle management',
                'AutoML for rapid prototyping',
                'Integrated with BigQuery and Cloud Storage',
                'Managed model serving with autoscaling',
                'Built-in experiment tracking'
            ],
            'cons': [
                'GPU costs can escalate quickly',
                'Vertex AI pricing is complex',
                'Limited customization vs self-managed',
                'Vendor lock-in for model artifacts'
            ],
            'scaling_characteristics': {
                'training': 'Multi-GPU, distributed training',
                'prediction': '1 - 1000+ replicas',
                'scaling_method': 'Automatic endpoint scaling'
            }
        }

    def _multi_region_architecture(self) -> Dict[str, Any]:
        """Multi-region high availability architecture."""
        return {
            'pattern_name': 'Multi-Region High Availability',
            'description': 'Global deployment with disaster recovery',
            'use_case': 'Global applications, 99.99% uptime, compliance',
            'services': {
                'dns': {
                    'service': 'Cloud DNS',
                    'purpose': 'Global DNS with health-checked routing',
                    'configuration': {
                        'routing_policy': 'Geolocation or weighted routing',
                        'health_checks': 'HTTP health checks per region',
                        'failover': 'Automatic DNS failover'
                    }
                },
                'cdn': {
                    'service': 'Cloud CDN',
                    'purpose': 'Edge caching and acceleration',
                    'configuration': {
                        'origins': 'Multiple regional backends',
                        'cache_modes': 'CACHE_ALL_STATIC or USE_ORIGIN_HEADERS',
                        'edge_locations': 'Global (100+ locations)'
                    }
                },
                'compute': {
                    'service': 'Multi-region GKE or Cloud Run',
                    'purpose': 'Active-active deployment across regions',
                    'configuration': {
                        'regions': 'us-central1 (primary), europe-west1 (secondary)',
                        'deployment': 'Cloud Deploy for multi-region rollout',
                        'traffic_split': 'Global Load Balancer with traffic management'
                    }
                },
                'database': {
                    'service': 'Cloud Spanner or Firestore multi-region',
                    'purpose': 'Globally consistent database',
                    'configuration': {
                        'spanner': 'Multi-region config (nam-eur-asia1)',
                        'firestore': 'Multi-region location (nam5, eur3)',
                        'consistency': 'Strong consistency (Spanner) or eventual (Firestore)',
                        'replication': 'Automatic cross-region replication'
                    }
                },
                'storage': {
                    'service': 'Cloud Storage (dual-region or multi-region)',
                    'purpose': 'Geo-redundant object storage',
                    'configuration': {
                        'location': 'Dual-region (us-central1+us-east1) or multi-region (US)',
                        'turbo_replication': '15-minute RPO with turbo replication',
                        'versioning': 'Enabled for critical data'
                    }
                }
            },
            'estimated_cost': {
                'monthly_usd': self._calculate_gke_cost() * 2.0,
                'breakdown': {
                    'Cloud DNS': '5-15 USD',
                    'Cloud CDN': '20-100 USD',
                    'Compute (2 regions)': '150-500 USD',
                    'Cloud Spanner': '500-2000 USD (multi-region)',
                    'Data transfer (cross-region)': '50-200 USD'
                }
            },
            'pros': [
                'Global low latency',
                'High availability (99.99%+)',
                'Disaster recovery built-in',
                'Data sovereignty compliance',
                'Automatic failover'
            ],
            'cons': [
                '2x+ costs vs single region',
                'Cloud Spanner is expensive',
                'Complex deployment pipeline',
                'Cross-region data transfer costs',
                'Operational overhead'
            ],
            'scaling_characteristics': {
                'users_supported': '100k - 100M',
                'requests_per_second': '10,000 - 10,000,000',
                'scaling_method': 'Per-region auto-scaling + global load balancing'
            }
        }

    def _calculate_serverless_cost(self) -> float:
        """Estimate serverless architecture cost."""
        requests_per_month = self.requests_per_second * 2_592_000
        cloud_run_cost = max(5, (requests_per_month / 1_000_000) * 0.40)
        firestore_cost = max(5, self.data_size_gb * 0.18)
        cdn_cost = max(5, self.expected_users * 0.008)
        storage_cost = max(1, self.data_size_gb * 0.02)

        total = cloud_run_cost + firestore_cost + cdn_cost + storage_cost
        return min(total, self.budget_monthly)

    def _calculate_gke_cost(self) -> float:
        """Estimate GKE microservices architecture cost."""
        gke_management = 74.40  # Autopilot cluster fee
        pod_cost = max(2, self.expected_users // 5000) * 35
        cloud_sql_cost = 120  # db-custom-2-8192 baseline
        memorystore_cost = 35  # Basic 1 GB
        lb_cost = 25

        total = gke_management + pod_cost + cloud_sql_cost + memorystore_cost + lb_cost
        return min(total, self.budget_monthly)

    def _calculate_data_pipeline_cost(self) -> float:
        """Estimate data pipeline cost."""
        pubsub_cost = max(5, self.data_size_gb * 0.5)
        dataflow_cost = max(20, self.data_size_gb * 1.5)
        bigquery_cost = max(10, self.data_size_gb * 0.02 * 6.25)
        storage_cost = self.data_size_gb * 0.02

        total = pubsub_cost + dataflow_cost + bigquery_cost + storage_cost
        return min(total, self.budget_monthly)

    def generate_service_checklist(self) -> list:
        """Generate implementation checklist for recommended architecture."""
        architecture = self.recommend_architecture_pattern()

        checklist = [
            {
                'phase': 'Planning',
                'tasks': [
                    'Review architecture pattern and services',
                    'Estimate costs using GCP Pricing Calculator',
                    'Define environment strategy (dev, staging, prod)',
                    'Set up GCP Organization and projects',
                    'Define labeling strategy for resources'
                ]
            },
            {
                'phase': 'Foundation',
                'tasks': [
                    'Create VPC with subnets (if using GKE/Compute)',
                    'Configure Cloud NAT for private resources',
                    'Set up IAM roles and service accounts',
                    'Enable Cloud Audit Logs',
                    'Configure Organization policies'
                ]
            },
            {
                'phase': 'Core Services',
                'tasks': [
                    f"Deploy {service['service']}"
                    for service in architecture['services'].values()
                ]
            },
            {
                'phase': 'Security',
                'tasks': [
                    'Configure firewall rules and VPC Service Controls',
                    'Enable encryption (Cloud KMS) for all services',
                    'Set up Cloud Armor WAF rules',
                    'Configure Secret Manager for credentials',
                    'Enable Security Command Center'
                ]
            },
            {
                'phase': 'Monitoring',
                'tasks': [
                    'Create Cloud Monitoring dashboards',
                    'Set up alerting policies for critical metrics',
                    'Configure notification channels (email, Slack, PagerDuty)',
                    'Enable Cloud Trace for distributed tracing',
                    'Set up log-based metrics and log sinks'
                ]
            },
            {
                'phase': 'CI/CD',
                'tasks': [
                    'Set up Cloud Build triggers',
                    'Configure automated testing',
                    'Implement canary or rolling deployments',
                    'Set up rollback procedures',
                    'Document deployment process'
                ]
            }
        ]

        return checklist


def main():
    parser = argparse.ArgumentParser(
        description='GCP Architecture Designer - Recommends GCP services based on workload requirements'
    )
    parser.add_argument(
        '--input', '-i',
        type=str,
        help='Path to JSON file with application requirements'
    )
    parser.add_argument(
        '--output', '-o',
        type=str,
        help='Path to write design output JSON'
    )
    parser.add_argument(
        '--json',
        action='store_true',
        help='Output as JSON format'
    )
    parser.add_argument(
        '--app-type',
        type=str,
        choices=['web_application', 'mobile_backend', 'data_pipeline',
                 'microservices', 'saas_platform', 'ml_platform'],
        default='web_application',
        help='Application type (default: web_application)'
    )
    parser.add_argument(
        '--users',
        type=int,
        default=1000,
        help='Expected number of users (default: 1000)'
    )
    parser.add_argument(
        '--budget',
        type=float,
        default=500,
        help='Monthly budget in USD (default: 500)'
    )

    args = parser.parse_args()

    if args.input:
        try:
            with open(args.input, 'r') as f:
                requirements = json.load(f)
        except FileNotFoundError:
            print(f"Error: File '{args.input}' not found.", file=sys.stderr)
            sys.exit(1)
        except json.JSONDecodeError:
            print(f"Error: File '{args.input}' is not valid JSON.", file=sys.stderr)
            sys.exit(1)
    else:
        requirements = {
            'application_type': args.app_type,
            'expected_users': args.users,
            'budget_monthly_usd': args.budget
        }

    designer = ArchitectureDesigner(requirements)
    result = designer.recommend_architecture_pattern()
    checklist = designer.generate_service_checklist()

    output = {
        'architecture': result,
        'implementation_checklist': checklist
    }

    if args.output:
        with open(args.output, 'w') as f:
            json.dump(output, f, indent=2)
        print(f"Design written to {args.output}")
    elif args.json:
        print(json.dumps(output, indent=2))
    else:
        print(f"\nRecommended Pattern: {result['pattern_name']}")
        print(f"Description: {result['description']}")
        print(f"Use Case: {result['use_case']}")
        print(f"\nServices:")
        for name, svc in result['services'].items():
            print(f"  - {name}: {svc['service']} ({svc['purpose']})")
        print(f"\nEstimated Monthly Cost: ${result['estimated_cost']['monthly_usd']:.2f}")
        print(f"\nPros: {', '.join(result['pros'])}")
        print(f"Cons: {', '.join(result['cons'])}")


if __name__ == '__main__':
    main()

"""
GCP cost optimization analyzer.
Provides cost-saving recommendations for GCP resources.
"""

import argparse
import json
import sys
from typing import Dict, List, Any


class CostOptimizer:
    """Analyze GCP costs and provide optimization recommendations."""

    def __init__(self, current_resources: Dict[str, Any], monthly_spend: float):
        """
        Initialize with current GCP resources and spending.

        Args:
            current_resources: Dictionary of current GCP resources
            monthly_spend: Current monthly GCP spend in USD
        """
        self.resources = current_resources
        self.monthly_spend = monthly_spend
        self.recommendations = []

    def analyze_and_optimize(self) -> Dict[str, Any]:
        """
        Analyze current setup and generate cost optimization recommendations.

        Returns:
            Dictionary with recommendations and potential savings
        """
        self.recommendations = []
        potential_savings = 0.0

        compute_savings = self._analyze_compute()
        potential_savings += compute_savings

        storage_savings = self._analyze_storage()
        potential_savings += storage_savings

        database_savings = self._analyze_database()
        potential_savings += database_savings

        network_savings = self._analyze_networking()
        potential_savings += network_savings

        general_savings = self._analyze_general_optimizations()
        potential_savings += general_savings

        return {
            'current_monthly_spend': self.monthly_spend,
            'potential_monthly_savings': round(potential_savings, 2),
            'optimized_monthly_spend': round(self.monthly_spend - potential_savings, 2),
            'savings_percentage': round((potential_savings / self.monthly_spend) * 100, 2) if self.monthly_spend > 0 else 0,
            'recommendations': self.recommendations,
            'priority_actions': self._prioritize_recommendations()
        }

    def _analyze_compute(self) -> float:
        """Analyze compute resources (GCE, GKE, Cloud Run)."""
        savings = 0.0

        gce_instances = self.resources.get('gce_instances', [])
        if gce_instances:
            idle_count = sum(1 for inst in gce_instances if inst.get('cpu_utilization', 100) < 10)
            if idle_count > 0:
                idle_cost = idle_count * 50
                savings += idle_cost
                self.recommendations.append({
                    'service': 'Compute Engine',
                    'type': 'Idle Resources',
                    'issue': f'{idle_count} GCE instances with <10% CPU utilization',
                    'recommendation': 'Stop or delete idle instances, or downsize to smaller machine types',
                    'potential_savings': idle_cost,
                    'priority': 'high'
                })

            # Check for committed use discounts
            on_demand_count = sum(1 for inst in gce_instances if inst.get('pricing', 'on-demand') == 'on-demand')
            if on_demand_count >= 2:
                cud_savings = on_demand_count * 50 * 0.37  # 37% savings with 1-yr CUD
                savings += cud_savings
                self.recommendations.append({
                    'service': 'Compute Engine',
                    'type': 'Committed Use Discounts',
                    'issue': f'{on_demand_count} instances on on-demand pricing',
                    'recommendation': 'Purchase 1-year committed use discounts for predictable workloads (37% savings) or 3-year (55% savings)',
                    'potential_savings': cud_savings,
                    'priority': 'medium'
                })

            # Check for sustained use discounts awareness
            short_lived = sum(1 for inst in gce_instances if inst.get('uptime_hours_month', 730) < 200)
            if short_lived > 0:
                self.recommendations.append({
                    'service': 'Compute Engine',
                    'type': 'Scheduling',
                    'issue': f'{short_lived} instances running <200 hours/month',
                    'recommendation': 'Use Instance Scheduler to stop dev/test instances outside business hours',
                    'potential_savings': short_lived * 20,
                    'priority': 'medium'
                })
                savings += short_lived * 20

        # GKE optimization
        gke_clusters = self.resources.get('gke_clusters', [])
        for cluster in gke_clusters:
            if cluster.get('mode', 'standard') == 'standard':
                node_utilization = cluster.get('avg_node_utilization', 100)
                if node_utilization < 40:
                    autopilot_savings = cluster.get('monthly_cost', 500) * 0.30
                    savings += autopilot_savings
                    self.recommendations.append({
                        'service': 'GKE',
                        'type': 'Cluster Mode',
                        'issue': f'Standard GKE cluster with <40% node utilization',
                        'recommendation': 'Migrate to GKE Autopilot to pay only for pod resources, or enable cluster autoscaler',
                        'potential_savings': autopilot_savings,
                        'priority': 'high'
                    })

        # Cloud Run optimization
        cloud_run_services = self.resources.get('cloud_run_services', [])
        for svc in cloud_run_services:
            if svc.get('min_instances', 0) > 0 and svc.get('avg_rps', 100) < 1:
                min_inst_savings = svc.get('min_instances', 1) * 15
                savings += min_inst_savings
                self.recommendations.append({
                    'service': 'Cloud Run',
                    'type': 'Min Instances',
                    'issue': f'Service {svc.get("name", "unknown")} has min instances but very low traffic',
                    'recommendation': 'Set min-instances to 0 for low-traffic services to enable scale-to-zero',
                    'potential_savings': min_inst_savings,
                    'priority': 'medium'
                })

        return savings

    def _analyze_storage(self) -> float:
        """Analyze Cloud Storage resources."""
        savings = 0.0

        gcs_buckets = self.resources.get('gcs_buckets', [])
        for bucket in gcs_buckets:
            size_gb = bucket.get('size_gb', 0)
            storage_class = bucket.get('storage_class', 'STANDARD')

            if not bucket.get('has_lifecycle_policy', False) and size_gb > 100:
                lifecycle_savings = size_gb * 0.012
                savings += lifecycle_savings
                self.recommendations.append({
                    'service': 'Cloud Storage',
                    'type': 'Lifecycle Policy',
                    'issue': f'Bucket {bucket.get("name", "unknown")} ({size_gb} GB) has no lifecycle policy',
                    'recommendation': 'Add lifecycle rule: Transition to Nearline after 30 days, Coldline after 90 days, Archive after 365 days',
                    'potential_savings': lifecycle_savings,
                    'priority': 'medium'
                })

            if storage_class == 'STANDARD' and size_gb > 500:
                class_savings = size_gb * 0.006
                savings += class_savings
                self.recommendations.append({
                    'service': 'Cloud Storage',
                    'type': 'Storage Class',
                    'issue': f'Large bucket ({size_gb} GB) using Standard class',
                    'recommendation': 'Enable Autoclass for automatic storage class management based on access patterns',
                    'potential_savings': class_savings,
                    'priority': 'high'
                })

        return savings

    def _analyze_database(self) -> float:
        """Analyze Cloud SQL, Firestore, and BigQuery costs."""
        savings = 0.0

        cloud_sql_instances = self.resources.get('cloud_sql_instances', [])
        for db in cloud_sql_instances:
            if db.get('connections_per_day', 1000) < 10:
                db_cost = db.get('monthly_cost', 100)
                savings += db_cost * 0.8
                self.recommendations.append({
                    'service': 'Cloud SQL',
                    'type': 'Idle Resource',
                    'issue': f'Database {db.get("name", "unknown")} has <10 connections/day',
                    'recommendation': 'Stop database if not needed, or take a backup and delete',
                    'potential_savings': db_cost * 0.8,
                    'priority': 'high'
                })

            if db.get('utilization', 100) < 30 and not db.get('has_ha', False):
                rightsize_savings = db.get('monthly_cost', 200) * 0.35
                savings += rightsize_savings
                self.recommendations.append({
                    'service': 'Cloud SQL',
                    'type': 'Right-sizing',
                    'issue': f'Cloud SQL instance {db.get("name", "unknown")} has low utilization (<30%)',
                    'recommendation': 'Downsize to a smaller machine type (e.g., db-custom-2-8192 to db-f1-micro for dev)',
                    'potential_savings': rightsize_savings,
                    'priority': 'medium'
                })

        # BigQuery optimization
        bigquery_datasets = self.resources.get('bigquery_datasets', [])
        for dataset in bigquery_datasets:
            if dataset.get('pricing_model', 'on_demand') == 'on_demand':
                monthly_tb_scanned = dataset.get('monthly_tb_scanned', 0)
                if monthly_tb_scanned > 10:
                    slot_savings = (monthly_tb_scanned * 6.25) * 0.30
                    savings += slot_savings
                    self.recommendations.append({
                        'service': 'BigQuery',
                        'type': 'Pricing Model',
                        'issue': f'Scanning {monthly_tb_scanned} TB/month on on-demand pricing',
                        'recommendation': 'Switch to BigQuery editions with slots for predictable costs (30%+ savings at this volume)',
                        'potential_savings': slot_savings,
                        'priority': 'high'
                    })

            if not dataset.get('has_partitioning', False):
                partition_savings = dataset.get('monthly_query_cost', 50) * 0.50
                savings += partition_savings
                self.recommendations.append({
                    'service': 'BigQuery',
                    'type': 'Table Partitioning',
                    'issue': f'Tables in {dataset.get("name", "unknown")} lack partitioning',
                    'recommendation': 'Partition tables by date and add clustering columns to reduce bytes scanned',
                    'potential_savings': partition_savings,
                    'priority': 'medium'
                })

        return savings

    def _analyze_networking(self) -> float:
        """Analyze networking costs (egress, Cloud NAT, etc.)."""
        savings = 0.0

        cloud_nat_gateways = self.resources.get('cloud_nat_gateways', [])
        if len(cloud_nat_gateways) > 1:
            extra_nats = len(cloud_nat_gateways) - 1
            nat_savings = extra_nats * 45
            savings += nat_savings
            self.recommendations.append({
                'service': 'Cloud NAT',
                'type': 'Resource Consolidation',
                'issue': f'{len(cloud_nat_gateways)} Cloud NAT gateways deployed',
                'recommendation': 'Consolidate NAT gateways in dev/staging, or use Private Google Access for GCP services',
                'potential_savings': nat_savings,
                'priority': 'high'
            })

        egress_gb = self.resources.get('monthly_egress_gb', 0)
        if egress_gb > 1000:
            cdn_savings = egress_gb * 0.04  # CDN is cheaper than direct egress
            savings += cdn_savings
            self.recommendations.append({
                'service': 'Networking',
                'type': 'CDN Optimization',
                'issue': f'High egress volume ({egress_gb} GB/month)',
                'recommendation': 'Enable Cloud CDN to serve cached content at lower egress rates',
                'potential_savings': cdn_savings,
                'priority': 'medium'
            })

        return savings

    def _analyze_general_optimizations(self) -> float:
        """General GCP cost optimizations."""
        savings = 0.0

        # Log retention
        log_sinks = self.resources.get('log_sinks', [])
        if not log_sinks:
            log_volume_gb = self.resources.get('monthly_log_volume_gb', 0)
            if log_volume_gb > 50:
                log_savings = log_volume_gb * 0.50 * 0.6
                savings += log_savings
                self.recommendations.append({
                    'service': 'Cloud Logging',
                    'type': 'Log Exclusion',
                    'issue': f'{log_volume_gb} GB/month of logs without exclusion filters',
                    'recommendation': 'Create log exclusion filters for verbose/debug logs and route remaining to Cloud Storage via log sinks',
                    'potential_savings': log_savings,
                    'priority': 'medium'
                })

        # Unattached persistent disks
        persistent_disks = self.resources.get('persistent_disks', [])
        unattached = sum(1 for disk in persistent_disks if not disk.get('attached', True))
        if unattached > 0:
            disk_savings = unattached * 10  # ~$10/month per 100 GB disk
            savings += disk_savings
            self.recommendations.append({
                'service': 'Compute Engine',
                'type': 'Unused Resources',
                'issue': f'{unattached} unattached persistent disks',
                'recommendation': 'Snapshot and delete unused persistent disks',
                'potential_savings': disk_savings,
                'priority': 'high'
            })

        # Static external IPs
        static_ips = self.resources.get('static_ips', [])
        unused_ips = sum(1 for ip in static_ips if not ip.get('in_use', True))
        if unused_ips > 0:
            ip_savings = unused_ips * 7.30  # $0.01/hour = $7.30/month
            savings += ip_savings
            self.recommendations.append({
                'service': 'Networking',
                'type': 'Unused Resources',
                'issue': f'{unused_ips} unused static external IP addresses',
                'recommendation': 'Release unused static IPs to avoid hourly charges',
                'potential_savings': ip_savings,
                'priority': 'high'
            })

        # Budget alerts
        if not self.resources.get('has_budget_alerts', False):
            self.recommendations.append({
                'service': 'Cloud Billing',
                'type': 'Cost Monitoring',
                'issue': 'No budget alerts configured',
                'recommendation': 'Set up Cloud Billing budgets with alerts at 50%, 80%, 100% of monthly budget',
                'potential_savings': 0,
                'priority': 'high'
            })

        # Recommender API
        if not self.resources.get('uses_recommender', False):
            self.recommendations.append({
                'service': 'Active Assist',
                'type': 'Visibility',
                'issue': 'GCP Recommender not reviewed',
                'recommendation': 'Review Active Assist recommendations for right-sizing, idle resources, and committed use discounts',
                'potential_savings': 0,
                'priority': 'medium'
            })

        return savings

    def _prioritize_recommendations(self) -> List[Dict[str, Any]]:
        """Get top priority recommendations."""
        high_priority = [r for r in self.recommendations if r['priority'] == 'high']
        high_priority.sort(key=lambda x: x.get('potential_savings', 0), reverse=True)
        return high_priority[:5]

    def generate_optimization_checklist(self) -> List[Dict[str, Any]]:
        """Generate actionable checklist for cost optimization."""
        return [
            {
                'category': 'Immediate Actions (Today)',
                'items': [
                    'Release unused static IPs',
                    'Delete unattached persistent disks',
                    'Stop idle Compute Engine instances',
                    'Set up billing budget alerts'
                ]
            },
            {
                'category': 'This Week',
                'items': [
                    'Add Cloud Storage lifecycle policies',
                    'Create log exclusion filters for verbose logs',
                    'Right-size Cloud SQL instances',
                    'Review Active Assist recommendations'
                ]
            },
            {
                'category': 'This Month',
                'items': [
                    'Evaluate committed use discounts',
                    'Migrate GKE Standard to Autopilot where applicable',
                    'Partition and cluster BigQuery tables',
                    'Enable Cloud CDN for high-egress services'
                ]
            },
            {
                'category': 'Ongoing',
                'items': [
                    'Review billing reports weekly',
                    'Label all resources for cost allocation',
                    'Monitor Active Assist recommendations monthly',
                    'Conduct quarterly cost optimization reviews'
                ]
            }
        ]


def main():
    parser = argparse.ArgumentParser(
        description='GCP Cost Optimizer - Analyzes GCP resources and recommends cost savings'
    )
    parser.add_argument(
        '--resources', '-r',
        type=str,
        help='Path to JSON file with current GCP resource inventory'
    )
    parser.add_argument(
        '--monthly-spend', '-s',
        type=float,
        default=1000,
        help='Current monthly GCP spend in USD (default: 1000)'
    )
    parser.add_argument(
        '--output', '-o',
        type=str,
        help='Path to write optimization report JSON'
    )
    parser.add_argument(
        '--json',
        action='store_true',
        help='Output as JSON format'
    )
    parser.add_argument(
        '--checklist',
        action='store_true',
        help='Generate optimization checklist'
    )

    args = parser.parse_args()

    if args.resources:
        try:
            with open(args.resources, 'r') as f:
                resources = json.load(f)
        except FileNotFoundError:
            print(f"Error: File '{args.resources}' not found.", file=sys.stderr)
            sys.exit(1)
        except json.JSONDecodeError:
            print(f"Error: File '{args.resources}' is not valid JSON.", file=sys.stderr)
            sys.exit(1)
    else:
        resources = {}

    optimizer = CostOptimizer(resources, args.monthly_spend)
    result = optimizer.analyze_and_optimize()

    if args.checklist:
        result['checklist'] = optimizer.generate_optimization_checklist()

    if args.output:
        with open(args.output, 'w') as f:
            json.dump(result, f, indent=2)
        print(f"Report written to {args.output}")
    elif args.json:
        print(json.dumps(result, indent=2))
    else:
        print(f"\nGCP Cost Optimization Report")
        print(f"{'=' * 40}")
        print(f"Current Monthly Spend: ${result['current_monthly_spend']:.2f}")
        print(f"Potential Savings:     ${result['potential_monthly_savings']:.2f}")
        print(f"Optimized Spend:       ${result['optimized_monthly_spend']:.2f}")
        print(f"Savings Percentage:    {result['savings_percentage']}%")
        print(f"\nTop Priority Actions:")
        for i, action in enumerate(result['priority_actions'], 1):
            print(f"  {i}. [{action['service']}] {action['recommendation']}")
            print(f"     Savings: ${action['potential_savings']:.2f}/month")
        print(f"\nTotal Recommendations: {len(result['recommendations'])}")


if __name__ == '__main__':
    main()