# Copyright 2015 Rackspace
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.

from __future__ import print_function

import argparse
import errno
import importlib
import os
import re
import sys

from cafe.configurator.managers import EngineConfigManager
from cafe.drivers.base import print_exception, get_error
from cafe.engine.config import EngineConfig


def get_engine_config():
    """
    Get the engine config.

    :return: Instantiated EngineConfig object
    :rtype: EngineConfig
    """
    return EngineConfig(
        os.environ.get("CAFE_ENGINE_CONFIG_FILE_PATH") or
        EngineConfigManager.ENGINE_CONFIG_PATH)


def tree(start):
    """
        Prints tree structure, files first then directories in alphabetical
        order.
    """
    start = os.path.abspath(os.path.expanduser(start))
    if not os.path.exists(start):
        print_exception(
            "Argument Parser", "tree", "{0} Does Not Exist".format(start))
        return
    elif os.path.isfile(start):
        print("+-{0}".format(os.path.basename(start)))
        return
    for path, dirs, files in os.walk(start):
        dirs.sort()
        files.sort()
        depth = path.replace(start, "").count(os.sep)
        print("{0}{1}+-{2}/".format(
            "  " * (depth > 0), "| " * (depth - 1), os.path.basename(path)))
        for file_ in files:
            if not file_.endswith(".pyc") and file_ != "__init__.py":
                print("  {0}{1}".format("| " * depth, file_))


class ConfigAction(argparse.Action):
    """
        Custom action that checks if config exists.
    """
    def __call__(self, parser, namespace, value, option_string=None):
        value = value if value.endswith('.config') else "{0}.config".format(
            value)
        path = "{0}/{1}".format(get_engine_config().config_directory, value)
        if not os.path.exists(path):
            parser.error(
                "ConfigAction: Config does not exist: {0}".format(path))
            exit(errno.ENOENT)
        setattr(namespace, self.dest, value)


class DataDirectoryAction(argparse.Action):
    """
        Custom action that checks if data-directory exists.
    """
    def __call__(self, parser, namespace, value, option_string=None):
        if not os.path.exists(value):
            parser.error(
                "DataDirectoryAction: Data directory does not exist: "
                "{0}".format(value))
            exit(errno.ENOENT)
        setattr(namespace, self.dest, value)


class InputFileAction(argparse.Action):
    """
        Custom action that reads in a file and uses the lines for a test order.
    """
    def __call__(self, parser, namespace, value, option_string=None):
        dic = {}
        try:
            lines = open(value).readlines()
            for count, line in enumerate(lines):
                temp = line.replace(")", "").strip().split(" (")
                dic[temp[1]] = dic.get(temp[1], []) + [temp[0]]
        except IndexError as exception:
            parser.error(
                "InputFileAction: Parsing of {0} failed: {1}".format(
                    line, exception))
        except IOError as exception:
            parser.error(
                "InputFileAction: File open failed: {0}".format(exception))
            exit(get_error(exception))
        setattr(namespace, self.dest, dic)


class ListAction(argparse.Action):
    """
        Custom action that lists either configs or tests.
    """
    def __call__(self, parser, namespace, values, option_string=None):
        if namespace.testrepos:
            print("\n<[TEST REPO]>\n")
            for repo in namespace.testrepos:
                path = importlib.import_module(repo.split(".")[0]).__path__[0]
                path = os.path.join(path, *repo.split(".")[1:])
                print(path)
                if os.path.exists("{0}.py".format(path)):
                    tree("{0}.py".format(path))
                else:
                    tree(path)
                print()
        else:
            print("\n<[CONFIGS]>\n")
            tree(get_engine_config().config_directory)
        exit(0)


class TagAction(argparse.Action):
    """
        Processes tag option.
    """
    def __call__(self, parser, namespace, values, option_string=None):
        if values[0] == "+":
            values = values[1:]
            setattr(namespace, "all_tags", True)
        else:
            setattr(namespace, "all_tags", False)
        if len(values) < 1:
            parser.error("argument --tags/-t: expected at least one argument")
        setattr(namespace, self.dest, values)


class RegexAction(argparse.Action):
    """
        Processes regex option.
    """
    def __call__(self, parser, namespace, values, option_string=None):
        regex_list = []
        for regex in values:
            try:
                regex_list.append(re.compile(regex))
            except re.error as exception:
                parser.error(
                    "RegexAction: Invalid regex {0} reason: {1}".format(
                        regex, exception))
        setattr(namespace, self.dest, regex_list)


class VerboseAction(argparse.Action):
    """
        Custom action that sets VERBOSE environment variable.
    """
    def __call__(self, parser, namespace, value, option_string=None):
        os.environ["VERBOSE"] = "true" if value == 3 else "false"
        setattr(namespace, self.dest, value)


class ArgumentParser(argparse.ArgumentParser):
    """
        Parses all arguments.
    """
    def __init__(self):
        desc = "Open Common Automation Framework Engine"
        usage_string = """
            cafe-runner <config> <testrepos>... [--failfast]
                [--dry-run] [--data-directory=DATA_DIRECTORY]
                [--regex-list=REGEX...] [--file] [--parallel=(class|test)]
                [--result=(json|xml)] [--result-directory=RESULT_DIRECTORY]
                [--tags=TAG...] [--verbose=VERBOSE] [--exit-on-error]
                [--workers=NUM]
            cafe-runner <config> <testrepo>... --list
            cafe-runner --list
            cafe-runner --help
            """

        super(ArgumentParser, self).__init__(
            usage=usage_string, description=desc)

        self.prog = "Argument Parser"

        self.add_argument(
            "config",
            action=ConfigAction,
            metavar="<config>",
            help="test config.  Looks in the .opencafe/configs directory."
                 "Example: bsl/uk.json")

        self.add_argument(
            "testrepos",
            nargs="*",
            default=[],
            metavar="<testrepo>...",
            help="The name of the packages containing the tests. "
                 "This overrides the value in the engine.config file, as well "
                 "as the CAFE_OPENCAFE_ENGINE_default_test_repo environment "
                 "variable. Example: ubroast.bsl.v2 ubroast.bsl.v1")

        self.add_argument(
            "--dry-run",
            action="store_true",
            help="dry run.  Don't run tests just print them.  Will run data"
                 " generators.")

        self.add_argument(
            "--exit-on-error",
            action="store_true",
            help="Exit on module import error")

        self.add_argument(
            "--failfast", "-f",
            action="store_true",
            help="fail fast")

        self.add_argument(
            "--list", "-l",
            action=ListAction,
            nargs=0,
            help="Lists configs if no repo is specified otherwise lists tests"
                 " for all the specified repos.")

        self.add_argument(
            "--data-directory", "-D",
            action=DataDirectoryAction,
            help="Data directory override")

        self.add_argument(
            "--regex-list", "-d",
            action=RegexAction,
            nargs="+",
            default=[],
            metavar="REGEX",
            help="Filter by regex against dotpath down to test level"
                 "Example: tests.repo.cafe_tests.NoDataGenerator.test_fail"
                 "Example: 'NoDataGenerator\.*fail'"
                 "Takes in a list and matches on any")

        self.add_argument(
            "--file", "-F",
            metavar="INPUT_FILE",
            default={},
            action=InputFileAction,
            help="Runs only tests listed in file."
                 "  Can be created by copying --dry-run response")

        self.add_argument(
            "--parallel", "-P",
            choices=["class", "test"],
            help="Runs test in parallel by class grouping or test")

        self.add_argument(
            "--result", "-R",
            choices=["json", "xml", "subunit"],
            help="Generates a specified formatted result file")

        self.add_argument(
            "--result-directory",
            default="./",
            metavar="RESULT_DIRECTORY",
            help="Directory for result file to be stored")

        self.add_argument(
            "--tags", "-t",
            nargs="+",
            action=TagAction,
            default=[],
            metavar="TAG",
            help="""Run only tests that have tags set.
                By default tests that match any of the tags will be returned.
                Sending a "+" as the first tag in the tag list will only
                return the tests that match all the tags.""")

        self.add_argument(
            "--verbose", "-v",
            action=VerboseAction,
            choices=[1, 2, 3],
            default=2,
            type=int,
            help="Set unittest output verbosity")

        self.add_argument(
            "--workers", "-w",
            nargs="?",
            default=10,
            type=int,
            help="Set number of workers for --parallel option")

    def error(self, message):
        self.print_usage(sys.stderr)
        print_exception("Argument Parser", message)
        exit(get_error())

    def parse_args(self, *args, **kwargs):
        args = super(ArgumentParser, self).parse_args(*args, **kwargs)
        if getattr(args, "all_tags", None) is None:
            args.all_tags = False
        return args