import asyncio
import logging
import os
import sys
import traceback

import httpx

from vectorcode import __version__
from vectorcode.cli_utils import (
    CliAction,
    config_logging,
    find_project_root,
    get_project_config,
    parse_cli_args,
)
from vectorcode.common import ClientManager

logger = logging.getLogger(name=__name__)


async def async_main():
    cli_args = await parse_cli_args()
    if cli_args.no_stderr:
        sys.stderr = open(os.devnull, "w")

    if cli_args.debug:
        from vectorcode import debugging

        debugging.enable()

    logger.info("Collected CLI arguments: %s", cli_args)

    if cli_args.project_root is None:
        cwd = os.getcwd()
        cli_args.project_root = (
            find_project_root(cwd, ".vectorcode")
            or find_project_root(cwd, ".git")
            or cwd
        )

    logger.info(f"Project root is set to {cli_args.project_root}")

    try:
        final_configs = await (
            await get_project_config(cli_args.project_root)
        ).merge_from(cli_args)
    except IOError as e:
        traceback.print_exception(e, file=sys.stderr)
        return 1

    logger.info("Final configuration has been built: %s", final_configs)

    match cli_args.action:
        case CliAction.check:
            from vectorcode.subcommands import check

            return await check(cli_args)
        case CliAction.init:
            from vectorcode.subcommands import init

            return await init(cli_args)
        case CliAction.version:
            print(__version__)
            return 0
        case CliAction.prompts:
            from vectorcode.subcommands import prompts

            return prompts(cli_args)
        case CliAction.chunks:
            from vectorcode.subcommands import chunks

            return await chunks(final_configs)

    if final_configs.pipe:  # pragma: nocover
        # NOTE: NNCF (intel GPU acceleration for sentence transformer) keeps showing logs.
        # This disables logs below ERROR so that it doesn't hurt the `pipe` output.
        logging.disable(logging.ERROR - 1)

    return_val = 0
    try:
        match final_configs.action:
            case CliAction.query:
                from vectorcode.subcommands import query

                return_val = await query(final_configs)
            case CliAction.vectorise:
                from vectorcode.subcommands import vectorise

                return_val = await vectorise(final_configs)
            case CliAction.drop:
                from vectorcode.subcommands import drop

                return_val = await drop(final_configs)
            case CliAction.ls:
                from vectorcode.subcommands import ls

                return_val = await ls(final_configs)
            case CliAction.update:
                from vectorcode.subcommands import update

                return_val = await update(final_configs)
            case CliAction.clean:
                from vectorcode.subcommands import clean

                return_val = await clean(final_configs)
            case CliAction.files:
                from vectorcode.subcommands import files

                return_val = await files(final_configs)
    except Exception as e:
        return_val = 1
        if isinstance(e, httpx.RemoteProtocolError):  # pragma: nocover
            e.add_note(
                f"Please verify that {final_configs.db_url} is a working chromadb server."
            )
        logger.error(traceback.format_exc())
    finally:
        await ClientManager().kill_servers()
        return return_val


def main():  # pragma: nocover
    config_logging("vectorcode")
    return asyncio.run(async_main())


if __name__ == "__main__":  # pragma: nocover
    sys.exit(main())