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

import graph
from node import Node, Leaf
from graph import generate_graph


class TestGraph(unittest.TestCase):

    def test_doctest(self):
        self.assertEqual(doctest.testmod(m=graph)[0], 0)

    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)
        self.assertEqualGraphs(g, """
        -
        │
        1
        """)

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

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

    def test_multichar_binary(self):
        plus = Node('+', self.multi, self.l1)
        g = generate_graph(plus)
        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)
        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)
        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)
        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)
        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)
        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)
        self.assertEqualGraphs(g, """
           sum
        ╭─┬─┼─┬─╮
        0 1 2 3 4
        """)

    def test_expression_small(self):
        l0 = Leaf(3)
        l1 = Leaf(4)
        l2 = Leaf(5)
        l3 = Leaf(7)

        n0 = Node('+', l0, l1)
        n1 = Node('+', l2, l3)
        n2 = Node('*', n0, n1)

        g = generate_graph(n2)
        self.assertEqualGraphs(g, """
           *
         ╭─┴─╮
         +   +
        ╭┴╮ ╭┴╮
        3 4 5 7
        """)

    def test_expression_larger(self):
        a = Leaf(3)
        b = Leaf(4)
        c = Leaf(5)
        d = Leaf(7)

        ac = Node('*', a, c)
        ad = Node('*', a, d)
        bc = Node('*', b, c)
        bd = Node('*', b, d)

        root = Node('+', Node('+', Node('+', ac, ad), bc), bd)

        g = generate_graph(root)
        self.assertEqualGraphs(g, """
                   +
               ╭───┴─╮
               +     *
           ╭───┴─╮  ╭┴╮
           +     *  4 7
         ╭─┴─╮  ╭┴╮
         *   *  4 5
        ╭┴╮ ╭┴╮
        3 5 3 7
        """)

    def strip(self, s):
        return s.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')