import sys
import os
import logging

from fabric.api import env, task
from fabric.operations import run
from fabric.context_managers import hide, settings
from fabric.utils import abort

from .utils import virtualenv_source, virtualenv
from .utils import printerr
from .utils import booleanize, handle_flag_message
from .utils import prompt_continue
from .utils import upload_template

from .initialize import get_config


ERROR_BAD_BRANCH_PARAM = -3
ERROR_BAD_PARAM = -2


@task
def setup_virtualenv(python3=True):
    """
    Sets up a virtual environment using virtualenvwrapper.

    This method creates a new virtual environment with the specified Python
    version. It uses the 'mkvirtualenv' command from virtualenvwrapper and can
    optionally use Python 3.

    :param python3: Specifies whether to use Python 3 for the virtual
                    environment, defaults to True.

    :type python3: bool

    Note:
        - The virtual environment's name is taken from
            `configuration.virtualenv.name`.
        - If `env.debug` is True, the method logs additional debug information.
    """
    configuration = env.config

    if env.debug:
        logging.basicConfig(
            format='\n%(levelname)s: deploy.setup_virtualenv %(message)s',
            level=logging.DEBUG)

    # mkvirtualenv_cmd = "mkvirtualenv --no-site-packages "
    mkvirtualenv_cmd = "mkvirtualenv "

    if python3:
        mkvirtualenv_cmd += "--python=python3 "

    mkvirtualenv_cmd += f"{configuration.virtualenv.name}"

    if env.debug:

        logging.debug("python3 install: %s", python3)

        logging.debug("virtualenv.workon        : %s",
                      configuration.virtualenv.workon)

        logging.debug("virtualenv.activate      : %s",
                      configuration.virtualenv.activate)

        logging.debug("virtualenv.name          : %s",
                      configuration.virtualenv.name)

        logging.debug("virtualenv.paths.bin     : %s",
                      configuration.virtualenv.paths.bin)

        logging.debug("virtualenv.paths.root    : %s",
                      configuration.virtualenv.paths.root)

        logging.debug("mkvirtualenv_cmd: %s", mkvirtualenv_cmd)

        logging.debug(
            "with virtualenv_source(): "
            "run(\"\n\t%s\n\t\")", mkvirtualenv_cmd)
    else:

        # run("source virtualenvwrapper.sh; mkvirtualenv "
        #     "--no-site-packages {virtualenv_name}".format(
        #         virtualenv_name=configuration.virtualenv.name))

        with virtualenv_source():
            run(mkvirtualenv_cmd)


@task
def bootstrap_pip():
    """
    Bootstraps pip in the current environment.

    This method is a wrapper that calls the 'setup' method, intended for
    setting up or bootstrapping pip in the current virtual environment.

    Note:
        - This method currently calls 'setup', which handles the installation
          of packages via pip based on the requirements file.
    """
    # upgrade()
    setup()


@task
def update_pip():
    """
    Updates pip to the latest version.

    This method updates pip, the Python package installer, to its latest
    version within the current virtual environment.

    Note:
        - The method assumes it's running inside a virtual environment.
        - If `env.debug` is True, it logs the upgrade command being executed.
    """

    # configuration = env.config

    if env.debug:
        logging.basicConfig(
            format='\n%(levelname)s: deploy.pip %(message)s',
            level=logging.DEBUG)

    pipinstall_cmd = "pip install --upgrade pip"

    if env.debug:
        logging.debug("with virtualenv(): run(\"\n\t%s\n\t\")",
                      pipinstall_cmd)
    else:
        with virtualenv():
            run(pipinstall_cmd)


@task
def setup():
    """
    Installs all required packages via pip.

    This method installs packages specified in a requirements file using pip.
    The requirements file path is retrieved from
    `configuration.virtualenv.requirements.filepath`.

    Note:
        - Assumes execution within a virtual environment.
        - If `env.debug` is enabled, debug information is logged.
    """
    configuration = env.config

    if env.debug:
        logging.basicConfig(
            format='\n%(levelname)s: deploy.pip %(message)s',
            level=logging.DEBUG)

    pipinstall_cmd = (
        f"pip install -r "
        f"{configuration.virtualenv.requirements.filepath}"
    )

    if env.debug:
        logging.debug("with virtualenv(): run(\"\n\t%s\n\t\")",
                      pipinstall_cmd)
    else:
        with virtualenv():
            run(pipinstall_cmd)


@task
def install(package_name=None):
    """
    Installs a package via pip within a virtual environment.

    This method installs a specified package using pip. If the package_name
    is '--all', it installs all packages listed in the requirements file.

    :param package_name: Name of the package to install or '--all' to install
                         all packages from requirements file, defaults to None.
    :type package_name: str, optional

    :raises ValueError: If no package_name is provided.
    """
    configuration = env.config

    if not package_name:
        abort("You must specify a package name to be installed")

    if package_name == "--all":
        pipinstall_cmd = (
            f"pip install -r "
            f"{configuration.virtualenv.requirements.filepath}"
        )

    else:
        pipinstall_cmd = f"pip install {package_name}"

    if env.debug:
        print(f"pipinstall_cmd: {pipinstall_cmd}")

    else:
        with virtualenv():
            run(pipinstall_cmd)


@task
def uninstall(package_name, silent=False):
    """
    Uninstalls a specified package from the virtual environment.

    This method activates the virtual environment and uses pip to uninstall the
    specified package. It can optionally suppress command line output.

    :param package_name: Name of the package to uninstall.
    :type package_name: str

    :param silent: Suppress command line output if True, defaults to False.
    :type silent: bool
    :return: None
    """
    with virtualenv():
        with settings(
                hide('warnings', 'running', 'stdout', 'stderr'),
                warn_only=True):

            run(f"pip uninstall -y {package_name}", quiet=silent)


@task
def freeze(param='help'):
    """
    True - update package list and freeze output
    """
    configuration = env.config

    msg_help = """
    pip.freeze takes one of three values:
    \thelp - this help message
    \tTrue - update the pip package list the freeze output
    \tFalse (default) - print the freeze output to the console
    """

    if handle_flag_message(param, msg_help, 'help'):
        sys.exit()
    else:
        try:
            param = booleanize(param)
        except TypeError:
            printerr(
                f"the parameter value you gave, '{param}',"
                f" is not a valid parameter\n{msg_help}",
                ERROR_BAD_PARAM
            )

    if param:
        cmd_pipfreeze = (
            f"pip freeze > "
            f"{configuration.virtualenv.requirements.filepath}"
        )

    else:
        cmd_pipfreeze = "pip freeze"

    with virtualenv():
        run(cmd_pipfreeze)


@task
def copyto(branch=None):
    """
    copy requirements from the current branch to the specified branch

    this only changes the requirements on the local branches.  It does not
    upload remotely. Use deploy.sync to perform remote updates.

    Keyword Arguments:
        branch -- the branch to copy to

    Usage:
        fab copyto --branch=staging
    """

    if branch is None:
        printerr(
            "Missing required parameter: 'branch'\n"
            "Usage: fab pip.copyto:<branch>\n"
            "Valid options: development, staging, production",
            ERROR_BAD_BRANCH_PARAM
        )
        return

    configuration = env.config
    branch_list = ['staging', 'production', 'development']

    if branch not in branch_list:
        printerr(
            f"Branch parameter '{branch}' must be one of {branch_list} "
            "values.", ERROR_BAD_BRANCH_PARAM)

    elif branch == 'development':
        printerr(
            "This method does not allow copying to development branch",
            ERROR_BAD_BRANCH_PARAM)

    elif configuration.project.branch == branch:
        printerr(
            "You have set the source branch to the current branch."
            "This will simply copy over \n\tthe requirements file for "
            "this branch with itself", ERROR_BAD_BRANCH_PARAM)

    branch_config = get_config(branch)

    current_local_path = os.path.join(
        configuration.virtualenv.requirements.local,
        configuration.virtualenv.requirements.filename)

    branch_local_path = os.path.join(
        configuration.virtualenv.requirements.local,
        branch_config.virtualenv.requirements.filename)

    print(f"current_local_path: {current_local_path}")
    print("branch_local_path: {branch_local_path}")

    message = (
        f"Copying file from current branch '{configuration.project.branch}'"
        f"to destination branch '{branch}'. Continue? Y/n "
    )

    prompt_continue(message=message)

    upload_template(
        filename=configuration.virtualenv.requirements.filename,
        destination=branch_local_path,
        context=None,
        use_jinja=False,
        use_sudo=False,
        backup=True,
        template_dir=configuration.virtualenv.requirements.local)


def check_package_installed(package_name, silent=False):
    """
    Checks if a specified package is installed in the virtual environment.

    Activates the virtual environment and uses 'pip list' to check if the
    specified package is installed. Can optionally suppress command line
    output.

    :param package_name: Name of the package to check.
    :type package_name: str

    :param silent: Suppress command line output if True, defaults to False.
    :type silent: bool

    :return: True if installed, False otherwise.
    :rtype: bool
    """
    with virtualenv():

        with settings(
                hide('warnings', 'running', 'stdout', 'stderr'),
                warn_only=True):

            output = run(f"pip list | grep {package_name}", quiet=silent)

        return package_name in output