#!/usr/bin/env python
"""
filesystem template interpreter
"""

import os
import re
import subprocess
import sys

from optparse import OptionParser


try:
    import tempita
except ImportError:
    raise NotImplementedError

# URL of this file
location = 'http://k0s.org/mozilla/hg/MakeItSo/raw-file/tip/makeitso/makeitso.py'

# regular expressions for finding the shebang
shebang_re = '#!.*makeitso.*'
shebang_re = re.compile(shebang_re)

class MissingVariablesException(Exception):
    def __init__(self, message, missing):
        self.missing = missing

def call(command, *args, **kw):
    code = subprocess.call(command, *args, **kw)
    if code:
        if isinstance(command, basestring):
            cmdstr = command
        else:
            cmdstr = ' '.join(command)
        raise SystemExit("Command `%s` exited with code %d" % (cmdstr, code))

def get_missing(name_error):
    """
    This is a horrible hack because python doesn't do the proper thing
    via eval and return the name of the variable;  instead, it just gives
    you a message:
    >>> try:
    ...   eval('2*foo')
    ... except Exception, e:
    ...   pass
    """
    message = name_error.args[0]
    varname = message.split("'")[1]
    return varname

def missing_variables(template, variables):
    """return additional variables needed"""
    vars = variables.copy()
    missing = set([])
    while True:
        try:
            template.substitute(**vars)
            return missing
        except NameError, e:
            missed = get_missing(e)
            missing.add(missed)
            vars[missed] = ''
    return missing

def template_variables(template):
    """return the variables needed for a template"""
    return missing_variables(template, {})

def read_variables(variables):
    retval = {}
    for i in variables:
        print 'Enter %s: ' % i,
        retval[i] = raw_input()
    return retval
        
def substitute(content, fp=sys.stdout, variables=None):

    # remove makeitso shebang if it has one
    if shebang_re.match(content):
        content = os.linesep.join(content.splitlines()[1:])

    variables = variables or {}
    template = Template(content)
    missing = missing_variables(template, variables)
    if missing:
        # TODO: add a switch for interactive or not
        variables.update(read_variables(missing))
    print >> fp, template.substitute(**variables)

def invocation(url, **variables):
    """returns a string appropriate for TTW invocation"""
    variables_string = ' '.join(['%s=%s' % (i,j) for i,j in variables.items()])
    return 'python <(curl %s) %s %s' % (location, url, variables_string)

def main(args=sys.argv[1:]):

    # create option parser
    usage = '%prog [options] template <template> <...>'
    parser = OptionParser(usage, description=__doc__)
    parser.add_option('-[', '--start-braces', dest='start_braces',
                      help='starting delimeter')
    parser.add_option('-]', '--end-braces', dest='end_braces',
                      help='starting delimeter')
    parser.add_option('--commandline', dest='commandline',
                      action='store_true', default=False,
                      help="print the commandline to invoke this script TTW")
    parser.add_option('--variables', dest='variables',
                      action='store_true', default=False,
                      help='print the variables in a template')
    options, args = parser.parse_args(args)

    # print the variables for the templates
    if options.variables:

        # makes no sense without a template
        if not args:
            parser.print_usage()
            parser.exit()

        # find all variables
        variables = set()
        for arg in args:
            content = file(arg).read()
            template = Template(content)
            variables.update(template_variables(template))

        # print them
        for variable in variables:
            print variable
        return

    # template variables
    variables = {}
    _vars = []
    _args = []
    for arg in args:
        if '=' in arg:
            key, value = arg.split('=')
            variables[key] = value
        else:
            _args.append(arg)
    args = _args

    # print TTW commandline for invocation
    if options.commandline:
        if args:
            for arg in args:
                print invocation(arg, **variables)
        else:
            print invocation('[URL]', **variables)
        return

    # get the content
    if args:
        for arg in args:
            content = file(arg).read()
            substitute(content, variables=variables)
    else:
        content = sys.stdin.read()
        substitute(content, variables=variables)
        
if __name__ == '__main__':
    main()