# vim: set fileencoding=utf-8 :
from copy import deepcopy


class Node(object):
    def __init__(self, value, *nodes, **kwargs):
        super(Node, self).__init__()
        self.value, self.nodes = value, list(nodes)
        self.is_leaf = False
        self.no_spacing = kwargs.get('no_spacing', False)
        self.negated = kwargs.get('negated', 0)

    def __getitem__(self, n):
        return self.nodes[n]

    def __setitem__(self, n, node):
        self.nodes[n] = node

    def __iter__(self):
        return iter(self.nodes)

    def __len__(self):
        return len(self.nodes)

    def __eq__(self, node):
        return isinstance(node, Node) and self.value == node.value \
               and self.nodes == node.nodes

    def __neg__(self):
        copied = self.clone()
        copied.negated += 1

        return copied

    def __pos__(self):
        copied = self.clone()
        copied.negated = max(copied.negated - 1, 0)

        return copied

    def __str__(self):
        return '<Node value=%s nodes=%s negated=%d>' \
               % (str(self.value), str(self.nodes), self.negated)

    def __repr__(self):
        return self.__str__()

    def title(self):
        return str(self.value)

    def operator(self):
        return self.value

    def clone(self):
        return deepcopy(self)

    def arity(self):
        return len(self)

    def is_postfix(self):
        return self.value == '\''

    def is_negation(self):
        return self.value == '-' and len(self) == 1

    def custom_line(self):
        pass

    def preprocess_str_exp(self):
        pass

    def postprocess_str(self, string):
        return string


class Leaf(Node):
    def __init__(self, value, **kwargs):
        super(Leaf, self).__init__(value, **kwargs)

        if type(value) in (int, float) and value < 0:
            self.value = abs(value)
            self.negated += 1

        self.nodes = None
        self.is_leaf = True

    def __len__(self):
        return len(str(self.value))

    def __str__(self):
        return '-' * self.negated + str(self.value)

    def __repr__(self):
        return '<Leaf %s>' % repr(str(self))