import os
import uuid
from datetime import datetime

from flask import Flask, g, request
from flask_cors import CORS

from app.middleware.error_handler import setup_error_handling
from app.services.cache_service import CacheService
from app.utils.helpers import (
    get_logger,
    log_exception,
    log_request_info,
    log_response_info,
    setup_logger,
)
from .config.settings import config


def create_app(config_name=None):
    app = Flask(__name__)
    app.json.sort_keys = False

    # Load configuration
    config_name = config_name or os.environ.get("FLASK_ENV", "default")
    app.config.from_object(config[config_name])

    # Configure CORS with settings from config
    cors_config = {
        "origins": app.config.get("CORS_ORIGINS", ["*"]),
        "methods": app.config.get(
            "CORS_METHODS", ["GET", "POST", "PUT", "DELETE", "OPTIONS"]
        ),
        "allow_headers": app.config.get(
            "CORS_ALLOW_HEADERS", ["Content-Type", "Authorization"]
        ),
        "supports_credentials": app.config.get("CORS_SUPPORTS_CREDENTIALS", False),
        "max_age": app.config.get("CORS_MAX_AGE", 600),
        "automatic_options": True,
    }
    print(app.config)
    # Initialize CORS
    CORS(app, **cors_config)

    # Initialize caching
    CacheService.init_app(app)

    # Enable compression for better performance
    try:
        from flask_compress import Compress

        # Compress(app)
        logger = get_logger("app")
        logger.info("Response compression enabled")
    except ImportError:
        pass  # Skip if flask-compress not installed

    # Initialize logging first
    setup_logger(app)
    logger = get_logger("app")

    # Setup Pydantic validation error handling
    setup_error_handling(app)

    # Setup pandoc location
    os.environ.setdefault("PYPANDOC_PANDOC", app.config.get("PANDOC_LOCATION", "/usr/bin/pandoc"))

    # Request middleware for logging and request tracking
    @app.before_request
    def before_request():
        """This helps Flask correctly interpret HTTPS requests from Cloudflare proxied traffic."""
        if request.is_secure:
            pass  # OK
        else:
            # Flask sometimes doesn't detect HTTPS through Cloudflare; fix it manually
            if request.headers.get("X-Forwarded-Proto", "") == "https":
                request.environ["wsgi.url_scheme"] = "https"

        # Generate unique request ID for tracking
        g.request_id = str(uuid.uuid4())
        g.start_time = datetime.now()

        # Log incoming request
        log_request_info()

    @app.after_request
    def after_request(response):
        # Log response
        log_response_info(response)
        response.headers.pop("Content-Encoding", None)

        # Log request duration
        if hasattr(g, "start_time"):
            duration = (datetime.now() - g.start_time).total_seconds()
            logger.info(f"Request {g.request_id} completed in {duration:.4f} seconds")

        return response

    # Register blueprints
    from app.routes.api import api_bp

    app.register_blueprint(api_bp)

    # Register example validation routes
    try:
        from app.controllers.example_controller import example_bp

        app.register_blueprint(example_bp)
        logger.info("Example validation routes registered")
    except ImportError:
        logger.warning("Example controller not found - skipping example routes")

    logger.info(f"Flask API application created with config: {config_name}")

    return app


app = create_app()