"""This module asserts correct runtime behaviour of various additional helpers."""

# Python Standard Library
from math import tau

# Generic testing
from unittest import TestCase

# Hypothesis testing
import hypothesis.extra.numpy as st_numpy
from hypothesis import given
import hypothesis.strategies as st

# Scientific
import numpy as np
from numpy.testing import assert_almost_equal

# Module under test
from pyrate.plan.geometry.helpers import cartesian_to_spherical
from pyrate.plan.geometry.helpers import difference_latitude
from pyrate.plan.geometry.helpers import difference_longitude
from pyrate.plan.geometry.helpers import mean_angle
from pyrate.plan.geometry.helpers import mean_coordinate
from pyrate.plan.geometry.helpers import meters2rad
from pyrate.plan.geometry.helpers import rad2meters

# Own strategies
from pyrate.common.testing.strategies.geometry import geo_bearings


_POSITIVE_FLOATS = st.floats(min_value=0.0, max_value=1e9, allow_infinity=False, allow_nan=False)


class TestRadiansAndMeterConversion(TestCase):
    """Makes sure the conversion between meters and radians works."""

    @given(_POSITIVE_FLOATS)
    def test_is_reversible_float(self, meters: float) -> None:
        """Tests that the two functions are the reverse of each other."""
        self.assertAlmostEqual(meters, rad2meters(meters2rad(meters)), places=5)

    @given(st_numpy.arrays(dtype=float, shape=st_numpy.array_shapes(), elements=_POSITIVE_FLOATS))
    def test_is_reversible_numpy(self, meters: np.ndarray) -> None:  # pylint: disable=no-self-use
        """Tests that the two functions are the reverse of each other."""
        assert_almost_equal(meters, rad2meters(meters2rad(meters)), decimal=5)


class TestCartesianToSpherical(TestCase):
    """Makes sure the conversion from cartesian to spherical coordinates works."""

    def test_raises_if_not_on_unit_sphere(self) -> None:
        """Asserts that an exception is raised if values are not on the unit sphere."""
        with self.assertRaises(AssertionError):
            cartesian_to_spherical(np.array([(10, 20, 30)]))

    def test_specific_values(self) -> None:  # pylint: disable=no-self-use
        """Asserts that an exception is raised if values are not on the unit sphere."""
        data_in = np.array([(1, 0, 0), (0, 1, 0), (0, 0, 1), (0.5, 0.5, np.sqrt(1 - 0.5**2 - 0.5**2))])
        expected_data_out = np.array([(0, 0), (0, np.pi / 2), (-np.pi / 2, 0), (-np.pi / 4, np.pi / 4)]).T

        assert_almost_equal(cartesian_to_spherical(data_in), expected_data_out)


class TestAngleAndCoordinateMean(TestCase):
    """Makes sure the mean computation and angles and coordinates works correctly."""

    @given(geo_bearings(), st.floats(min_value=0.0, max_value=1e-9))
    def test_raises_if_ambiguous(self, angle: float, noise: float) -> None:
        """Asserts that an exception is raised if no sensible mean can be calculated."""

        ambiguous_pair = np.array([angle, (angle + 180 + noise) % 360])
        with self.assertRaises(ValueError):
            mean_angle(np.radians(ambiguous_pair))
        with self.assertRaises(ValueError):
            mean_coordinate(np.array([0.0, 67.2]), ambiguous_pair)

        # But the methods should recover from an exception on the latitude mean computation
        latitude, _ = mean_coordinate(ambiguous_pair, np.array([0.0, 67.2]))
        self.assertAlmostEqual(latitude, 0.0)

    @given(
        st_numpy.arrays(
            elements=st.floats(min_value=0.0, max_value=np.pi), dtype=float, shape=st_numpy.array_shapes()
        )
    )
    def test_mean_angle_is_in_valid_range(self, data: np.ndarray) -> None:
        """Asserts that means are never negative and always between ``0°`` and ``360°``."""

        try:
            mean = mean_angle(data)
            self.assertGreaterEqual(mean, 0.0)
            self.assertLessEqual(mean, np.pi)

        except ValueError:
            pass  # this might happen with the generated values and is okay

    @given(geo_bearings(), st.floats(min_value=0.0, max_value=170))
    def test_obvious_values_angle(self, angle: float, difference: float) -> None:
        """Asserts that the result is sensible for known values."""

        mean = mean_angle(np.radians(np.array([angle, (angle + difference) % 360])))
        self.assertAlmostEqual(mean, np.radians((angle + difference / 2)) % tau, delta=1e-6)

    @given(
        st.floats(min_value=-80.0, max_value=+80.0),
        st.floats(min_value=-170.0, max_value=+170.0),
        st.floats(min_value=-9.0, max_value=9.0),
        st.floats(min_value=-9.0, max_value=9.0),
    )
    def test_obvious_values_coordinate(
        self, latitude: float, longitude: float, lat_delta: float, lon_delta: float
    ) -> None:
        """Asserts that the result is sensible for known values."""

        lat_mean, lon_mean = mean_coordinate(
            latitudes=np.array([latitude, latitude + lat_delta]),
            longitudes=np.array([longitude, longitude + lon_delta]),
        )
        self.assertLessEqual(difference_latitude(lat_mean, (latitude + lat_delta / 2)), 1e-6)
        self.assertLessEqual(difference_longitude(lon_mean, (longitude + lon_delta / 2)), 1e-6)