import math

import numpy as np
import pytest

from scipy._lib._util import AxisError
from scipy._lib._array_api import make_xp_test_case, eager_warns, is_numpy
from scipy._lib._array_api_no_0d import xp_assert_equal, xp_assert_close
from scipy._external import array_api_extra as xpx

from scipy import stats
from scipy.stats import variation
from scipy.stats._axis_nan_policy import (too_small_nd_omit, too_small_nd_not_omit,
                                          SmallSampleWarning)

lazy_xp_modules = [stats]
skip_xp_backends = pytest.mark.skip_xp_backends


@make_xp_test_case(variation)
class TestVariation:
    """
    Test class for scipy.stats.variation
    """

    def test_ddof(self, xp):
        x = xp.arange(9.0)
        xp_assert_close(variation(x, ddof=1), xp.asarray(math.sqrt(60/8)/4))

    @pytest.mark.parametrize('sgn', [1, -1])
    def test_sign(self, sgn, xp):
        x = xp.asarray([1., 2., 3., 4., 5.])
        v = variation(sgn*x)
        expected = xp.asarray(sgn*math.sqrt(2)/3)
        xp_assert_close(v, expected, rtol=1e-10)

    @skip_xp_backends(np_only=True, reason="test plain python scalar input")
    def test_scalar(self, xp):
        # A scalar is treated like a 1-d sequence with length 1.
        assert variation(4.0) == 0.0

    @pytest.mark.parametrize('nan_policy, expected',
                             [('propagate', np.nan),
                              ('omit', math.sqrt(20/3)/4)])
    @skip_xp_backends(eager_only=True, reason='lazy -> limited nan_policy support')
    def test_variation_nan(self, nan_policy, expected, xp):
        x = xp.arange(10.)
        x[9] = xp.nan
        xp_assert_close(variation(x, nan_policy=nan_policy), xp.asarray(expected))

    @skip_xp_backends(eager_only=True, reason='lazy -> limited nan_policy support')
    def test_nan_policy_raise(self, xp):
        x = xp.asarray([1.0, 2.0, xp.nan, 3.0])
        with pytest.raises(ValueError, match='input contains nan'):
            variation(x, nan_policy='raise')

    @skip_xp_backends("dask.array", reason='needs `_axis_nan_policy`')
    def test_bad_nan_policy(self, xp):
        with pytest.raises(ValueError, match='must be one of'):
            variation(xp.asarray([1, 2, 3]), nan_policy='foobar')

    @skip_xp_backends("dask.array", reason='needs `_axis_nan_policy`')
    def test_keepdims(self, xp):
        x = xp.reshape(xp.arange(10), (2, 5))
        y = variation(x, axis=1, keepdims=True)
        expected = 2**0.5 / xp.asarray([[2.], [7.]])
        xp_assert_close(y, expected)

    @skip_xp_backends("dask.array", reason='needs `_axis_nan_policy`')
    @pytest.mark.parametrize('axis, expected',
                             [(0, np.empty((1, 0)).tolist()),
                              (1, np.full((5, 1), fill_value=np.nan).tolist())])
    def test_keepdims_size0(self, axis, expected, xp):
        x = xp.zeros((5, 0))
        if axis == 1:
            with pytest.warns(SmallSampleWarning, match=too_small_nd_not_omit):
                y = variation(x, axis=axis, keepdims=True)
        else:
            y = variation(x, axis=axis, keepdims=True)
        xp_assert_equal(y, xp.asarray(expected))

    @skip_xp_backends("dask.array", reason='needs `_axis_nan_policy`')
    @pytest.mark.parametrize('incr, expected_fill', [(0, np.inf), (1, np.nan)])
    def test_keepdims_and_ddof_eq_len_plus_incr(self, incr, expected_fill, xp):
        x = xp.asarray([[1, 1, 2, 2], [1, 2, 3, 3]])
        y = variation(x, axis=1, ddof=x.shape[1] + incr, keepdims=True)
        xp_assert_equal(y, xp.full((2, 1), fill_value=expected_fill))

    @skip_xp_backends("dask.array", reason='needs `_axis_nan_policy`')
    def test_propagate_nan(self, xp):
        # Check that the shape of the result is the same for inputs
        # with and without nans, cf gh-5817
        a = xp.reshape(xp.arange(8.), (2, -1))
        a = xpx.at(a)[1, 0].set(xp.nan)
        v = variation(a, axis=1, nan_policy="propagate")
        xp_assert_close(v, xp.asarray([math.sqrt(5/4)/1.5, xp.nan]))

    def test_axis_none(self, xp):
        # Check that `variation` computes the result on the flattened
        # input when axis is None.
        y = variation(xp.asarray([[0, 1], [2, 3]]), axis=None)
        xp_assert_close(y, xp.asarray(math.sqrt(5/4)/1.5))

    def test_bad_axis(self, xp):
        # Check that an invalid axis raises np.exceptions.AxisError.
        x = xp.asarray([[1, 2, 3], [4, 5, 6]])
        with pytest.raises((AxisError, IndexError)):
            variation(x, axis=10)

    @pytest.mark.filterwarnings("ignore:divide by zero encountered:RuntimeWarning:dask")
    def test_mean_zero(self, xp):
        # Check that `variation` returns inf for a sequence that is not
        # identically zero but whose mean is zero.
        x = xp.asarray([10., -3., 1., -4., -4.])
        y = variation(x)
        xp_assert_equal(y, xp.asarray(xp.inf))

        x2 = xp.stack([x, -10.*x])
        y2 = variation(x2, axis=1)
        xp_assert_equal(y2, xp.asarray([xp.inf, xp.inf]))

    @pytest.mark.filterwarnings("ignore:invalid value encountered:RuntimeWarning:dask")
    @pytest.mark.parametrize('x', [[0.]*5, [1, 2, np.inf, 9]])
    def test_return_nan(self, x, xp):
        x = xp.asarray(x)
        # Test some cases where `variation` returns nan.
        y = variation(x)
        xp_assert_equal(y, xp.asarray(xp.nan, dtype=x.dtype))

    @pytest.mark.filterwarnings('ignore:Invalid value encountered:RuntimeWarning:dask')
    @pytest.mark.parametrize('axis, expected',
                             [(0, []), (1, [np.nan]*3), (None, np.nan)])
    def test_2d_size_zero_with_axis(self, axis, expected, xp):
        x = xp.empty((3, 0))
        if axis != 0:
            # specific message depends on `axis`, and `SmallSampleWarning`
            # is specific enough.
            with eager_warns(SmallSampleWarning, xp=xp):
                y = variation(x, axis=axis)
        else:
            y = variation(x, axis=axis)
        xp_assert_equal(y, xp.asarray(expected))

    @pytest.mark.filterwarnings('ignore:divide by zero encountered:RuntimeWarning:dask')
    def test_neg_inf(self, xp):
        # Edge case that produces -inf: ddof equals the number of non-nan
        # values, the values are not constant, and the mean is negative.
        x1 = xp.asarray([-3., -5.])
        xp_assert_equal(variation(x1, ddof=2), xp.asarray(-xp.inf))

    @skip_xp_backends(np_only=True, reason='only NumPy supports ND nan_policy="omit"')
    def test_neg_inf_nan(self, xp):
        x2 = xp.asarray([[xp.nan, 1, -10, xp.nan],
                         [-20, -3, xp.nan, xp.nan]])
        xp_assert_equal(variation(x2, axis=1, ddof=2, nan_policy='omit'),
                        xp.asarray([-xp.inf, -xp.inf]))

    @pytest.mark.parametrize("nan_policy", ['propagate', 'omit'])
    def test_combined_edge_cases(self, nan_policy, xp):
        if not is_numpy(xp):
            pytest.skip("Only NumPy supports ND nan_policy='omit'")
        x = xp.asarray([[0, 10, xp.nan, 1],
                        [0, -5, xp.nan, 2],
                        [0, -5, xp.nan, 3]])
        if nan_policy == 'omit':
            with pytest.warns(SmallSampleWarning, match=too_small_nd_omit):
                y = variation(x, axis=0, nan_policy=nan_policy)
        else:
            y = variation(x, axis=0, nan_policy=nan_policy)
        xp_assert_close(y, xp.asarray([xp.nan, xp.inf, xp.nan, math.sqrt(2/3)/2]))

    @skip_xp_backends(np_only=True, reason='only NumPy supports ND nan_policy="omit"')
    @pytest.mark.parametrize(
        'ddof, expected',
        [(0, [np.sqrt(1/6), np.sqrt(5/8), np.inf, 0, np.nan, 0.0, np.nan]),
         (1, [0.5, np.sqrt(5/6), np.inf, 0, np.nan, 0, np.nan]),
         (2, [np.sqrt(0.5), np.sqrt(5/4), np.inf, np.nan, np.nan, 0, np.nan])]
    )
    def test_more_nan_policy_omit_tests(self, ddof, expected, xp):
        # The slightly strange formatting in the follow array is my attempt to
        # maintain a clean tabular arrangement of the data while satisfying
        # the demands of pycodestyle.  Currently, E201 and E241 are not
        # disabled by the `noqa` annotation.
        nan = xp.nan
        x = xp.asarray([[1.0, 2.0, nan, 3.0],
                        [0.0, 4.0, 3.0, 1.0],
                        [nan, -.5, 0.5, nan],
                        [nan, 9.0, 9.0, nan],
                        [nan, nan, nan, nan],
                        [3.0, 3.0, 3.0, 3.0],
                        [0.0, 0.0, 0.0, 0.0]])
        with pytest.warns(SmallSampleWarning, match=too_small_nd_omit):
            v = variation(x, axis=1, ddof=ddof, nan_policy='omit')
        xp_assert_close(v, expected)

    @skip_xp_backends(eager_only=True, reason='lazy -> limited nan_policy support')
    def test_variation_ddof(self, xp):
        # test variation with delta degrees of freedom
        # regression test for gh-13341
        a = xp.asarray([1., 2., 3., 4., 5.])
        nan_a = xp.asarray([1, 2, 3, xp.nan, 4, 5, xp.nan])
        y = variation(a, ddof=1)
        nan_y = variation(nan_a, nan_policy="omit", ddof=1)
        xp_assert_close(y, xp.asarray(math.sqrt(5/2)/3))
        assert y == nan_y
