import filecmp
import os.path
import numpy as np
import unittest
from numpy.lib.function_base import diff


def find_relative_errors(path_original, path):
    binary_original = np.load(path_original)
    binary = np.load(path)

<<<<<<< Updated upstream
    diffs = binary_original - binary

    binary_original = binary_original.tolist()
    diffs = diffs.tolist()
    relative_errors = []

    for x in range(len(diffs)):
        for y in range(len(diffs)):
            for z in range(len(diffs)):
                if type(diffs[x][y][z]) != type([]):
                    relative_error = (
                        0
                        if binary_original[x][y][z] == 0
                        else diffs[x][y][z] / binary_original[x][y][z]
                    )
                    relative_errors.append(abs(relative_error))
                else:
                    for w in range(len(diffs)):
                        relative_error = (
                            0
                            if binary_original[x][y][z][w] == 0
                            else diffs[x][y][z][w] / binary_original[x][y][z][w]
                        )
                        relative_errors.append(abs(relative_error))

    return relative_errors


BINARIES = ["Cmap", "D", "P", "V", "k"]

=======
    diffs = np.divide(binary_original - binary, binary_original)
    comparisons = np.array([(abs(x) < 0.01).all() for x in diffs])
    return comparisons.all()

BINARIES = ['Cmap', 'D', 'P', 'V', 'k']
>>>>>>> Stashed changes

class TestIntegration(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        os.chdir("../..")
        config_file = os.path.abspath("./tests/integration/conf_test.ini")
        os.system(f"CONFIG_FILE_PATH={config_file} mpirun -np 1 python3 mpirunner.py")

        binary_results = {}
        for binary in BINARIES:
            binary_results[binary] = []

        for i in range(90):
            for binary in BINARIES:
                path = "./tests/integration/tmp_output/{}/{}.npy".format(i, binary)
                path_original = "./test_loop/{}/{}.npy".format(i, binary)
                relative_errors = find_relative_errors(path_original, path)
                binary_results[binary].append(relative_errors)

        cls.binary_stats = {}
        for binary in binary_results:
            binary_results[binary] = [
                item for sublist in binary_results[binary] for item in sublist
            ]
            if len(binary_results[binary]) != 0:
                cls.binary_stats[binary] = {
                    "max": max(binary_results[binary]),
                    "avg": sum(binary_results[binary]) / len(binary_results[binary]),
                }

    @classmethod
    def tearDownClass(cls):
        os.system("rm -rf ./tests/integration/tmp_output")

    def test_Cmap_binary(self):
        cmap_stats = self.binary_stats["Cmap"]
        self.assertEqual(cmap_stats["max"], 0.0)
        self.assertEqual(cmap_stats["avg"], 0.0)

    def test_k_binary(self):
        k_stats = self.binary_stats["k"]
        self.assertEqual(k_stats["max"], 0.0)
        self.assertEqual(k_stats["avg"], 0.0)

    def test_P_binary(self):
        P_stats = self.binary_stats["P"]
        self.assertLess(P_stats["max"], 0.5)
        self.assertLess(P_stats["avg"], 0.0005)

    def test_D_binary(self):
        D_stats = self.binary_stats["D"]
        self.assertLess(D_stats["max"], 900)
        self.assertLess(D_stats["avg"], 0.006)

    def test_V_binary(self):
        V_stats = self.binary_stats["V"]
        self.assertLess(V_stats["max"], 10)
        self.assertLess(V_stats["avg"], 0.05)


if __name__ == "__main__":
    unittest.main()