#!/usr/bin/env python3
import sys
import os
import subprocess
import platform
from argparse import ArgumentParser
from git_reqs.requirementmodule import requirement_module, init_module
from git_reqs import importtools
from git_reqs import exporttools

def get_module(args):
    project = requirement_module(args.project_root)
    if args.module:
        req_module = project.modules[args.module]
        module_path = args.project_root + '/' + args.module
    else:
        req_module = project
        module_path = args.project_root

    if args.file:
        file = args.file
    else:
        file = req_module.module_path + "/" + req_module.module_prefix + '.' + args.format

    return project, req_module, module_path, file

def init(args):
    if args.upgrade:
        req_module = requirement_module(args.parent_path + '/' + args.module)
        req_module.upgrade_module()
    else:
        assert args.module_prefix, "Module prefix is required"
        init_module(
            args.parent_path, args.module, args.module_prefix, args.req_numbering_format, args.root_module)


def import_reqs(args):
    project, req_module, module_path, file = get_module(args)

    if args.format == 'junit':
        importtools.add_test_results(module_path, file)
        project = requirement_module(args.project_root)
    elif args.format == 'xls' or args.format == 'xlsx':
        importtools.import_from_xls(req_module, file)
    elif args.format == 'md':
        importtools.import_from_markdown(req_module, file)
    elif args.format == 're.comments':
        importtools.parse_requirement_links(project, file)
    else:
        assert False, "Invalid format. See available formats with git-reqs import --help"

    req_module.write_reqs()

    if args.update_source and (args.format == 'xls' or args.format == 'md'):
        export_reqs(args)
def edit_reqs(args):
    project = requirement_module(args.project_root)
    if args.module:
        req_module = project.modules[args.module]
    else:
        req_module = project

    file = exporttools.convert_to_xls(req_module)
    print(platform.system())
    if platform.system() == 'Darwin':
        cmd = ['open', '-W', file]
    elif platform.system() == 'Linux':
        cmd = ['xdg-open', file]
    else:
        cmd = ['start', file]

    p = subprocess.Popen(cmd)
    print('Waiting for edit application to finish...')
    p.wait()

    importtools.import_from_xls(req_module, file)
    req_module.write_reqs()



def export_reqs(args):
    project, req_module, module_path, file = get_module(args)

    if args.format == 'xls':
        exporttools.convert_to_xls(req_module)
    elif args.format == 'md':
        exporttools.convert_to_markdown(req_module)
    else:
        assert False, "Invalid format. See available formats with git-reqs export --help"


def create_report(args):
    project = requirement_module(args.project_root)

    if args.type == 'relations':
        exporttools.create_report(project, args.module, args.dont_show_output)
    elif args.type == 'bokeh':
        exporttools.draw_bokeh(project, args.req)
    elif args.type == 'test_coverage':
        exporttools.draw_coverage_diagrams(project, args.dont_show_output)
    else:
        assert False, "Invalid format. See available formats with git-reqs report --help"



if __name__ == "__main__":
    args_parser = ArgumentParser()
    subparsers = args_parser.add_subparsers()

    edit_parser = subparsers.add_parser(
        "edit", help="Edit requirement module with excel")
    edit_parser.add_argument(
        "--project_root", help="Root path to the req project", default=os.getcwd())
    edit_parser.add_argument("--module", help="Name of requirement module")
    edit_parser.set_defaults(func=edit_reqs)

    export_parser = subparsers.add_parser(
        "export", help="Read requirement module")
    export_parser.add_argument(
        "--project_root", help="Root path to the req project", default=os.getcwd())
    export_parser.add_argument("--module", help="Name of requirement module")
    export_parser.add_argument(
        "--format", help="Export format, xls and md are valid")
    export_parser.add_argument(
        "--file", help="Path to file to import")
    export_parser.set_defaults(func=export_reqs)

    import_parser = subparsers.add_parser(
        "import", help="Read requirement module")
    import_parser.add_argument(
        "--project_root", help="Root path to the req project", default=os.getcwd())
    import_parser.add_argument("--module", help="Name of requirement module")
    import_parser.add_argument(
        "--format", help="Export format, xls and junit are valid")
    import_parser.add_argument(
        "--file", help="Path to file to import")
    import_parser.add_argument(
        "--update-source", action='store_false', help="Export git-reqs modifications back to source (default true)")
    import_parser.set_defaults(func=import_reqs)

    report_parser = subparsers.add_parser(
        "report", help="Read requirement module")
    report_parser.add_argument(
        "--project_root", help="Root path to the req project", default=os.getcwd())
    report_parser.add_argument("--module", help="Name of requirement module")
    report_parser.add_argument(
        "--type", help="Report type, relations, bokeh and test_coverage are valid")
    report_parser.add_argument(
        "--req", help="Bokeh plot only for a certain req and its relations", default=None)
    report_parser.set_defaults(func=create_report)
    report_parser.add_argument(
        "--dont_show_output", action='store_true', help="Just save the resulting file, dont show the output (default true)")

    init_parser = subparsers.add_parser(
        "init", help="Init new requirement module")
    init_parser.add_argument(
        "--parent_path", help="Root path to the req project", default=os.getcwd())
    init_parser.add_argument(
        "--module", help="Name of the new requirement module", default='')
    init_parser.add_argument(
        "--module_prefix", help="Project prefix of the new requirement module")
    init_parser.add_argument(
        "--req_numbering_format", help="Numbering format of the reqs, numbers or time_hash are valid", default='time_hash')
    init_parser.add_argument(
        "--upgrade", action='store_true', help="Upgrade existing module to current format version")
    init_parser.add_argument(
        "--root_module", action='store_true', help="Set the new module as a root module, "
                                                   "i.e it will not contain any requirements, only other modules")
    init_parser.set_defaults(func=init)

    args = args_parser.parse_args(sys.argv[1:])

    if hasattr(args, 'func'):
        args.func(args)
    else:
        args_parser.print_usage()
