#!/usr/bin/env python3
"""
Deployment prerequisites checker for Malaysian SME SaaS platform.
Validates that all prerequisites are met before deployment.
"""

import json
import os
import sys
import subprocess
import yaml
import argparse
from typing import Dict, List, Any, Optional
from pathlib import Path

class PrerequisiteChecker:
    """Comprehensive deployment prerequisite checker."""

    def __init__(self, environment: str):
        self.environment = environment
        self.errors = []
        self.warnings = []
        self.checks_passed = 0
        self.checks_failed = 0
        self.checks_total = 0

    def check_all(self) -> Dict[str, Any]:
        """Run all prerequisite checks."""
        print(f"🔍 Checking deployment prerequisites for {self.environment} environment...")
        print("=" * 60)

        # Environment and configuration checks
        self._check_environment_variables()
        self._check_configuration_files()
        self._check_database_connectivity()
        self._check_redis_connectivity()

        # Build and deployment checks
        self._check_docker_availability()
        self._check_docker_compose_availability()
        self._check_required_images()
        self._check_disk_space()

        # Security checks
        self._check_ssl_certificates()
        self._check_firewall_configuration()
        self._check_backup_availability()

        # Application-specific checks
        self._check_python_dependencies()
        self._check_node_dependencies()
        self._check_migrations_pending()
        self._check_static_files()

        # Performance and monitoring
        self._check_monitoring_tools()
        self._check_logging_configuration()
        self._check_resource_limits()

        # Generate report
        return self._generate_report()

    def _check_environment_variables(self) -> None:
        """Check required environment variables."""
        print("\n📋 Checking environment variables...")
        required_vars = {
            'production': [
                'SECRET_KEY',
                'DATABASE_URL',
                'REDIS_URL',
                'ALLOWED_HOSTS',
                'CSRF_TRUSTED_ORIGINS',
                'SENTRY_DSN',
                'ROLLBAR_ACCESS_TOKEN',
                'AWS_ACCESS_KEY_ID',
                'AWS_SECRET_ACCESS_KEY',
                'AWS_S3_BUCKET',
                'SSL_CERT_PATH',
                'SSL_KEY_PATH',
            ],
            'staging': [
                'SECRET_KEY',
                'DATABASE_URL',
                'REDIS_URL',
                'ALLOWED_HOSTS',
                'SENTRY_DSN',
                'AWS_ACCESS_KEY_ID',
                'AWS_SECRET_ACCESS_KEY',
                'AWS_S3_BUCKET',
            ]
        }

        required = required_vars.get(self.environment, [])
        self.checks_total += len(required)

        missing_vars = []
        for var in required:
            if not os.getenv(var):
                missing_vars.append(var)
                self.errors.append(f"Missing required environment variable: {var}")
            else:
                self.checks_passed += 1

        if missing_vars:
            self.checks_failed += len(missing_vars)
            print(f"❌ Missing environment variables: {', '.join(missing_vars)}")
        else:
            print("✅ All required environment variables are set")

        # Check sensitive variables
        sensitive_vars = ['SECRET_KEY', 'DATABASE_PASSWORD', 'REDIS_PASSWORD']
        for var in sensitive_vars:
            value = os.getenv(var)
            if value and len(value) < 32:
                self.warnings.append(f"Sensitive variable {var} appears to be weak (length < 32)")

    def _check_configuration_files(self) -> None:
        """Check required configuration files."""
        print("\n📄 Checking configuration files...")
        required_files = [
            'docker-compose.prod.yml',
            'docker-compose.staging.yml',
            'nginx.prod.conf',
            '.env',
            'backend/.env',
            'frontend/.env',
            'backend/settings/production.py',
            'backend/settings/staging.py',
        ]

        self.checks_total += len(required_files)

        missing_files = []
        for file_path in required_files:
            if not Path(file_path).exists():
                missing_files.append(file_path)
                self.errors.append(f"Missing configuration file: {file_path}")
            else:
                self.checks_passed += 1

        if missing_files:
            self.checks_failed += len(missing_files)
            print(f"❌ Missing configuration files: {', '.join(missing_files)}")
        else:
            print("✅ All required configuration files exist")

        # Validate configuration file syntax
        self._validate_yaml_files()
        self._validate_env_files()

    def _validate_yaml_files(self) -> None:
        """Validate YAML configuration files."""
        yaml_files = [
            'docker-compose.prod.yml',
            'docker-compose.staging.yml',
        ]

        for yaml_file in yaml_files:
            if Path(yaml_file).exists():
                try:
                    with open(yaml_file, 'r') as f:
                        yaml.safe_load(f)
                    self.checks_passed += 1
                    print(f"✅ {yaml_file} is valid YAML")
                except yaml.YAMLError as e:
                    self.errors.append(f"Invalid YAML in {yaml_file}: {e}")
                    self.checks_failed += 1
                    print(f"❌ {yaml_file} has invalid YAML syntax")

        self.checks_total += len(yaml_files)

    def _validate_env_files(self) -> None:
        """Validate environment file syntax."""
        env_files = [
            '.env',
            'backend/.env',
            'frontend/.env',
        ]

        for env_file in env_files:
            if Path(env_file).exists():
                try:
                    with open(env_file, 'r') as f:
                        for line_num, line in enumerate(f, 1):
                            line = line.strip()
                            if line and not line.startswith('#'):
                                if '=' not in line:
                                    raise ValueError(f"Invalid format at line {line_num}")
                    self.checks_passed += 1
                    print(f"✅ {env_file} is valid")
                except Exception as e:
                    self.errors.append(f"Invalid format in {env_file}: {e}")
                    self.checks_failed += 1
                    print(f"❌ {env_file} has invalid format")

        self.checks_total += len(env_files)

    def _check_database_connectivity(self) -> None:
        """Check database connectivity."""
        print("\n🗄️ Checking database connectivity...")
        self.checks_total += 1

        try:
            import psycopg2
            from urllib.parse import urlparse

            db_url = os.getenv('DATABASE_URL')
            if not db_url:
                self.errors.append("DATABASE_URL environment variable not set")
                self.checks_failed += 1
                print("❌ DATABASE_URL not configured")
                return

            parsed = urlparse(db_url)
            conn = psycopg2.connect(
                host=parsed.hostname,
                port=parsed.port or 5432,
                database=parsed.path[1:],
                user=parsed.username,
                password=parsed.password,
                connect_timeout=10
            )

            # Check database version
            with conn.cursor() as cursor:
                cursor.execute("SELECT version()")
                version = cursor.fetchone()[0]
                print(f"✅ Database connected: PostgreSQL {version}")

            # Check database size
            with conn.cursor() as cursor:
                cursor.execute("SELECT pg_size_pretty(pg_database_size(current_database()))")
                size = cursor.fetchone()[0]
                print(f"📊 Database size: {size}")

            conn.close()
            self.checks_passed += 1

        except ImportError:
            self.warnings.append("psycopg2 not available - skipping database check")
            print("⚠️  psycopg2 not available - skipping database check")
        except Exception as e:
            self.errors.append(f"Database connectivity failed: {e}")
            self.checks_failed += 1
            print(f"❌ Database connectivity failed: {e}")

    def _check_redis_connectivity(self) -> None:
        """Check Redis connectivity."""
        print("\n🔴 Checking Redis connectivity...")
        self.checks_total += 1

        try:
            import redis
            from urllib.parse import urlparse

            redis_url = os.getenv('REDIS_URL')
            if not redis_url:
                self.errors.append("REDIS_URL environment variable not set")
                self.checks_failed += 1
                print("❌ REDIS_URL not configured")
                return

            parsed = urlparse(redis_url)
            r = redis.Redis(
                host=parsed.hostname,
                port=parsed.port or 6379,
                password=parsed.password,
                socket_timeout=10
            )

            # Test Redis connection
            info = r.info()
            print(f"✅ Redis connected: version {info.get('redis_version', 'unknown')}")

            # Check memory usage
            used_memory = info.get('used_memory_human', 'unknown')
            print(f"📊 Redis memory usage: {used_memory}")

            r.close()
            self.checks_passed += 1

        except ImportError:
            self.warnings.append("redis not available - skipping Redis check")
            print("⚠️  redis not available - skipping Redis check")
        except Exception as e:
            self.errors.append(f"Redis connectivity failed: {e}")
            self.checks_failed += 1
            print(f"❌ Redis connectivity failed: {e}")

    def _check_docker_availability(self) -> None:
        """Check Docker availability."""
        print("\n🐳 Checking Docker availability...")
        self.checks_total += 1

        try:
            result = subprocess.run(['docker', '--version'], capture_output=True, text=True)
            if result.returncode == 0:
                version = result.stdout.strip()
                print(f"✅ Docker available: {version}")
                self.checks_passed += 1

                # Check Docker daemon
                try:
                    subprocess.run(['docker', 'info'], capture_output=True, timeout=10)
                    print("✅ Docker daemon is running")
                except subprocess.TimeoutExpired:
                    self.warnings.append("Docker daemon response time is slow")
                except Exception as e:
                    self.errors.append(f"Docker daemon not running: {e}")
                    self.checks_failed += 1
                    return
            else:
                self.errors.append(f"Docker not available: {result.stderr}")
                self.checks_failed += 1
                print("❌ Docker not available")
        except FileNotFoundError:
            self.errors.append("Docker not found in PATH")
            self.checks_failed += 1
            print("❌ Docker not found in PATH")
        except Exception as e:
            self.errors.append(f"Docker check failed: {e}")
            self.checks_failed += 1
            print(f"❌ Docker check failed: {e}")

    def _check_docker_compose_availability(self) -> None:
        """Check Docker Compose availability."""
        print("\n🐳 Checking Docker Compose availability...")
        self.checks_total += 1

        # Try docker-compose first, then docker compose
        compose_cmd = None
        for cmd in ['docker-compose', 'docker compose']:
            try:
                result = subprocess.run([cmd, '--version'], capture_output=True, text=True)
                if result.returncode == 0:
                    compose_cmd = cmd
                    version = result.stdout.strip()
                    print(f"✅ Docker Compose available: {version}")
                    self.checks_passed += 1
                    break
            except (FileNotFoundError, subprocess.SubprocessError):
                continue

        if not compose_cmd:
            self.errors.append("Docker Compose not available")
            self.checks_failed += 1
            print("❌ Docker Compose not available")

    def _check_required_images(self) -> None:
        """Check required Docker images."""
        print("\n📦 Checking required Docker images...")
        required_images = [
            'postgres:15',
            'redis:7-alpine',
            'nginx:alpine',
        ]

        self.checks_total += len(required_images)

        for image in required_images:
            try:
                result = subprocess.run(['docker', 'images', '-q', image], capture_output=True, text=True)
                if result.stdout.strip():
                    print(f"✅ {image} is available locally")
                    self.checks_passed += 1
                else:
                    print(f"⚠️  {image} not available locally (will be pulled during deployment)")
                    self.warnings.append(f"Docker image {image} not available locally")
            except Exception as e:
                self.errors.append(f"Failed to check image {image}: {e}")
                self.checks_failed += 1
                print(f"❌ Failed to check image {image}")

    def _check_disk_space(self) -> None:
        """Check available disk space."""
        print("\n💾 Checking disk space...")
        self.checks_total += 1

        try:
            result = subprocess.run(['df', '-h', '/'], capture_output=True, text=True)
            if result.returncode == 0:
                lines = result.stdout.strip().split('\n')
                if len(lines) > 1:
                    parts = lines[1].split()
                    if len(parts) >= 5:
                        usage_percent = parts[4].replace('%', '')
                        available = parts[3]
                        print(f"📊 Disk usage: {usage_percent}%, Available: {available}")

                        if int(usage_percent) > 80:
                            self.warnings.append(f"Disk usage is high: {usage_percent}%")
                        elif int(usage_percent) > 90:
                            self.errors.append(f"Disk usage is critical: {usage_percent}%")
                            self.checks_failed += 1
                            return

                self.checks_passed += 1
            else:
                self.errors.append(f"Failed to check disk space: {result.stderr}")
                self.checks_failed += 1
        except Exception as e:
            self.errors.append(f"Disk space check failed: {e}")
            self.checks_failed += 1

    def _check_ssl_certificates(self) -> None:
        """Check SSL certificates."""
        print("\n🔒 Checking SSL certificates...")
        cert_path = os.getenv('SSL_CERT_PATH')
        key_path = os.getenv('SSL_KEY_PATH')

        if cert_path and key_path:
            self.checks_total += 2

            if Path(cert_path).exists():
                print(f"✅ SSL certificate found: {cert_path}")
                self.checks_passed += 1
            else:
                self.errors.append(f"SSL certificate not found: {cert_path}")
                self.checks_failed += 1

            if Path(key_path).exists():
                print(f"✅ SSL key found: {key_path}")
                self.checks_passed += 1
            else:
                self.errors.append(f"SSL key not found: {key_path}")
                self.checks_failed += 1
        else:
            self.warnings.append("SSL certificate paths not configured")
            print("⚠️  SSL certificate paths not configured")

    def _check_firewall_configuration(self) -> None:
        """Check firewall configuration."""
        print("\n🛡️ Checking firewall configuration...")
        self.checks_total += 1

        required_ports = [80, 443, 5432, 6379]
        open_ports = []

        try:
            # Check if ufw is available
            result = subprocess.run(['ufw', 'status'], capture_output=True, text=True)
            if result.returncode == 0:
                if 'Status: active' in result.stdout:
                    print("✅ UFW firewall is active")
                    self.checks_passed += 1
                else:
                    self.warnings.append("UFW firewall is not active")
                    print("⚠️  UFW firewall is not active")
            else:
                # Try checking iptables
                result = subprocess.run(['iptables', '-L'], capture_output=True, text=True)
                if result.returncode == 0:
                    print("✅ iptables is available")
                    self.checks_passed += 1
                else:
                    self.warnings.append("Could not verify firewall configuration")
                    print("⚠️  Could not verify firewall configuration")
        except FileNotFoundError:
            self.warnings.append("Firewall management tools not found")
            print("⚠️  Firewall management tools not found")
        except Exception as e:
            self.errors.append(f"Firewall check failed: {e}")
            self.checks_failed += 1

    def _check_backup_availability(self) -> None:
        """Check backup availability."""
        print("\n💾 Checking backup availability...")
        self.checks_total += 1

        backup_dir = Path('./backups')
        if backup_dir.exists():
            backup_files = list(backup_dir.glob('*.sql'))
            if backup_files:
                latest_backup = max(backup_files, key=lambda x: x.stat().st_mtime)
                print(f"✅ Found {len(backup_files)} backup files")
                print(f"📄 Latest backup: {latest_backup.name}")
                self.checks_passed += 1
            else:
                self.warnings.append("No backup files found")
                print("⚠️  No backup files found")
        else:
            self.warnings.append("Backup directory not found")
            print("⚠️  Backup directory not found")

    def _check_python_dependencies(self) -> None:
        """Check Python dependencies."""
        print("\n🐍 Checking Python dependencies...")
        self.checks_total += 1

        requirements_files = [
            'requirements.txt',
            'requirements-dev.txt',
        ]

        missing_files = []
        for req_file in requirements_files:
            if not Path(req_file).exists():
                missing_files.append(req_file)

        if missing_files:
            self.errors.append(f"Missing requirements files: {', '.join(missing_files)}")
            self.checks_failed += 1
            print(f"❌ Missing requirements files: {', '.join(missing_files)}")
        else:
            print("✅ All Python requirements files exist")
            self.checks_passed += 1

    def _check_node_dependencies(self) -> None:
        """Check Node.js dependencies."""
        print("\n📦 Checking Node.js dependencies...")
        self.checks_total += 1

        if Path('frontend/package.json').exists():
            if Path('frontend/package-lock.json').exists():
                print("✅ Node.js dependencies are locked")
                self.checks_passed += 1
            else:
                self.warnings.append("package-lock.json not found")
                print("⚠️  package-lock.json not found")
        else:
            self.warnings.append("Frontend package.json not found")
            print("⚠️  Frontend package.json not found")

    def _check_migrations_pending(self) -> None:
        """Check for pending database migrations."""
        print("\n🔄 Checking for pending migrations...")
        self.checks_total += 1

        try:
            result = subprocess.run([
                'python', 'backend/manage.py', 'showmigrations', '--plan'
            ], capture_output=True, text=True)

            if result.returncode == 0:
                migrations = [line for line in result.stdout.split('\n') if '[ ]' in line]
                if migrations:
                    print(f"⚠️  Found {len(migrations)} pending migrations")
                    self.warnings.append(f"Found {len(migrations)} pending database migrations")
                else:
                    print("✅ No pending migrations")
                    self.checks_passed += 1
            else:
                self.errors.append(f"Failed to check migrations: {result.stderr}")
                self.checks_failed += 1
        except Exception as e:
            self.errors.append(f"Migration check failed: {e}")
            self.checks_failed += 1

    def _check_static_files(self) -> None:
        """Check static files configuration."""
        print("\n📄 Checking static files...")
        self.checks_total += 1

        static_dirs = [
            'backend/static',
            'frontend/build/static',
        ]

        existing_dirs = []
        for static_dir in static_dirs:
            if Path(static_dir).exists():
                existing_dirs.append(static_dir)

        if existing_dirs:
            print(f"✅ Found static directories: {', '.join(existing_dirs)}")
            self.checks_passed += 1
        else:
            self.warnings.append("No static directories found")
            print("⚠️  No static directories found")

    def _check_monitoring_tools(self) -> None:
        """Check monitoring tools configuration."""
        print("\n📊 Checking monitoring tools...")
        self.checks_total += 3

        # Check Prometheus
        prometheus_config = Path('./monitoring/prometheus.yml')
        if prometheus_config.exists():
            print("✅ Prometheus configuration found")
            self.checks_passed += 1
        else:
            self.warnings.append("Prometheus configuration not found")
            print("⚠️  Prometheus configuration not found")

        # Check Grafana
        grafana_dir = Path('./monitoring/grafana')
        if grafana_dir.exists():
            print("✅ Grafana configuration found")
            self.checks_passed += 1
        else:
            self.warnings.append("Grafana configuration not found")
            print("⚠️  Grafana configuration not found")

        # Check logging configuration
        log_config = Path('./monitoring/logstash/pipeline')
        if log_config.exists():
            print("✅ Logging configuration found")
            self.checks_passed += 1
        else:
            self.warnings.append("Logging configuration not found")
            print("⚠️  Logging configuration not found")

    def _check_logging_configuration(self) -> None:
        """Check logging configuration."""
        print("\n📝 Checking logging configuration...")
        self.checks_total += 1

        log_dir = Path('./logs')
        if not log_dir.exists():
            try:
                log_dir.mkdir(parents=True)
                print("✅ Created logs directory")
                self.checks_passed += 1
            except Exception as e:
                self.errors.append(f"Failed to create logs directory: {e}")
                self.checks_failed += 1
        else:
            print("✅ Logs directory exists")
            self.checks_passed += 1

    def _check_resource_limits(self) -> None:
        """Check system resource limits."""
        print("\n⚡ Checking system resource limits...")
        self.checks_total += 2

        # Check file descriptor limit
        try:
            import resource
            fd_limit = resource.getrlimit(resource.RLIMIT_NOFILE)[0]
            print(f"📊 File descriptor limit: {fd_limit}")

            if fd_limit < 65536:
                self.warnings.append(f"File descriptor limit is low: {fd_limit}")
            else:
                self.checks_passed += 1
        except ImportError:
            self.warnings.append("resource module not available - skipping file descriptor check")
            print("⚠️  resource module not available - skipping file descriptor check")

        # Check memory limits
        try:
            with open('/proc/meminfo', 'r') as f:
                meminfo = f.read()
                total_mem = None
                for line in meminfo.split('\n'):
                    if 'MemTotal:' in line:
                        total_mem = int(line.split()[1])
                        break

                if total_mem:
                    total_mem_gb = total_mem / 1024 / 1024
                    print(f"📊 Total memory: {total_mem_gb:.1f} GB")

                    if total_mem_gb < 4:
                        self.warnings.append(f"Available memory is low: {total_mem_gb:.1f} GB")
                    else:
                        self.checks_passed += 1
        except FileNotFoundError:
            self.warnings.append("Could not read memory information")
            print("⚠️  Could not read memory information")

    def _generate_report(self) -> Dict[str, Any]:
        """Generate comprehensive report."""
        print("\n" + "=" * 60)
        print("📋 DEPLOYMENT PREREQUISITES REPORT")
        print("=" * 60)

        # Summary statistics
        total_checks = self.checks_passed + self.checks_failed
        success_rate = (self.checks_passed / total_checks * 100) if total_checks > 0 else 0

        print(f"\n📊 Summary:")
        print(f"✅ Passed: {self.checks_passed}/{total_checks} ({success_rate:.1f}%)")
        print(f"❌ Failed: {self.checks_failed}")
        print(f"⚠️  Warnings: {len(self.warnings)}")

        # Detailed errors
        if self.errors:
            print(f"\n❌ Errors ({len(self.errors)}):")
            for i, error in enumerate(self.errors, 1):
                print(f"  {i}. {error}")

        # Warnings
        if self.warnings:
            print(f"\n⚠️  Warnings ({len(self.warnings)}):")
            for i, warning in enumerate(self.warnings, 1):
                print(f"  {i}. {warning}")

        # Overall assessment
        print(f"\n🎯 Overall Assessment:")
        if self.checks_failed == 0:
            if success_rate >= 90:
                print("✅ Ready for deployment")
                deployment_ready = True
            else:
                print("⚠️  Mostly ready - consider addressing warnings")
                deployment_ready = True
        else:
            print("❌ Not ready for deployment - fix errors first")
            deployment_ready = False

        # Generate report data
        report = {
            'environment': self.environment,
            'timestamp': str(datetime.now()),
            'summary': {
                'total_checks': total_checks,
                'passed': self.checks_passed,
                'failed': self.checks_failed,
                'warnings': len(self.warnings),
                'success_rate': success_rate,
            },
            'deployment_ready': deployment_ready,
            'errors': self.errors,
            'warnings': self.warnings,
        }

        # Save report to file
        report_file = f'deployment-prerequisites-{self.environment}-{datetime.now().strftime("%Y%m%d-%H%M%S")}.json'
        with open(report_file, 'w') as f:
            json.dump(report, f, indent=2)

        print(f"\n📄 Report saved to: {report_file}")

        return report


def main():
    """Main function."""
    parser = argparse.ArgumentParser(description='Check deployment prerequisites')
    parser.add_argument('--environment', '-e', required=True, choices=['staging', 'production'],
                       help='Target environment')
    parser.add_argument('--output', '-o', help='Output file for report')
    parser.add_argument('--quiet', '-q', action='store_true', help='Quiet mode')

    args = parser.parse_args()

    if not args.quiet:
        print("🚀 Malaysian SME SaaS Platform - Deployment Prerequisites Checker")
        print("=" * 70)

    checker = PrerequisiteChecker(args.environment)
    report = checker.check_all()

    if args.output:
        with open(args.output, 'w') as f:
            json.dump(report, f, indent=2)

    # Exit with appropriate code
    sys.exit(0 if report['deployment_ready'] else 1)


if __name__ == '__main__':
    from datetime import datetime
    main()