werk

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Copyright (C) 2019 tribe29 GmbH - License: GNU General Public License v2
# This file is part of Checkmk (https://checkmk.com). It is subject to the terms and
# conditions defined in the file COPYING, which is part of this source code package.

import fcntl
import os
import struct
import subprocess
import sys
import termios
import time
import tty
from typing import Any, Callable, Dict, List, NoReturn, Optional, Set, Tuple

# colored output, if stdout is a tty
if sys.stdout.isatty():
    tty_red = '\033[31m'
    tty_green = '\033[32m'
    tty_yellow = '\033[33m'
    tty_blue = '\033[34m'
    tty_magenta = '\033[35m'
    tty_cyan = '\033[36m'
    tty_white = '\033[37m'
    tty_bgred = '\033[41m'
    tty_bggreen = '\033[42m'
    tty_bgyellow = '\033[43m'
    tty_bgblue = '\033[44m'
    tty_bgmagenta = '\033[45m'
    tty_bgcyan = '\033[46m'
    tty_bgwhite = '\033[47m'
    tty_bold = '\033[1m'
    tty_underline = '\033[4m'
    tty_normal = '\033[0m'

    def tty_colors(codes):
        return '\033[%sm' % (';'.join([str(c) for c in codes]))
else:
    tty_red = ''
    tty_green = ''
    tty_yellow = ''
    tty_blue = ''
    tty_magenta = ''
    tty_cyan = ''
    tty_white = ''
    tty_bgred = ''
    tty_bggreen = ''
    tty_bgblue = ''
    tty_bgmagenta = ''
    tty_bgcyan = ''
    tty_bgwhite = ''
    tty_bold = ''
    tty_underline = ''
    tty_normal = ''
    tty_ok = 'OK'

    def tty_colors(codes):
        return ""


grep_colors = [
    tty_bold + tty_magenta,
    tty_bold + tty_cyan,
    tty_bold + tty_green,
]


def get_tty_size():
    # type: () -> Tuple[int, int]
    try:
        ws = bytearray(8)
        fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ, ws)
        lines, columns, _x, _y = struct.unpack("HHHH", ws)
        if lines > 0 and columns > 0:
            return lines, columns
    except OSError:
        pass
    return (24, 99999)


def bail_out(text):
    # type: (str) -> NoReturn
    sys.stderr.write(text + "\n")
    sys.exit(1)


g_base_dir = ""


def goto_werksdir():
    global g_base_dir
    g_base_dir = os.path.abspath('.')
    while not os.path.exists(".werks") and os.path.abspath('.') != '/':
        os.chdir("..")

    try:
        os.chdir(".werks")
    except Exception:
        sys.stderr.write("Cannot find directory .werks\n")
        sys.exit(1)


g_last_werk = None  # type: Optional[int]


def get_last_werk():
    # type: () -> int
    if g_last_werk is None:
        bail_out("No last werk known. Please specify id.")
    return g_last_werk


def load_config():
    global g_last_werk
    with open("config") as f_config:
        exec(f_config.read(), globals(), globals())
    try:
        with open(".last") as f_last:
            g_last_werk = int(f_last.read())
    except Exception:
        g_last_werk = None


g_werks = {}  # type: Dict[int, Dict[str, Any]]


def load_werks():
    global g_werks
    g_werks = {}
    check_modified()
    for entry in os.listdir("."):
        try:
            werkid = int(entry)
            try:
                g_werks[werkid] = load_werk(werkid)
            except Exception:
                sys.stderr.write("SKIPPING INVALID werk %d\n" % werkid)
        except Exception:
            continue


def save_last_werkid(wid):
    try:
        open(".last", "w").write("%d\n" % int(wid))
    except Exception:
        pass


def load_current_version():
    for line in open("../defines.make"):
        if line.startswith("VERSION"):
            version = line.split("=", 1)[1].strip()
            return version

    bail_out("Failed to read VERSION from defines.make")


g_modified = set()  # type: Set[int]


def check_modified():
    global g_modified
    g_modified = set([])
    for line in os.popen("git status --porcelain"):
        if line[0] in "AM" and ".werks/" in line:
            try:
                wid = line.rsplit("/", 1)[-1].strip()
                g_modified.add(int(wid))
            except Exception:
                pass


def werk_is_modified(werkid):
    return werkid in g_modified


def werk_exists(werkid):
    return os.path.exists(str(werkid))


def load_werk(werkid):
    werk = {
        "id": werkid,
        "state": "unknown",
        "title": "unknown",
        "component": "general",
        "compatible": "compat",
        "edition": "cre",
        "knowledge": "undoc",
    }

    f = open(str(werkid))
    for line in f:
        line = line.strip()
        if line == "":
            break
        header, value = line.split(":", 1)
        werk[header.strip().lower()] = value.strip()

    werk["description"] = f.read()
    versions.add(werk["version"])
    return werk


def save_werk(werk):
    f = open(str(werk["id"]), "w")
    f.write("Title: %s\n" % werk["title"])
    for key, val in sorted(werk.items()):
        if key not in ["title", "description", "id"]:
            f.write("%s%s: %s\n" % (key[0].upper(), key[1:], val))
    f.write("\n")
    f.write(werk["description"])
    f.close()
    git_add(werk)
    save_last_werkid(werk["id"])


def change_werk_version(werk_id, new_version):
    werk = g_werks[werk_id]
    werk["version"] = new_version
    save_werk(werk)
    git_add(werk)


def git_add(werk):
    os.system("git add %d" % werk["id"])  # nosec


def git_commit(werk, custom_files):
    title = werk["title"]
    for classid, _classname, prefix in classes:
        if werk["class"] == classid:
            if prefix:
                title = "%s %s" % (prefix, title)

    title = "%05d %s" % (werk['id'], title)

    if custom_files:
        files_to_commit = custom_files
        default_files = [".werks"]
        for entry in default_files:
            files_to_commit.append("%s/%s" % (git_top_level(), entry))

        os.chdir(g_base_dir)
        cmd = "git commit %s -m %s" % (" ".join(files_to_commit),
                                       quote_shell_string(title + "\n\n" + werk["description"]))
        os.system(cmd)  # nosec

    else:
        if something_in_git_index():
            dash_a = ''
            os.system("cd '%s' ; git add .werks" % git_top_level())  # nosec
        else:
            dash_a = '-a'

        cmd = "git commit %s -m %s" % (dash_a,
                                       quote_shell_string(title + "\n\n" + werk["description"]))
        os.system(cmd)  # nosec


def git_top_level():
    info = subprocess.Popen(["git", "rev-parse", "--show-toplevel"], stdout=subprocess.PIPE)
    return info.communicate()[0].split()[0]


def something_in_git_index():
    for line in os.popen("git status --porcelain"):
        if line[0] == 'M':
            return True
    return False


def quote_shell_string(s):
    return "'" + s.replace("'", "'\"'\"'") + "'"


def next_werk_id():
    my_werk_ids = get_werk_ids()
    if not my_werk_ids:
        bail_out(
            'You have no werk IDS left. You can reserve 10 additional Werk IDS with "./werk ids 10".'
        )
    return my_werk_ids[0]


def add_comment(werk, title, comment):
    werk["description"] += """
%s: %s
%s""" % (time.strftime("%F %T"), title, comment)


def usage():
    sys.stdout.write("""Usage: werk COMMAND [ARGS...]

where COMMAND is one of:

  ids [#]                - Shows the number of reserved werk IDS. With a number
                           given as parameter the command will reserve new werk IDS.
  list [-r] [STATE]      - list werks (-r: reverse)
  new                    - create a new werk
  show [# #..]           - show several werks, or 'all' for all, of leave out for last
  delete #..             - delete werk(s)
  grep [-v] KW1 KW2...   - show werks containing all of the given keywords (-v: verbose)
  edit [#]               - open werk # in editor (or newest werk)
  knowledge|knw ID STATE - change the knowlege state of a werk
  blame [#]              - show who worked on a werk
  url #                  - show the online URL of werk #

""")
    sys.exit(1)


def num_color(n, colors, inverse):
    if inverse:
        b = 40
    else:
        b = 30

    c = colors[n - 1]
    return tty_colors([b + c, 1])


def list_werk(werk):
    if werk_is_modified(werk["id"]):
        bold = tty_bold + tty_cyan + "(*) "
    else:
        bold = ""
    _lines, cols = get_tty_size()
    title = werk["title"][:cols - 45]
    sys.stdout.write(
        "%s %-9s %s %s %3s %-13s %-6s %s%s%s %-8s %s%s%s\n" %
        (format_werk_id(werk["id"]), time.strftime("%F", time.localtime(int(werk["date"]))),
         colored_class(werk["class"], 8), format_knw_state(werk["knowledge"]) if werk["class"]
         == "feature" else "   ", werk["edition"], werk["component"], werk["compatible"], tty_bold,
         werk["level"], tty_normal, werk["version"], bold, title, tty_normal))


def format_werk_id(werk_id):
    return tty_bgwhite + tty_blue + ("#%05d" % int(werk_id)) + tty_normal


def format_knw_state(knw_state):
    return {
        "undoc": tty_bgblue + tty_white + tty_bold + "?D?" + tty_normal,
        "todoc": tty_bgred + tty_white + tty_bold + "!D!" + tty_normal,
        "doc": tty_bggreen + tty_white + tty_bold + " D " + tty_normal,
    }.get(knw_state, knw_state)


def colored_class(classname, digits):
    if classname == "fix":
        return tty_bold + tty_red + ("%-" + str(digits) + "s") % classname + tty_normal
    return ("%-" + str(digits) + "s") % classname


def show_werk(werk):
    list_werk(werk)
    sys.stdout.write("\n%s\n" % werk["description"])


def main_list(args, fmt):
    # arguments are tags from state, component and class. Multiple values
    # in one class are orred. Multiple types are anded.
    filters = {}  # type: Dict[str, List]

    reverse = False
    for a in args:

        if a == "current":
            a = g_current_version

        if a == '-r':
            reverse = True
            continue

        hit = False
        for tp, values in [("edition", editions), ("component", all_components()),
                           ("level", levels), ("class", classes), ("version", versions),
                           ("compatible", compatible), ("knowledge", knowledge)]:
            for v in values:
                if isinstance(v, tuple):
                    v = v[0]
                if v.startswith(a):
                    entries = filters.get(tp, [])
                    entries.append(v)
                    filters[tp] = entries
                    hit = True
                    break
            if hit:
                break
        if not hit:
            bail_out(
                "No such edition, component, state, class, knowledge state or target version: %s" %
                a)

    # Filter
    newwerks = []
    for werk in g_werks.values():
        skip = False
        for tp, entries in filters.items():
            if werk[tp] not in entries:
                skip = True
                break
        if not skip:
            newwerks.append(werk)

    werks = sorted(newwerks, key=lambda w: w["date"], reverse=reverse)

    # Output
    if fmt == "console":
        for werk in werks:
            list_werk(werk)
    else:
        output_csv(werks)


# CSV Table has the following columns:
# Component;ID;Title;Class;Effort
def output_csv(werks):
    def line(*l):
        sys.stdout.write('"' + '";"'.join(map(str, l)) + '"\n')

    nr = 1
    for entry in components:
        if isinstance(entry, tuple) and len(entry) == 2:
            name, alias = entry
        elif isinstance(entry, str):  # TODO: Hmmm...
            name, alias = entry, entry
        else:
            bail_out("invalid component %r" % (entry,))

        line("", "", "", "", "")

        total_effort = 0
        for werk in werks:
            if werk["component"] == name:
                total_effort += werk_effort(werk)
        line("", "%d. %s" % (nr, alias), "", total_effort)
        nr += 1

        for werk in werks:
            if werk["component"] == name:
                line(werk["id"], werk["title"], werk_class(werk), werk_effort(werk))
                line("", werk["description"].replace("\n", " ").replace('"', "'"), "", "")


def werk_class(werk):
    cl = werk["class"]
    for entry in classes:
        if entry == cl:
            return cl

        if isinstance(entry, tuple) and entry[0] == cl:
            return entry[1]
    return cl


def werk_effort(werk):
    return int(werk.get("effort", "0"))


def main_show(args):
    ids = args
    if len(ids) == 0:
        ids = [get_last_werk()]
    elif ids[0] == 'all':
        ids = [wid for (wid, _werk) in g_werks.items()]

    for wid in ids:
        if wid != ids[0]:
            sys.stdout.write(
                "-------------------------------------------------------------------------------\n")
        try:
            show_werk(g_werks[int(wid)])
        except Exception:
            sys.stderr.write("Skipping invalid werk id '%s'\n" % wid)
    save_last_werkid(ids[-1])


def get_input(what, default=""):
    sys.stdout.write("%s: " % what)
    sys.stdout.flush()
    value = sys.stdin.readline().strip()
    if value == "":
        return default
    return value


def get_long_input(what):
    sys.stdout.write("Enter %s. End with CTRL-D.\n" % what)
    usertext = sys.stdin.read()
    # remove leading and trailing empty lines
    while usertext.startswith("\n"):
        usertext = usertext[1:]
    while usertext.endswith("\n\n"):
        usertext = usertext[:-1]
    return usertext


def getch():
    fd = sys.stdin.fileno()
    old_settings = termios.tcgetattr(fd)
    try:
        tty.setraw(sys.stdin.fileno())
        ch = sys.stdin.read(1)
    finally:
        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
    if ord(ch) == 3:
        raise KeyboardInterrupt()
    return ch


def input_choice(what, choices):
    next_index = 0
    ctc = {}
    texts = []
    for choice in choices:
        if isinstance(choice, tuple):
            choice = choice[0]

        added = False

        # Find an identifying character for the input choice. In case all possible
        # characters are already used start using unique numbers
        for c in str(choice):
            if c not in ".-_/" and c not in ctc:
                ctc[c] = choice
                texts.append(str(choice).replace(c, tty_bold + c + tty_normal, 1))
                added = True
                break

        if not added:
            ctc["%s" % next_index] = choice
            texts.append("%s:%s" % ("%s%d%s" % (tty_bold, next_index, tty_normal), choice))
            next_index += 1

    while True:
        sys.stdout.write("%s (%s): " % (what, ", ".join(texts)))
        sys.stdout.flush()
        c = getch()
        if c in ctc:
            sys.stdout.write(" %s%s%s\n" % (tty_bold, ctc[c], tty_normal))
            return ctc[c]

        sys.stdout.write("\n")


def get_edition_components(edition):
    return components + edition_components.get(edition, [])


def all_components():
    c = components
    for ed_components in edition_components.values():
        c += ed_components
    return components


werk_notes = """
    .---Werk----------------------------------------------------------------------.
    |                                                                             |
    |             Das Werk ist für den User/Admin gedacht!!                       |
    |                                                                             |
    |  Anhand des Titels soll der User sofort erkennen, ob er/sie betroffen ist.  |
    |  In den Details soll beschrieben werden, was er/sie ggfs. tun muss.         |
    |  Es dürfen auch gerne technische Details erläutert werden.                  |
    |                                                                             |
    '-----------------------------------------------------------------------------'

"""


def main_new(args):
    sys.stdout.write(tty_green + werk_notes + tty_normal)

    werk = {}
    werk["id"] = next_werk_id()
    werk["date"] = int(time.time())
    werk["version"] = g_current_version
    werk["title"] = get_input("Title")
    if werk["title"] == "":
        sys.stderr.write("Cancelled.\n")
        sys.exit(0)
    werk["class"] = input_choice("Class", classes)
    werk["edition"] = input_choice("Edition", editions)
    werk["component"] = input_choice("Component", get_edition_components(werk["edition"]))
    werk["level"] = input_choice("Level", levels)
    werk["compatible"] = input_choice("Compatible", compatible)
    if werk["class"] == "feature":
        werk["knowledge"] = "undoc"  # Don't ask. Developers must not deal with this
    else:
        werk["knowledge"] = "doc"  # Bug and security fixes never get documented in user manual
    werk["description"] = u"\n"

    g_werks[werk["id"]] = werk
    save_werk(werk)
    invalidate_my_werkid(werk["id"])
    edit_werk(werk["id"], args)

    sys.stdout.write("Werk %s saved.\n" % format_werk_id(werk["id"]))


def get_werk_arg(args):
    if len(args) == 0:
        wid = get_last_werk()
    else:
        if len(args) != 1:
            usage()
        wid = int(args[0])

    werk = g_werks.get(wid)
    if not werk:
        bail_out("No such werk.\n")
    save_last_werkid(wid)
    return wid


def main_blame(args):
    wid = get_werk_arg(args)
    os.system("git blame %d" % wid)  # nosec


def main_url(args):
    wid = get_werk_arg(args)
    sys.stdout.write(online_url % wid + "\n")


def main_delete(args):
    if len(args) == 0:
        args = [get_last_werk()]
    for werk_id in args:
        if not werk_exists(werk_id):
            bail_out("There is no werk %s." % format_werk_id(werk_id))

        if os.system("git rm -f %s" % werk_id) == 0:  # nosec
            sys.stdout.write("Deleted werk %s (%s).\n" %
                             (format_werk_id(werk_id), g_werks[int(werk_id)]["title"]))
            my_ids = get_werk_ids()
            my_ids.append(werk_id)
            store_werk_ids(my_ids)
            sys.stdout.write("You lucky bastard now own the werk ID %s.\n" %
                             format_werk_id(werk_id))


def grep(line, kw, n):
    lc = kw.lower()
    i = line.lower().find(lc)
    if i == -1:
        return None
    col = grep_colors[n % len(grep_colors)]
    return line[0:i] + col + line[i:i + len(kw)] + tty_normal + line[i + len(kw):]


def main_grep(args):
    if '-v' in args:
        verbose = True
        args = [a for a in args if a != '-v']
    else:
        verbose = False

    if len(args) == 0:
        usage()

    for werk in g_werks.values():
        one_kw_didnt_match = False
        title = werk["title"]
        lines = werk["description"].split("\n")
        bodylines = set([])

        # *all* of the keywords must match in order for the
        # werk to be displayed
        i = 0
        for kw in args:
            i += 1
            this_kw_matched = False

            # look for keyword in title
            match = grep(title, kw, i)
            if match:
                werk["title"] = match
                title = match
                this_kw_matched = True

            # look for keyword in description
            for j, line in enumerate(lines):
                match = grep(line, kw, i)
                if match:
                    bodylines.add(j)
                    lines[j] = match
                    this_kw_matched = True

            if not this_kw_matched:
                one_kw_didnt_match = True

        if not one_kw_didnt_match:
            list_werk(werk)
            if verbose:
                for x in sorted(list(bodylines)):
                    sys.stdout.write("  %s\n" % lines[x])


def main_knowledge(args):
    if len(args) != 2:
        bail_out("Usage: werk knowledge ID undoc|todoc|doc")
    werkid = args[0]
    if not werk_exists(werkid):
        bail_out("No such werk.")
    werkid = int(werkid)
    save_last_werkid(werkid)

    knw_state = args[1]
    if knw_state not in [c[0] for c in knowledge]:
        bail_out("Invalid knowledge state. Allowed are %s." %
                 ", ".join(["%s (%s)" % c for c in knowledge]))

    werk = load_werk(werkid)
    werk["knowledge"] = knw_state
    save_werk(werk)


def main_edit(args):
    if len(args) == 0:
        werkid = get_last_werk()
    else:
        try:
            werkid = int(args[0])
            args = args[1:]
        except Exception:
            werkid = get_last_werk()

    edit_werk(werkid, args, commit=False)
    save_last_werkid(werkid)


def edit_werk(werkid, custom_files=None, commit=True):
    if custom_files is None:
        custom_files = []
    if not os.path.exists(str(werkid)):
        bail_out("No werk with this id.")
    editor = os.getenv("EDITOR")
    if not editor:
        for p in ["/usr/bin/editor", "/usr/bin/vim", "/bin/vi"]:
            if os.path.exists(p):
                editor = p
                break
    if not editor:
        bail_out("No editor available (please set EDITOR).\n")

    if os.system("bash -c '%s +11 %s'" % (editor, werkid)) == 0:  # nosec
        load_werks()
        werk = g_werks[werkid]
        git_add(g_werks[werkid])
        if commit:
            git_commit(werk, custom_files)


def main_commit(args):
    if len(g_modified) == 0:
        bail_out("No new or modified werk.")
    else:
        sys.stdout.write("Commiting:\n")
        for wid in g_modified:
            list_werk(g_werks[wid])
        cmd = "git commit -m 'Updated werk entries %s' ." % (", ".join(
            ["#%05d" % wid for wid in g_modified]))
        if os.system(cmd) == 0:  # nosec
            sys.stdout.write("--> Successfully committed %d werks.\n" % len(g_modified))
        else:
            bail_out("Cannot commit.")


def main_pick(args):
    if len(args) == 0:
        bail_out("Please specify at least one commit ID to cherry-pick.")
    if args[0] == '-n':
        no_commit = True
        args = args[1:]
    else:
        no_commit = False

    for commit_id in args:
        werk_cherry_pick(commit_id, no_commit)


def werk_cherry_pick(commit_id, no_commit):
    # Cherry-pick the commit in question from the other branch
    os.system("git cherry-pick --no-commit '%s'" % commit_id)  # nosec

    # Find werks that have been cherry-picked and change their version
    # to our current version
    load_werks()  # might have changed
    for line in os.popen("git status --porcelain"):  # nosec
        # M  .werks/103
        #  M werk
        _status, filename = line.strip().split(None, 1)
        if filename.startswith(".werks/") and filename[7].isdigit():
            werk_id = int(filename[7:])
            change_werk_version(werk_id, g_current_version)
            sys.stdout.write("Changed version of werk %s to %s.\n" %
                             (format_werk_id(werk_id), g_current_version))

    # Commit
    if not no_commit:
        os.system("git commit -C '%s'" % commit_id)  # nosec

    else:
        sys.stdout.write("We don't commit yet. Here is the status:\n")
        sys.stdout.write("Please commit with git commit -C '%s'\n\n" % commit_id)
        os.system("git status")


def get_werk_ids():
    try:
        return eval(open('.my_ids', 'r').read())
    except Exception:
        return []


def invalidate_my_werkid(wid):
    ids = get_werk_ids()
    ids.remove(wid)
    store_werk_ids(ids)


def store_werk_ids(l):
    open('.my_ids', 'w').write(repr(l) + "\n")


def current_branch():
    return [l for l in os.popen("git branch") if l.startswith("*")][0].split()[-1]


def main_fetch_ids(args):
    if not args:
        sys.stdout.write('You have %d reserved IDs.\n' % (len(get_werk_ids())))
        sys.exit(0)
    elif len(args) == 1:
        num = int(args[0])
    else:
        usage()

    if current_branch() != "master":
        bail_out("It is not allowed to reserve IDs on any other branch than the master.")

    # Get the start werk_id to reserve
    try:
        first_free = int(open('first_free').read().strip())
    except (IOError, ValueError):
        first_free = 0

    new_first_free = first_free + num
    # enterprise werks were between 8000 and 8749. Skip over this area for new
    # reserved werk ids
    if 8000 <= first_free < 8780 or 8000 <= new_first_free < 8780:
        first_free = 8780
        new_first_free = first_free + num

    # cmk-omd werk were between 7500 and 7680. Skip over this area for new
    # reserved werk ids
    if 7500 <= first_free < 7680 or 7500 <= new_first_free < 7680:
        first_free = 7680
        new_first_free = first_free + num

    # cma werks are between 9000 and 9999. Skip over this area for new
    # reserved werk ids
    if 9000 <= first_free < 10000 or 9000 <= new_first_free < 10000:
        first_free = 10000
        new_first_free = first_free + num

    # Store the werk_ids to reserve
    my_ids = get_werk_ids() + list(range(first_free, new_first_free))
    store_werk_ids(my_ids)

    # Store the new reserved werk ids
    open('first_free', 'w').write(str(new_first_free) + "\n")

    sys.stdout.write('Reserved %d additional IDs now. You have %d reserved IDs now.\n' %
                     (num, len(my_ids)))

    if os.system("git commit -m 'Reserved %d Werk IDS' ." % num) == 0:  # nosec
        sys.stdout.write("--> Successfully committed reserved werk IDS. Please push it soon!\n")
    else:
        bail_out("Cannot commit.")


#                    _
#    _ __ ___   __ _(_)_ __
#   | '_ ` _ \ / _` | | '_ \
#   | | | | | | (_| | | | | |
#   |_| |_| |_|\__,_|_|_| |_|
#

# default config
editions = []  # type: List[Tuple[str, str]]
components = []  # type: List[Tuple[str, str]]
edition_components = {}  # type: Dict[str, List[Tuple[str, str]]]
classes = []  # type: List[Tuple[str, str, str]]
levels = []  # type: List[Tuple[str, str]]
compatible = []  # type: List[Tuple[str, str]]
knowledge = []  # type: List[Tuple[str, str]]
online_url = ""

versions = set([])  # type: Set[str]
goto_werksdir()
load_config()
load_werks()
g_current_version = load_current_version()

if len(sys.argv) < 2:
    usage()

cmd_arg = sys.argv[1]
commands = {
    "list": lambda args: main_list(args, "console"),
    "export": lambda args: main_list(args, "csv"),
    "show": main_show,
    "new": main_new,
    "blame": main_blame,
    "delete": main_delete,
    "grep": main_grep,
    "edit": main_edit,
    "knowledge": main_knowledge,
    "knw": main_knowledge,
    "ids": main_fetch_ids,
    "pick": main_pick,
    "cherry-pick": main_pick,
    "url": main_url,
}

hits = []  # type: List[Tuple[str,Callable[[List[str]], None]]]
for cmd_name, func in commands.items():
    if cmd_name == cmd_arg:
        hits = [(cmd_name, func)]
        break

    if cmd_name.startswith(cmd_arg):
        hits.append((cmd_name, func))

if len(hits) < 1:
    usage()

elif len(hits) > 1:
    sys.stderr.write("Command '%s' is ambigous. Possible are: %s\n" %
                     (cmd_arg, ", ".join([candidate for (candidate, _f) in hits])))

else:
    hits[0][1](sys.argv[2:])