# vim: set fileencoding=utf-8 :
import unittest

from node import Node, Leaf
from graph import generate_graph


class TestGraph(unittest.TestCase):

    def setUp(self):
        self.l0, self.l1, self.multi = Leaf(0), Leaf(1), Leaf('test')

    def tearDown(self):
        pass

    def test_simple_unary(self):
        uminus = Node('-', self.l1)
        g = generate_graph(uminus, Node)
        self.assertEqualGraphs(g, """
        -
        │
        1
        """)

    def test_simple_binary(self):
        plus = Node('+', self.l0, self.l1)
        g = generate_graph(plus, Node)
        self.assertEqualGraphs(g, """
         +
        ╭┴╮
        0 1
        """)

    def test_multichar_unary(self):
        uminus = Node('-', self.multi)
        g = generate_graph(uminus, Node)
        self.assertEqualGraphs(g, """
         -
         │
        test
        """)

    def test_multichar_binary(self):
        plus = Node('+', self.multi, self.l1)
        g = generate_graph(plus, Node)
        self.assertEqualGraphs(g, """
            +
         ╭──┴╮
        test 1
        """)

    def test_ternary(self):
        exp = Leaf('x')
        inf = Leaf('o')
        minus_inf = Node('-', Leaf('L'))
        integral = Node('n', exp, minus_inf, inf)
        g = generate_graph(integral, Node, verbose=True)
        self.assertEqualGraphs(g, """
          n
        ╭─┼─╮
        x - o
          │
          L
        """)

    def test_ternary_multichar(self):
        exp = Leaf('x')
        inf = Leaf('oo')
        minus_inf = Node('-', Leaf('LL'))
        integral = Node('int', exp, minus_inf, inf)
        g = generate_graph(integral, Node, verbose=True)
        self.assertEqualGraphs(g, """
         int
        ╭─┼──╮
        x -  oo
          │
          LL
        """)

    def test_ternary_multichar_middle_right(self):
        exp = Leaf('x')
        minus_99 = Node('-', Leaf('99'))
        minus_inf = Node('-', Leaf('oo'))
        integral = Node('int', exp, minus_inf, minus_99)
        g = generate_graph(integral, Node, verbose=True)
        self.assertEqualGraphs(g, """
         int
        ╭─┼──╮
        x -  -
          │  │
          oo 99
        """)

    def test_ternary_multichar_right(self):
        exp = Leaf('x')
        minus_99 = Node('-', Leaf('99'))
        ten = Leaf('10')
        integral = Node('int', exp, ten, minus_99)
        g = generate_graph(integral, Node, verbose=True)
        self.assertEqualGraphs(g, """
         int
        ╭─┼──╮
        x 10 -
             │
             99
        """)

    def test_quaternary(self):
        a, b, c, d = Leaf(0), Leaf(1), Leaf(2), Leaf(3)
        sum_node = Node('sum', a, b, c, d)
        g = generate_graph(sum_node, Node, verbose=True)
        self.assertEqualGraphs(g, """
          sum
        ╭─┬┴┬─╮
        0 1 2 3
        """)

    def test_quinary(self):
        a, b, c, d, e = Leaf(0), Leaf(1), Leaf(2), Leaf(3), Leaf(4)
        sum_node = Node('sum', a, b, c, d, e)
        g = generate_graph(sum_node, Node, verbose=True)
        self.assertEqualGraphs(g, """
           sum
        ╭─┬─┼─┬─╮
        0 1 2 3 4
        """)

    def strip(self, str):
        return str.replace('\n        ', '\n')[1:-1]

    def assertEqualGraphs(self, g, expect):
        expect = self.strip(expect)

        if g != expect:  # pragma: nocover
            print 'Expected:'
            print expect
            print 'Got:'
            print g
            raise AssertionError('Graph does not match expected value')