#!/usr/bin/env python

import unittest

from interp import baker
from interp.baker import Answer


class Test(unittest.TestCase):
    def setUp(self):
        self.l = [[-1, 1], [-1, 0], [-1, 1], [0, -1],
                    [0, 0], [0, 1], [1, -1], [1, 0], [1, 1]]
        self.all_points = [
                              [0, 0],   # 0
                              [1, 0],   # 1
                              [1, 1],   # 2
                              [0, 1],   # 3
                              [1, -1],   # 4
                              [0, -1],   # 5
                              [-1, 1],   # 6
                              [-1, 0],   # 7
                              [-1, -1],   # 8
                         ]
        self.q = [1, 0, 0, 0, 0, 0, 0, 0, 0]
        self.X = [0.5, 0.25]
        self.accuracy = 8

    def testImports(self):
        import numpy
        import scipy
        import interp.grid as gv
        import interp.baker as bv

        numpy.__version__
        scipy.__version__

        gv, bv

    def testGetPhis(self):
        X = [0, 0]
        r = [[-1, -1], [0, 2], [1, -1]]

        result = baker.get_phis(X, r)

        right_answer = [1 / 3.0, 1 / 3.0, 1 / 3.0]

        for a, b in zip(result, right_answer):
            self.assertAlmostEqual(a, b)

    def testGetPhis2(self):
        X = [0.5, 0.25]
        r = [[0, 0], [1, 0], [1, 1]]

        result = baker.get_phis(X, r)

        right_answer = [0.5, 0.25, 0.25]

        for a, b in zip(result, right_answer):
            self.assertEqual(a, b)

    def testQlinear(self):
        X = [0.5, 0.25]
        r = [[0, 0], [1, 0], [1, 1]]
        q = [1, 0, 0]

        phi, result = baker.qlinear(X, r, q)

        right_answer = 0.5

        self.assertAlmostEqual(result, right_answer)

    def testRunBaker_linear(self):
        size_of_simplex = 3

        R, R_q = (self.all_points[:size_of_simplex],
                                 self.q[:size_of_simplex])

        answer = baker.interpolate(self.X, R, R_q)
        good_answer = Answer(qlin=0.5, final=None, error=None, abc={})
        self.assertEqual(answer, good_answer)

    def testRunBaker_1(self):
        size_of_simplex = 3
        extra_points = 3

        R, R_q = (self.all_points[:size_of_simplex],
                                 self.q[:size_of_simplex])

        S, S_q = (self.all_points[size_of_simplex:size_of_simplex \
                                                 + extra_points],
                        self.q[size_of_simplex:size_of_simplex + extra_points])

        answer = baker.interpolate(self.X, R, R_q, S, S_q)

        a = answer.abc[0]
        b = answer.abc[1]
        c = answer.abc[2]

        self.assertEqual(sorted((a, b, c)), sorted((0, 0.0, 1 / 3.)))

    def testRunBaker_2(self):
        size_of_simplex = 3
        extra_points = 4

        R, R_q = (self.all_points[:size_of_simplex], self.q[:size_of_simplex])

        S, S_q = (self.all_points[size_of_simplex:size_of_simplex \
                                        + extra_points],
                        self.q[size_of_simplex:size_of_simplex + extra_points])

        answer = baker.interpolate(self.X, R, R_q, S, S_q)

        a, b, c = sorted(answer.abc)
        aa, bb, cc = sorted((2 / 3.0, 2 / 3.0, 1 / 3.0))

        self.assertAlmostEqual(a, aa)
        self.assertAlmostEqual(b, bb)
        self.assertAlmostEqual(c, cc)

    def testRunBaker_3(self):
        size_of_simplex = 3
        extra_points = 5

        R, R_q = (self.all_points[:size_of_simplex], self.q[:size_of_simplex])

        S, S_q = (self.all_points[size_of_simplex:size_of_simplex \
                                    + extra_points],
                        self.q[size_of_simplex:size_of_simplex + extra_points])
        answer = baker.interpolate(self.X, R, R_q, S, S_q)

        a = answer.abc[0]
        b = answer.abc[1]
        c = answer.abc[2]

        a, b, c = sorted((a, b, c))
        aa, bb, cc = sorted((13 / 14., 2 / 7., 15 / 14.))

        self.assertAlmostEqual(a, aa)
        self.assertAlmostEqual(b, bb)
        self.assertAlmostEqual(c, cc)

    def testRunBaker_4(self):
        size_of_simplex = 3
        extra_points = 6

        R, R_q = (self.all_points[:size_of_simplex],
                                                 self.q[:size_of_simplex])
        S, S_q = (self.all_points[size_of_simplex:size_of_simplex \
                                            + extra_points],
                        self.q[size_of_simplex:size_of_simplex + extra_points])
        answer = baker.interpolate(self.X, R, R_q, S, S_q)

        a = answer.abc[0]
        b = answer.abc[1]
        c = answer.abc[2]

        a, b, c = sorted((a, b, c))
        aa, bb, cc = sorted((48 / 53.0, 15 / 53.0, 54 / 53.0))

        self.assertAlmostEqual(a, aa)
        self.assertAlmostEqual(b, bb)
        self.assertAlmostEqual(c, cc)

if __name__ == '__main__':
    suite = unittest.TestLoader().loadTestsFromTestCase(Test)
    unittest.TextTestRunner(verbosity=3).run(suite)