import os
import sys
import click
import pathlib
import logging
import mimetypes
import setproctitle
import multiprocessing


from flask_jwt_extended import (
    create_access_token,
    get_jwt,
    get_jwt_identity,
    set_access_cookies,
    verify_jwt_in_request,
)
from datetime import datetime, timezone
from flask import Response, request

from swingmusic import settings
from swingmusic.api import create_api
from swingmusic.crons import start_cron_jobs
from swingmusic.utils.threading import background
from swingmusic.setup import load_into_mem, run_setup
from swingmusic.plugins.register import register_plugins
from swingmusic.utils.xdg_utils import get_xdg_config_dir
from swingmusic.start_info_logger import log_startup_info
from swingmusic.utils.filesystem import get_home_res_path
from swingmusic.utils.paths import getClientFilesExtensions
from swingmusic.arg_handler import handle_build, handle_password_reset

def print_version(*args, **kwargs):
    """
    Prints the version of the application.
    """
    if not args[2]:
        return

    path = get_home_res_path("version.txt")
    if not path:
        click.echo("Version file not found.")
        sys.exit(1)

    with open(path, "r") as f:
        version = f.read()

    click.echo(version)
    sys.exit(0)


def start_swingmusic(host: str, port: int):
    """
    Creates and starts the Flask application server for Swing Music.

    This function sets up the Flask application with all necessary
    configurations, including static file handling, authentication middleware, and
    server setup, then runs it. It also sets up background tasks and cron jobs.

    Args:
        host (str): The host address to bind the server to (e.g., 'localhost' or '0.0.0.0')
        port (int): The port number to run the server on

    Note:
        The application uses either bjoern or waitress as the WSGI server,
        depending on availability. It also includes JWT authentication,
        static file serving with gzip compression support, and automatic
        token refresh functionality.
    """

    # Example: Setting up dirs, database, and loading stuff into memory.
    # TIP: Be careful with the order of the setup functions.

    # Load mimetypes for the web client's static files
    # Loading mimetypes should happen automatically but
    # sometimes the mimetypes are not loaded correctly
    # eg. when the Registry is messed up on Windows.

    # See the following issues:
    # https://github.com/swingmx/swingmusic/issues/137

    mimetypes.add_type("text/css", ".css")
    mimetypes.add_type("text/javascript", ".js")
    mimetypes.add_type("text/plain", ".txt")
    mimetypes.add_type("text/html", ".html")
    mimetypes.add_type("image/webp", ".webp")
    mimetypes.add_type("image/svg+xml", ".svg")
    mimetypes.add_type("image/png", ".png")
    mimetypes.add_type("image/vnd.microsoft.icon", ".ico")
    mimetypes.add_type("image/gif", ".gif")
    mimetypes.add_type("font/woff", ".woff")
    mimetypes.add_type("application/manifest+json", ".webmanifest")

    # logging.disable(logging.CRITICAL)
    # werkzeug = logging.getLogger("werkzeug")
    # werkzeug.setLevel(logging.ERROR)

    waitress_logger = logging.getLogger("waitress")
    waitress_logger.setLevel(logging.ERROR)

    log_startup_info(host, port)

    @background
    def run_swingmusic():
        register_plugins()

        setproctitle.setproctitle(f"swingmusic {host}:{port}")
        start_cron_jobs()

    # Setup function calls
    settings.Info.load()
    run_setup()

    # Create the Flask app
    app = create_api()
    app.static_folder = get_home_res_path("client")

    # INFO: Routes that don't need authentication
    whitelisted_routes = {
        "/auth/login",
        "/auth/users",
        "/auth/pair",
        "/auth/logout",
        "/auth/refresh",
        "/docs",
    }
    blacklist_extensions = {".webp", ".jpg"}.union(getClientFilesExtensions())

    def skipAuthAction():
        """
        Skips the JWT verification for the current request.
        """
        if request.path == "/" or any(
            request.path.endswith(ext) for ext in blacklist_extensions
        ):
            return True

        # if request path starts with any of the blacklisted routes, don't verify jwt
        if any(request.path.startswith(route) for route in whitelisted_routes):
            return True

        return False

    @app.before_request
    def verify_auth():
        """
        Verifies the JWT token before each request.
        """
        if skipAuthAction():
            return

        verify_jwt_in_request()

    @app.after_request
    def refresh_expiring_jwt(response: Response):
        """
        Refreshes the cookies JWT token after each request.
        """

        # INFO: If the request has an Authorization header, don't refresh the jwt
        # Request is probably from the mobile client or a third party
        if skipAuthAction() or request.headers.get("Authorization"):
            return response

        try:
            exp_timestamp = get_jwt()["exp"]
            now = datetime.now(timezone.utc)
            target_timestamp = datetime.timestamp(now) + 60 * 60 * 24 * 7  # 7 days

            if target_timestamp > exp_timestamp:
                access_token = create_access_token(identity=get_jwt_identity())
                set_access_cookies(response, access_token)

            return response
        except (RuntimeError, KeyError):
            return response

    @app.route("/<path:path>")
    def serve_client_files(path: str):
        """
        Serves the static files in the client folder.
        """
        js_or_css = path.endswith(".js") or path.endswith(".css")
        if not js_or_css:
            return app.send_static_file(path)

        gzipped_path = path + ".gz"
        user_agent = request.headers.get("User-Agent")

        # INFO: Safari doesn't support gzip encoding
        # See issue: https://github.com/swingmx/swingmusic/issues/155
        is_safari = (
            user_agent
            and user_agent.find("Safari") >= 0
            and user_agent.find("Chrome") < 0
        )

        if is_safari:
            return app.send_static_file(path)

        accepts_gzip = request.headers.get("Accept-Encoding", "").find("gzip") >= 0

        if accepts_gzip:
            if os.path.exists(os.path.join(app.static_folder or "", gzipped_path)):
                response = app.make_response(app.send_static_file(gzipped_path))
                response.headers["Content-Encoding"] = "gzip"
                return response

        return app.send_static_file(path)

    @app.route("/")
    def serve_client():
        """
        Serves the index.html file at `client/index.html`.
        """
        return app.send_static_file("index.html")

    load_into_mem()
    run_swingmusic()
    # TrackStore.export()
    # ArtistStore.export()

    try:
        import bjoern

        bjoern.run(app, host, port)
    except ImportError:
        import waitress

        waitress.serve(
            app,
            host=host,
            port=port,
            threads=100,
            ipv6=True,
            ipv4=True,
        )


@click.command(options_metavar="<options>", context_settings={"show_default": True})
@click.option(
    "--build",
    default=False,
    help="Build the project.",
    is_eager=True,
    callback=handle_build,
    is_flag=True,
)
@click.option("--host", default="0.0.0.0", help="Host to run the app on.")
@click.option("--port", default=1970, help="HTTP port to run the app on.")
@click.option(
    "--config",
    default=lambda: get_xdg_config_dir(),
    show_default="XDG_CONFIG_HOME",
    help="Path to the config file.",
    type=click.Path(
        exists=True,
        file_okay=False,
        dir_okay=True,
        writable=True,
        resolve_path=True,
        allow_dash=False,
        path_type=pathlib.Path,
    ),
)
@click.option(
    "--password-reset",
    is_flag=True,
    help="Reset the password.",
    is_eager=True,
    callback=handle_password_reset,
)
@click.option(
    "--version",
    is_flag=True,
    default=False,
    callback=print_version,
    help="Show the version and exit",
    is_eager=True,
)
def run(*args, **kwargs):
    """
    Swing Music entry point. All commandline arguments are handled
    here by the click decorators and configuration.
    """
    # INFO: Set the config dir as an environment variable
    os.environ["SWINGMUSIC_XDG_CONFIG_DIR"] = str(
        pathlib.Path(kwargs["config"]).resolve()
    )
    start_swingmusic(kwargs["host"], kwargs["port"])


if __name__ == "__main__":
    multiprocessing.freeze_support()
    multiprocessing.set_start_method("spawn")
    run()