# XML "function" nodes that evaluate their contents to text

import datetime

import dates

import exc

import maps

import term

import xml_dom

class SyntaxException(Exception):

    def __init__(self, cause):

        Exception.__init__(self, 'Invalid XML function syntax: '

            +exc.str_(cause))

class FormatException(SyntaxException): pass

def map_items(func, items):

    return [(name, func(value)) for name, value in items]

def conv_items(type_, items):

    def conv(val):

        try: return type_(val)

        except ValueError, e: raise SyntaxException(e)

    return map_items(conv, xml_dom.TextEntryOnlyIter(items))

def alt(items):

    items = list(items)

    items.sort()

    return items[0][1] # value of lowest-numbered item

def merge(items):

    items = list(items)

    items.sort()

    return maps.merge_values(*[v for k, v in items])

def label(items):

    items = dict(conv_items(str, items)) # get *once* from iter and check types

    try:

        label = items['label']

        value = items['value']

    except KeyError, e: raise SyntaxException(e)

    return label+': '+value

def range_(items):

    items = dict(conv_items(float, items))

    from_ = items.get('from', None)

    to = items.get('to', None)

    if from_ == None or to == None: return None

    return str(to - from_)

def avg(items):

    count = 0

    sum_ = 0.

    for name, value in conv_items(float, items):

        count += 1

        sum_ += value

    return str(sum_/count)

def date(items):

    items = conv_items(str, items) # get *once* from iter and check types

    try: str_ = dict(items)['date']

    except KeyError:

        items = dict(filter(lambda (k, v): v != 0, conv_items(int, items)))

        items.setdefault('year', 1900)

        items.setdefault('month', 1)

        items.setdefault('day', 1)

        try: date = datetime.date(**items)

        except ValueError, e: raise SyntaxException(e)

    else:

        try: year = float(str_)

        except ValueError:

            try: import dateutil.parser

            except ImportError: return str_

            try: date = dateutil.parser.parse(str_)

            except ValueError, e: raise SyntaxException(e)

        else: date = (datetime.date(int(year), 1, 1) +

            datetime.timedelta(round((year % 1.)*365)))

    try: return dates.strftime('%Y-%m-%d', date)

    except ValueError, e: raise FormatException(e)

_name_parts_slices_items = [

    ('first', slice(None, 1)),

    ('middle', slice(1, -1)),

    ('last', slice(-1, None)),

]

name_parts_slices = dict(_name_parts_slices_items)

name_parts = [name for name, slice_ in _name_parts_slices_items]

def name(items):

    items = dict(items)

    parts = []

    for part in name_parts:

        if part in items: parts.append(items[part])

    return ' '.join(parts)

def name_part(items):

    out_items = []

    for part, value in items:

        try: slice_ = name_parts_slices[part]

        except KeyError, e: raise SyntaxException(e)

        else: out_items.append((part, ' '.join(value.split(' ')[slice_])))

    return name(out_items)

# Function names must start with _ to avoid collisions with real tags

# Functions take arguments (items)

funcs = {'_alt': alt, '_merge': merge, '_label': label, '_range': range_,

    '_avg': avg, '_date': date, '_name': name, '_namePart': name_part}

def process(node, on_error=exc.raise_):

    for child in xml_dom.NodeElemIter(node): process(child, on_error)

    name = node.tagName

    if name.startswith('_') and name in funcs:

        try: value = funcs[name](xml_dom.NodeTextEntryIter(node))

        except SyntaxException, e:

            str_ = str(node)

            exc.add_msg(e, 'function:\n'+str_)

            xml_dom.replace(node, node.ownerDocument.createComment(

                '\n'+term.emph_multiline(str_)))

            on_error(e)

        else: xml_dom.replace_with_text(node, value)