"""Bring time stamps of generated checked-in files into the right order

A versioned configuration file .hgtouch specifies generated files, in the
syntax of make rules.

  output:    input1 input2

In addition to the dependency syntax, #-comments are supported.
"""
import errno
import os
import time

def parse_config(repo):
    try:
        fp = repo.wfile(".hgtouch")
    except IOError, e:
        if e.errno != errno.ENOENT:
            raise
        return {}
    result = {}
    with fp:
        for line in fp:
            # strip comments
            line = line.split('#')[0].strip()
            if ':' not in line:
                continue
            outputs, inputs = line.split(':', 1)
            outputs = outputs.split()
            inputs = inputs.split()
            for o in outputs:
                try:
                    result[o].extend(inputs)
                except KeyError:
                    result[o] = inputs
    return result

def check_rule(ui, repo, modified, basedir, output, inputs):
    """Verify that the output is newer than any of the inputs.
    Return (status, stamp), where status is True if the update succeeded,
    and stamp is the newest time stamp assigned  to any file (might be in
    the future).

    If basedir is nonempty, it gives a directory in which the tree is to
    be checked.
    """
    f_output = repo.wjoin(os.path.join(basedir, output))
    try:
        o_time = os.stat(f_output).st_mtime
    except OSError:
        ui.warn("Generated file %s does not exist\n" % output)
        return False, 0
    youngest = 0   # youngest dependency
    backdate = None
    backdate_source = None
    for i in inputs:
        f_i = repo.wjoin(os.path.join(basedir, i))
        try:
            i_time = os.stat(f_i).st_mtime
        except OSError:
            ui.warn(".hgtouch input file %s does not exist\n" % i)
            return False, 0
        if i in modified:
            # input is modified. Need to backdate at least to i_time
            if backdate is None or backdate > i_time:
                backdate = i_time
                backdate_source = i
            continue
        youngest = max(i_time, youngest)
    if backdate is not None:
        ui.warn("Input %s for file %s locally modified\n" % (backdate_source, output))
        # set to 1s before oldest modified input
        backdate -= 1
        os.utime(f_output, (backdate, backdate))
        return False, 0
    if youngest >= o_time:
        ui.note("Touching %s\n" % output)
        youngest += 1
        os.utime(f_output, (youngest, youngest))
        return True, youngest
    else:
        # Nothing to update
        return True, 0

def do_touch(ui, repo, basedir):
    if basedir:
        if not os.path.isdir(repo.wjoin(basedir)):
            ui.warn("Abort: basedir %r does not exist\n" % basedir)
            return
        modified = []
    else:
        modified = repo.status()[0]
    dependencies = parse_config(repo)
    success = True
    tstamp = 0       # newest time stamp assigned
    # try processing all rules in topological order
    hold_back = {}
    while dependencies:
        output, inputs = dependencies.popitem()
        # check whether any of the inputs is generated
        for i in inputs:
            if i in dependencies:
                hold_back[output] = inputs
                continue
        _success, _tstamp = check_rule(ui, repo, modified, basedir, output, inputs)
        success = success and _success
        tstamp = max(tstamp, _tstamp)
        # put back held back rules
        dependencies.update(hold_back)
        hold_back = {}
    now = time.time()
    if tstamp > now:
        # wait until real time has passed the newest time stamp, to
        # avoid having files dated in the future
        time.sleep(tstamp-now)
    if hold_back:
        ui.warn("Cyclic dependency involving %s\n" % (' '.join(hold_back.keys())))
        return False
    return success

def touch(ui, repo, basedir):
    "touch generated files that are older than their sources after an update."
    do_touch(ui, repo, basedir)

cmdtable = {
    "touch": (touch,
              [('b', 'basedir', '', 'base dir of the tree to apply touching')],
              "hg touch [-b BASEDIR]")
}