import sys

from app.config import settings
from common_logging import get_logger

logger = get_logger(__name__)


class EnvironmentValidator:

    def __init__(self):
        self.errors: list[str] = []
        self.warnings: list[str] = []

    def validate_required_vars(self) -> None:
        required_vars = {"SECRET_KEY": settings.SECRET_KEY, "DATABASE_URL": settings.DATABASE_URL}
        for var_name, var_value in required_vars.items():
            if not var_value or var_value == f"your-{var_name.lower()}-change-this-in-production":
                self.errors.append(f"❌ {var_name} is not set or using default value")

    def validate_production_settings(self) -> None:
        if settings.ENVIRONMENT == "production":
            if "change-this" in settings.SECRET_KEY.lower():
                self.errors.append("❌ SECRET_KEY must be changed in production")
            if settings.DEV_MODE:
                self.warnings.append("⚠️  DEV_MODE should be disabled in production")
            if "sqlite" in settings.DATABASE_URL.lower():
                self.errors.append("❌ SQLite should not be used in production")

    def validate_database_connection(self) -> None:
        if not settings.DATABASE_URL:
            self.errors.append("❌ DATABASE_URL is not configured")
        elif "postgresql" not in settings.DATABASE_URL.lower():
            self.warnings.append("⚠️  Using non-PostgreSQL database")

    def validate_api_keys(self) -> None:
        if not settings.OPENAI_API_KEY:
            self.warnings.append("⚠️  OPENAI_API_KEY is not set")

    def validate_rate_limiting(self) -> None:
        if settings.RATE_LIMIT_ENABLED:
            if settings.RATE_LIMIT_PER_MINUTE <= 0:
                self.errors.append("❌ RATE_LIMIT_PER_MINUTE must be positive")
            if settings.RATE_LIMIT_PER_HOUR <= 0:
                self.errors.append("❌ RATE_LIMIT_PER_HOUR must be positive")

    def run_all_validations(self) -> tuple[list[str], list[str]]:
        self.validate_required_vars()
        self.validate_production_settings()
        self.validate_database_connection()
        self.validate_api_keys()
        self.validate_rate_limiting()
        return (self.errors, self.warnings)


def validate_environment() -> None:
    validator = EnvironmentValidator()
    errors, warnings = validator.run_all_validations()
    for warning in warnings:
        logger.warning(warning)
    if errors:
        for error in errors:
            logger.error(error)
        logger.error("Environment validation failed")
        raise RuntimeError("Environment validation failed. Please check configuration.")
    logger.info("Environment validation passed")


def print_environment_info() -> None:
    logger.info("=" * 50)
    logger.info("Environment Configuration")
    logger.info("=" * 50)
    logger.info(f"Environment: {settings.ENVIRONMENT}")
    logger.info(f"Project Name: {settings.PROJECT_NAME}")
    logger.info(f"API Version: {settings.API_V1_STR}")
    logger.info(
        f"Database: {(settings.DATABASE_URL.split('@')[-1] if '@' in settings.DATABASE_URL else 'Not configured')}"
    )
    logger.info(f"Rate Limiting: {('Enabled' if settings.RATE_LIMIT_ENABLED else 'Disabled')}")
    if settings.RATE_LIMIT_ENABLED:
        logger.info(f"  - Per Minute: {settings.RATE_LIMIT_PER_MINUTE}")
        logger.info(f"  - Per Hour: {settings.RATE_LIMIT_PER_HOUR}")
    logger.info(f"Dev Mode: {settings.DEV_MODE}")
    logger.info(f"Frontend URL: {settings.FRONTEND_URL}")
    logger.info("=" * 50)


if __name__ == "__main__":
    try:
        validate_environment()
        print_environment_info()
        logger.info("✅ Environment validation passed")
        sys.exit(0)
    except Exception as e:
        logger.error(f"❌ Environment validation failed: {e}")
        sys.exit(1)