"""Application factory."""
import os
import logging
from flask import Flask
from config import get_config
from app.extensions import db, migrate, bcrypt, cors, ma, limiter, session
from app.middleware import RequestIDMiddleware, SecurityHeadersMiddleware, setup_cors
from app.exceptions.base import BaseAPIException
from app.utils.response import api_response
import redis


def create_app(config_name=None):
    """
    Create and configure the Flask application.

    Args:
        config_name: Configuration name (development, testing, production)

    Returns:
        Flask application instance
    """
    app = Flask(__name__)

    # Load configuration
    config = get_config(config_name)
    app.config.from_object(config)

    # Initialize extensions
    initialize_extensions(app)

    # Setup middleware
    setup_middleware(app)

    # Register blueprints
    register_blueprints(app)

    # Register error handlers
    register_error_handlers(app)

    # Setup logging
    setup_logging(app)

    return app


def initialize_extensions(app):
    """Initialize Flask extensions."""
    # Database
    db.init_app(app)
    migrate.init_app(app, db)

    # Security
    bcrypt.init_app(app)

    # CORS
    cors.init_app(
        app,
        origins=app.config.get("CORS_ORIGINS", []),
        supports_credentials=app.config.get("CORS_SUPPORTS_CREDENTIALS", True),
    )

    # Marshmallow
    ma.init_app(app)

    # Rate limiting
    if app.config.get("RATELIMIT_ENABLED"):
        limiter.init_app(app)

    # Redis for sessions
    try:
        redis_url = app.config.get("REDIS_URL")
        if redis_url:
            redis_client = redis.from_url(redis_url)
            app.config["SESSION_REDIS"] = redis_client
    except Exception as e:
        app.logger.warning(f"Redis connection failed: {e}")

    # Flask-Session
    session.init_app(app)


def setup_middleware(app):
    """Setup application middleware."""
    RequestIDMiddleware(app)
    SecurityHeadersMiddleware(app)
    setup_cors(app, cors)


def register_blueprints(app):
    """Register application blueprints."""
    from app.api import register_api_blueprints

    register_api_blueprints(app)


def register_error_handlers(app):
    """Register error handlers."""

    @app.errorhandler(BaseAPIException)
    def handle_api_exception(error):
        """Handle custom API exceptions."""
        return api_response(
            success=False,
            message=error.message,
            status=error.status_code,
            error_type=error.error_type,
            error_details=error.error_details,
        )

    @app.errorhandler(404)
    def handle_not_found(error):
        """Handle 404 errors."""
        return api_response(
            success=False,
            message="Resource not found",
            status=404,
            error_type="NOT_FOUND",
        )

    @app.errorhandler(405)
    def handle_method_not_allowed(error):
        """Handle 405 errors."""
        return api_response(
            success=False,
            message="Method not allowed",
            status=405,
            error_type="METHOD_NOT_ALLOWED",
        )

    @app.errorhandler(500)
    def handle_internal_error(error):
        """Handle 500 errors."""
        app.logger.error(f"Internal server error: {error}")
        return api_response(
            success=False,
            message="Internal server error",
            status=500,
            error_type="INTERNAL_ERROR",
        )

    @app.errorhandler(Exception)
    def handle_unexpected_error(error):
        """Handle unexpected errors."""
        app.logger.error(f"Unexpected error: {error}", exc_info=True)
        return api_response(
            success=False,
            message="An unexpected error occurred",
            status=500,
            error_type="INTERNAL_ERROR",
        )


def setup_logging(app):
    """Setup application logging."""
    log_level = getattr(logging, app.config.get("LOG_LEVEL", "INFO"))

    # Create formatter
    formatter = logging.Formatter(
        "[%(asctime)s] %(levelname)s in %(module)s: %(message)s"
    )

    # Configure root logger
    if app.config.get("LOG_TO_STDOUT"):
        stream_handler = logging.StreamHandler()
        stream_handler.setFormatter(formatter)
        stream_handler.setLevel(log_level)
        app.logger.addHandler(stream_handler)

    app.logger.setLevel(log_level)

    # Reduce SQLAlchemy logging noise
    logging.getLogger('sqlalchemy').setLevel(logging.WARNING)

    app.logger.info("Application startup")