from commands import registered_cmds
from raw_commands import RawCommand
from formatters import Printer
from example_cmd import example_cmd, echo

import os
import os.path
import shlex

# Load all of the commands in the path into the global namespace as raw
# commands.
for path in os.environ['PATH'].split(':'):
    if os.path.exists(path):
        binaries = os.listdir(path)
        for binary in binaries:
            if binary not in globals():
                globals()[binary] = RawCommand(binary)


def parse_cmd(potential_cmd):
    """Evaluates a potential command. If it exists in the list of
    registered commands, we return a string that would call the
    constructor for that command. If it does not exist, we wrap the
    name of the command with the RawCommand class.

    :return: A string that when evaluated by Python's `eval` feature
        would build an object of the correct type
    """
    args = potential_cmd.strip().split(' ')
    cmd_name = args[0]
    if args:
        args = args[1:]
    if cmd_name not in registered_cmds:
        return "RawCommand({})".format(shlex.split(potential_cmd))
    else:
        return "{0}({1})".format(cmd_name,str(args))


def parse_cmds(raw_input_line):
    """Parses command objects out of a single | separated string"""
    potential_cmds = raw_input_line.split('|')
    cmds = [parse_cmd(cmd) for cmd in potential_cmds]
    return cmds


def handle_input(prompt=""):
    """Gets a single line of input for the REPL, and returns some valid
    Python for the rest of the REPL to evaluate. It's the "R" in REPL.
    If the line begins with ">", we just strip it and evaluate as valid
    Python."""
    raw_input_line = input(prompt)
    if raw_input_line[0] == '>':
        return raw_input_line[1:]
    else:
        cmds = parse_cmds(raw_input_line)
        cmds.append("Printer()")
        mangled_input = cmds[0]
        for cmd in cmds[1:]:
            mangled_input += ".chain(" + cmd + ")"
        mangled_input += ".call()"
        print("[DEBUG]: evaluating Python: ", mangled_input)
        return mangled_input


def main():
    import code
    code.interact("Augmented Unix Userland", handle_input, globals())


if __name__ == '__main__':
    main()