import logging
import unittest

import numpy as np

import trimesh

try:
    from . import generic as g
except BaseException:
    import generic as g

TEST_DIM = (100, 3)
TOL_ZERO = 1e-9
TOL_CHECK = 1e-2

log = logging.getLogger("trimesh")
log.addHandler(logging.NullHandler())


class VectorTests(unittest.TestCase):
    def setUp(self):
        self.test_dim = TEST_DIM

    def test_unitize_multi(self):
        vectors = np.ones(self.test_dim)
        vectors[0] = [0, 0, 0]
        vectors, valid = trimesh.unitize(vectors, check_valid=True)

        assert not valid[0]
        assert valid[1:].all()

        length = np.sum(vectors[1:] ** 2, axis=1) ** 0.5
        assert np.allclose(length, 1.0)

    def test_align(self):
        log.info("Testing vector alignment")
        target = np.array([0, 0, 1])
        for _i in range(100):
            vector = trimesh.unitize(np.random.random(3) - 0.5)
            T = trimesh.geometry.align_vectors(vector, target)
            result = np.dot(T, np.append(vector, 1))[0:3]
            aligned = np.abs(result - target).sum() < TOL_ZERO
            self.assertTrue(aligned)


class UtilTests(unittest.TestCase):
    def test_bounds_tree(self):
        for _attempt in range(3):
            for dimension in [2, 3]:
                t = g.random((1000, 3, dimension))
                bounds = g.np.column_stack((t.min(axis=1), t.max(axis=1)))
                tree = g.trimesh.util.bounds_tree(bounds)
                self.assertTrue(0 in tree.intersection(bounds[0]))

    def test_stack(self):
        # shortcut to the function
        f = g.trimesh.util.stack_3D
        # start with some random points
        p = g.random((100, 2))
        stack = f(p)
        # shape should be 3D
        assert stack.shape == (100, 3)
        # points should be equal
        assert g.np.allclose(p, stack[:, :2])

        # check an empty array
        assert f([]).shape == (0,)

        try:
            # try with 4D points
            f(g.np.ones((100, 4)))
            raise AssertionError()
        except ValueError:
            # this is what should happen
            pass

    def test_chain(self):
        from trimesh.util import chain

        # should work on iterables the same as `itertools.chain`
        assert g.np.allclose(chain([1, 3], [4]), [1, 3, 4])
        # should work with non-iterable single values
        assert g.np.allclose(chain([1, 3], 4), [1, 3, 4])
        # should filter out `None` arguments
        assert g.np.allclose(chain([1, 3], None, 4, None), [1, 3, 4])

    def test_has_module(self):
        # built-in
        assert g.trimesh.util.has_module("collections")
        # required for everything
        assert g.trimesh.util.has_module("numpy")
        # not-a-thing
        assert not g.trimesh.util.has_module("foobarrionananan")

    def test_strips(self):
        """
        Test our conversion of triangle strips to face indexes.
        """

        def strips_to_faces(strips):
            """
            A slow but straightforward version of the function to test against
            """
            faces = g.collections.deque()
            for s in strips:
                s = g.np.asanyarray(s, dtype=g.np.int64)
                # each triangle is defined by one new vertex
                tri = g.np.column_stack([g.np.roll(s, -i) for i in range(3)])[:-2]
                # we need to flip ever other triangle
                idx = (g.np.arange(len(tri)) % 2).astype(bool)
                tri[idx] = g.np.fliplr(tri[idx])
                faces.append(tri)
            # stack into one (m,3) array
            faces = g.np.vstack(faces)
            return faces

        # test 4- triangle strip
        s = [g.np.arange(6)]
        f = g.trimesh.util.triangle_strips_to_faces(s)
        assert (f == g.np.array([[0, 1, 2], [3, 2, 1], [2, 3, 4], [5, 4, 3]])).all()
        assert len(f) + 2 == len(s[0])
        assert (f == strips_to_faces(s)).all()

        # test single triangle
        s = [g.np.arange(3)]
        f = g.trimesh.util.triangle_strips_to_faces(s)
        assert (f == g.np.array([[0, 1, 2]])).all()
        assert len(f) + 2 == len(s[0])
        assert (f == strips_to_faces(s)).all()

        s = [g.np.arange(100)]
        f = g.trimesh.util.triangle_strips_to_faces(s)
        assert len(f) + 2 == len(s[0])
        assert (f == strips_to_faces(s)).all()

    def test_pairwise(self):
        # check to make sure both itertools and numpy
        # methods return the same result
        pa = np.array(list(g.trimesh.util.pairwise(range(5))))
        pb = g.trimesh.util.pairwise(np.arange(5))

        # make sure results are the same from both methods
        assert (pa == pb).all()
        # make sure we have 4 pairs for 5 values
        assert len(pa) == 4
        # make sure all pairs are length 2
        assert all(len(i) == 2 for i in pa)

    def test_concat(self):
        a = g.get_mesh("ballA.off")
        b = g.get_mesh("ballB.off")

        hA = a.__hash__()
        hB = b.__hash__()

        # make sure we're not mutating original mesh
        for _i in range(4):
            c = a + b
            assert g.np.isclose(c.volume, a.volume + b.volume)
            assert a.__hash__() == hA
            assert b.__hash__() == hB

        count = 5
        meshes = []
        for _i in range(count):
            m = a.copy()
            m.apply_translation([a.scale, 0, 0])
            meshes.append(m)

        # do a multimesh concatenate
        r = g.trimesh.util.concatenate(meshes)
        assert g.np.isclose(r.volume, a.volume * count)
        assert a.__hash__() == hA

    def test_concat_vertex_normals(self):
        # vertex normals should only be included if they already exist

        a = g.trimesh.creation.icosphere().apply_translation([1, 0, 0])
        assert "vertex_normals" not in a._cache

        b = g.trimesh.creation.icosphere().apply_translation([-1, 0, 0])
        assert "vertex_normals" not in b._cache

        c = g.trimesh.util.concatenate([a, b])
        assert "vertex_normals" not in c._cache

        rando = g.trimesh.unitize(g.random(a.vertices.shape))
        a.vertex_normals = rando
        assert "vertex_normals" in a._cache

        c = g.trimesh.util.concatenate([a, b])
        assert "vertex_normals" in c._cache
        # should have included the rando normals
        assert g.np.allclose(c.vertex_normals[: len(a.vertices)], rando)

    def test_concat_face_normals(self):
        # face normals should only be included if they already exist
        a = g.trimesh.creation.icosphere().apply_translation([1, 0, 0])
        assert "face_normals" not in a._cache

        b = g.trimesh.creation.icosphere().apply_translation([-1, 0, 0])
        assert "face_normals" not in b._cache

        c = g.trimesh.util.concatenate([a, b])
        assert "face_normals" not in c._cache

        # will generate normals
        _ = a.face_normals
        assert "face_normals" in a._cache

        c = g.trimesh.util.concatenate([a, b])
        assert "face_normals" in c._cache

    def test_unique_id(self):
        num_ids = 10000

        g.trimesh.util.random.seed(0)
        unique_ids_0 = []
        for _i in range(num_ids):
            s = g.trimesh.util.unique_id()
            unique_ids_0.append(s)

        # make sure every id is truly unique
        assert len(unique_ids_0) == len(g.np.unique(unique_ids_0))

        g.trimesh.util.random.seed(0)
        unique_ids_1 = []
        for i in range(num_ids):
            s = g.trimesh.util.unique_id()
            unique_ids_1.append(s)

            # make sure id's can be reproduced
            assert s == unique_ids_0[i]

    def test_unique_name(self):
        from trimesh.util import unique_name

        assert len(unique_name(None, {})) > 0
        assert len(unique_name("", {})) > 0

        count = 10
        names = set()
        for _i in range(count):
            names.add(unique_name("hi", names))
        assert len(names) == count

        names = set()
        for _i in range(count):
            names.add(unique_name("", names))
        assert len(names) == count

        # Try with a larger set of names
        # get some random strings
        names = [g.uuid4().hex for _ in range(20)]
        # make it a whole lotta duplicates
        names = names * 1000
        # add a non-int postfix to test
        names.extend(["suppp_hi"] * 10)

        assigned = set()
        with g.Profiler() as P:
            for name in names:
                assigned.add(unique_name(name, assigned))
        g.log.debug(P.output_text())

        assigned_new = set()
        # tracker = UniqueName()\
        counts = {}
        with g.Profiler() as P:
            for name in names:
                assigned_new.add(unique_name(name, contains=assigned_new, counts=counts))
        g.log.debug(P.output_text())

        # new scheme should match the old one
        assert assigned_new == assigned
        # de-duplicated set should match original length
        assert len(assigned) == len(names)


class ContainsTest(unittest.TestCase):
    def test_inside(self):
        sphere = g.trimesh.primitives.Sphere(radius=1.0, subdivisions=4)
        g.log.info("Testing contains function with sphere")
        samples = (np.random.random((1000, 3)) - 0.5) * 5
        radius = np.linalg.norm(samples, axis=1)

        margin = 0.05
        truth_in = radius < (1.0 - margin)
        truth_out = radius > (1.0 + margin)

        contains = sphere.contains(samples)

        if not contains[truth_in].all():
            raise ValueError("contains test does not match truth!")

        if contains[truth_out].any():
            raise ValueError("contains test does not match truth!")


class IOWrapTests(unittest.TestCase):
    def test_io_wrap(self):
        util = g.trimesh.util

        # check wrap_as_stream
        test_b = g.random(1).tobytes()
        test_s = "this is a test yo"
        res_b = util.wrap_as_stream(test_b).read()
        res_s = util.wrap_as_stream(test_s).read()
        assert res_b == test_b
        assert res_s == test_s

        # check __enter__ and __exit__
        hi = b"hi"
        with util.BytesIO(hi) as f:
            assert f.read() == hi

        # check __enter__ and __exit__
        hi = "hi"
        with util.StringIO(hi) as f:
            assert f.read() == hi


class CompressTests(unittest.TestCase):
    def test_compress(self):
        source = {"hey": "sup", "naa": "2002211"}

        # will return bytes
        c = g.trimesh.util.compress(source)

        # wrap bytes as file- like object
        f = g.trimesh.util.wrap_as_stream(c)
        # try to decompress file- like object
        d = g.trimesh.util.decompress(f, file_type="zip")

        # make sure compressed- decompressed items
        # are the same after a cycle
        for key, value in source.items():
            result = d[key].read().decode("utf-8")
            assert result == value


class UniqueTests(unittest.TestCase):
    def test_unique(self):
        options = [
            np.array([0, 1, 2, 3, 1, 3, 10, 20]),
            np.arange(100),
            np.array([], dtype=np.int64),
            (np.random.random(1000) * 10).astype(int),
        ]

        for values in options:
            if len(values) > 0:
                minlength = values.max()
            else:
                minlength = 10

            # try our unique bincount function
            unique, inverse, counts = g.trimesh.grouping.unique_bincount(
                values, minlength=minlength, return_inverse=True, return_counts=True
            )
            # make sure inverse is correct
            assert (unique[inverse] == values).all()

            # make sure that the number of counts matches
            # the number of unique values
            assert len(unique) == len(counts)

            # get the truth
            truth_unique, truth_inverse, truth_counts = np.unique(
                values, return_inverse=True, return_counts=True
            )
            # make sure truth is doing what we think
            assert (truth_unique[truth_inverse] == values).all()

            # make sure we have same number of values
            assert len(truth_unique) == len(unique)

            # make sure all values are identical
            assert set(truth_unique) == set(unique)

            # make sure that the truth counts are identical to our counts
            assert np.all(truth_counts == counts)


class CommentTests(unittest.TestCase):
    def test_comment(self):
        # test our comment stripping logic
        f = g.trimesh.util.comment_strip

        text = "hey whats up"
        assert f(text) == text

        text = "#hey whats up"
        assert f(text) == ""

        text = "   # hey whats up "
        assert f(text) == ""

        text = "# naahah\nhey whats up"
        assert f(text) == "hey whats up"

        text = "#naahah\nhey whats up\nhi"
        assert f(text) == "hey whats up\nhi"

        text = "#naahah\nhey whats up\n hi"
        assert f(text) == "hey whats up\n hi"

        text = "#naahah\nhey whats up\n hi#"
        assert f(text) == "hey whats up\n hi"

        text = "hey whats up# see here\n hi#"
        assert f(text) == "hey whats up\n hi"


class ArrayToString(unittest.TestCase):
    def test_converts_an_unstructured_1d_array(self):
        self.assertEqual(g.trimesh.util.array_to_string(np.array([1, 2, 3])), "1 2 3")

    def test_converts_an_unstructured_int_array(self):
        self.assertEqual(
            g.trimesh.util.array_to_string(np.array([[1, 2, 3], [4, 5, 6]])),
            "1 2 3\n4 5 6",
        )

    def test_converts_an_unstructured_float_array(self):
        self.assertEqual(
            g.trimesh.util.array_to_string(
                np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float64)
            ),
            "1.00000000 2.00000000 3.00000000\n4.00000000 5.00000000 6.00000000",
        )

    def test_uses_the_specified_column_delimiter(self):
        self.assertEqual(
            g.trimesh.util.array_to_string(
                np.array([[1, 2, 3], [4, 5, 6]]), col_delim="col"
            ),
            "1col2col3\n4col5col6",
        )

    def test_uses_the_specified_row_delimiter(self):
        self.assertEqual(
            g.trimesh.util.array_to_string(
                np.array([[1, 2, 3], [4, 5, 6]]), row_delim="row"
            ),
            "1 2 3row4 5 6",
        )

    def test_uses_the_specified_value_format(self):
        self.assertEqual(
            g.trimesh.util.array_to_string(
                np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float64), value_format="{:.1f}"
            ),
            "1.0 2.0 3.0\n4.0 5.0 6.0",
        )

    def test_supports_uints(self):
        self.assertEqual(
            g.trimesh.util.array_to_string(np.array([1, 2, 3], dtype=np.uint8)), "1 2 3"
        )

    def test_supports_repeat_format(self):
        self.assertEqual(
            g.trimesh.util.array_to_string(
                np.array([[1, 2, 3], [4, 5, 6]]), value_format="{} {}"
            ),
            "1 1 2 2 3 3\n4 4 5 5 6 6",
        )

    def test_raises_if_array_is_structured(self):
        with self.assertRaises(ValueError):
            g.trimesh.util.array_to_string(
                np.array(
                    [(1, 1.1), (2, 2.2)],
                    dtype=[("some_int", np.int64), ("some_float", np.float64)],
                )
            )

    def test_raises_if_array_is_not_flat(self):
        with self.assertRaises(ValueError):
            g.trimesh.util.array_to_string(np.array([[[1, 2, 3], [4, 5, 6]]]))


class StructuredArrayToString(unittest.TestCase):
    def test_converts_a_structured_array_with_1d_elements(self):
        self.assertEqual(
            g.trimesh.util.structured_array_to_string(
                np.array(
                    [(1, 1.1), (2, 2.2)],
                    dtype=[("some_int", np.int64), ("some_float", np.float64)],
                )
            ),
            "1 1.10000000\n2 2.20000000",
        )

    def test_converts_a_structured_array_with_2d_elements(self):
        self.assertEqual(
            g.trimesh.util.structured_array_to_string(
                np.array(
                    [([1, 2], 1.1), ([3, 4], 2.2)],
                    dtype=[("some_int", np.int64, 2), ("some_float", np.float64)],
                )
            ),
            "1 2 1.10000000\n3 4 2.20000000",
        )

    def test_uses_the_specified_column_delimiter(self):
        self.assertEqual(
            g.trimesh.util.structured_array_to_string(
                np.array(
                    [(1, 1.1), (2, 2.2)],
                    dtype=[("some_int", np.int64), ("some_float", np.float64)],
                ),
                col_delim="col",
            ),
            "1col1.10000000\n2col2.20000000",
        )

    def test_uses_the_specified_row_delimiter(self):
        self.assertEqual(
            g.trimesh.util.structured_array_to_string(
                np.array(
                    [(1, 1.1), (2, 2.2)],
                    dtype=[("some_int", np.int64), ("some_float", np.float64)],
                ),
                row_delim="row",
            ),
            "1 1.10000000row2 2.20000000",
        )

    def test_uses_the_specified_value_format(self):
        self.assertEqual(
            g.trimesh.util.structured_array_to_string(
                np.array(
                    [(1, 1.1), (2, 2.2)],
                    dtype=[("some_int", np.int64), ("some_float", np.float64)],
                ),
                value_format="{:.1f}",
            ),
            "1.0 1.1\n2.0 2.2",
        )

    def test_supports_uints(self):
        self.assertEqual(
            g.trimesh.util.structured_array_to_string(
                np.array(
                    [(1, 1.1), (2, 2.2)],
                    dtype=[("some_int", np.uint8), ("some_float", np.float64)],
                )
            ),
            "1 1.10000000\n2 2.20000000",
        )

    def test_raises_if_array_is_unstructured(self):
        with self.assertRaises(ValueError):
            g.trimesh.util.structured_array_to_string(np.ndarray([1, 2, 3]))

    def test_raises_if_value_format_specifies_repeats(self):
        with self.assertRaises(ValueError):
            g.trimesh.util.structured_array_to_string(
                np.array(
                    [(1, 1.1), (2, 2.2)],
                    dtype=[("some_int", np.int64), ("some_float", np.float64)],
                ),
                value_format="{} {}",
            )

    def test_raises_if_array_is_not_flat(self):
        with self.assertRaises(ValueError):
            g.trimesh.util.structured_array_to_string(
                np.array(
                    [[(1, 1.1), (2, 2.2)], [(1, 1.1), (2, 2.2)]],
                    dtype=[("some_int", np.int64), ("some_float", np.float64)],
                )
            )


if __name__ == "__main__":
    trimesh.util.attach_to_log()
    unittest.main()