from __future__ import absolute_import, unicode_literals

import logging

from ..app_data import AppDataAction, AppDataDisabled, TempAppData
from ..config.cli.parser import VirtualEnvConfigParser
from ..report import LEVELS, setup_report
from ..run.session import Session
from ..seed.wheels.periodic_update import manual_upgrade
from ..version import __version__
from .plugin.activators import ActivationSelector
from .plugin.creators import CreatorSelector
from .plugin.discovery import get_discover
from .plugin.seeders import SeederSelector


def cli_run(args, options=None):
    """Create a virtual environment given some command line interface arguments

    :param args: the command line arguments
    :param options: passing in a ``VirtualEnvOptions`` object allows return of the parsed options
    :return: the session object of the creation (its structure for now is experimental and might change on short notice)
    """
    session = session_via_cli(args, options)
    with session:
        session.run()
    return session


# noinspection PyProtectedMember
def session_via_cli(args, options=None):
    parser, elements = build_parser(args, options)
    options = parser.parse_args(args)
    creator, seeder, activators = tuple(e.create(options) for e in elements)  # create types
    session = Session(options.verbosity, options.app_data, parser._interpreter, creator, seeder, activators)
    return session


# noinspection PyProtectedMember
def build_parser(args=None, options=None):
    parser = VirtualEnvConfigParser(options)
    add_version_flag(parser)
    parser.add_argument(
        "--with-traceback",
        dest="with_traceback",
        action="store_true",
        default=False,
        help="on failure also display the stacktrace internals of virtualenv",
    )
    _do_report_setup(parser, args)
    options = load_app_data(args, parser, options)
    handle_extra_commands(options)

    discover = get_discover(parser, args)
    parser._interpreter = interpreter = discover.interpreter
    if interpreter is None:
        raise RuntimeError("failed to find interpreter for {}".format(discover))
    elements = [
        CreatorSelector(interpreter, parser),
        SeederSelector(interpreter, parser),
        ActivationSelector(interpreter, parser),
    ]
    options, _ = parser.parse_known_args(args)
    for element in elements:
        element.handle_selected_arg_parse(options)
    parser.enable_help()
    return parser, elements


def build_parser_only(args=None):
    """Used to provide a parser for the doc generation"""
    return build_parser(args)[0]


def handle_extra_commands(options):
    if options.upgrade_embed_wheels:
        result = manual_upgrade(options.app_data)
        raise SystemExit(result)


def load_app_data(args, parser, options):
    # here we need a write-able application data (e.g. the zipapp might need this for discovery cache)
    default_app_data = AppDataAction.default()
    parser.add_argument(
        "--app-data",
        dest="app_data",
        action=AppDataAction,
        default="<temp folder>" if isinstance(default_app_data, AppDataDisabled) else default_app_data,
        help="a data folder used as cache by the virtualenv",
    )
    parser.add_argument(
        "--reset-app-data",
        dest="reset_app_data",
        action="store_true",
        help="start with empty app data folder",
        default=False,
    )
    parser.add_argument(
        "--upgrade-embed-wheels",
        dest="upgrade_embed_wheels",
        action="store_true",
        help="trigger a manual update of the embedded wheels",
        default=False,
    )
    options, _ = parser.parse_known_args(args, namespace=options)
    if options.app_data == "<temp folder>":
        options.app_data = TempAppData()
    if options.reset_app_data:
        options.app_data.reset()
    return options


def add_version_flag(parser):
    import virtualenv

    parser.add_argument(
        "--version",
        action="version",
        version="%(prog)s {} from {}".format(__version__, virtualenv.__file__),
        help="display the version of the virtualenv package and it's location, then exit",
    )


def _do_report_setup(parser, args):
    level_map = ", ".join("{}={}".format(logging.getLevelName(l), c) for c, l in sorted(list(LEVELS.items())))
    msg = "verbosity = verbose - quiet, default {}, mapping => {}"
    verbosity_group = parser.add_argument_group(
        title="verbosity", description=msg.format(logging.getLevelName(LEVELS[3]), level_map),
    )
    verbosity = verbosity_group.add_mutually_exclusive_group()
    verbosity.add_argument("-v", "--verbose", action="count", dest="verbose", help="increase verbosity", default=2)
    verbosity.add_argument("-q", "--quiet", action="count", dest="quiet", help="decrease verbosity", default=0)
    option, _ = parser.parse_known_args(args)
    setup_report(option.verbosity)