# Copyright (c) 2018 Radio Astronomy Software Group
# Licensed under the 2-clause BSD License
import copy

import numpy as np
import pytest
from astropy import units
from astropy.coordinates import (
    CartesianRepresentation,
    EarthLocation,
    Latitude,
    Longitude,
    SkyCoord,
)
from astropy.time import Time
from astropy.units import Quantity

from pyuvdata import parameter as uvp, utils
from pyuvdata.testing import check_warnings
from pyuvdata.uvbase import UVBase

from .utils.test_coordinates import (
    frame_selenoid,
    ref_latlonalt,
    ref_latlonalt_moon,
    ref_xyz,
    ref_xyz_moon,
)


@pytest.fixture
def sky_in():
    yield SkyCoord(
        ra=Longitude(5.0, unit="hourangle"),
        dec=Latitude(-30, unit="deg"),
        frame="fk5",
        equinox="J2000",
    )


def test_class_inequality(capsys):
    """Test equality error for different uvparameter classes."""
    param1 = uvp.UVParameter(name="p1", value=1)
    param2 = uvp.AngleParameter(name="p2", value=1)
    # use `__ne__` rather than `!=` throughout so we can cover print lines
    assert param1.__ne__(param2, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith("p1 parameter classes are different")


def test_value_class_inequality(capsys):
    """Test equality error for different uvparameter classes."""
    param1 = uvp.UVParameter(name="p1", value=3)
    param2 = uvp.UVParameter(name="p2", value=np.array([3, 4, 5]))
    assert param1.__ne__(param2, silent=False)
    captured = capsys.readouterr()
    assert captured.out.startswith(
        "p1 parameter value is not an array on left but right is an array."
    )

    assert param2.__ne__(param1, silent=False)
    captured = capsys.readouterr()
    assert captured.out.startswith(
        "p2 parameter value is an array on left, but is <class 'int'> on right."
    )

    param3 = uvp.UVParameter(name="p2", value="Alice")
    assert param1.__ne__(param3, silent=False)
    captured = capsys.readouterr()
    assert captured.out.startswith(
        "p1 parameter value has type <class 'int'> on left and <class 'str'> on "
        "right. The values are not equal."
    )


def test_array_inequality(capsys):
    """Test equality error for different array values."""
    param1 = uvp.UVParameter(name="p1", value=np.array([0, 1, 3]))
    param2 = uvp.UVParameter(name="p2", value=np.array([0, 2, 4]))
    assert param1.__ne__(param2, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith(
        "p1 parameter value is an array with matching shapes, values are not close."
    )

    param3 = uvp.UVParameter(name="p3", value=np.array([0, 1]))
    assert param1.__ne__(param3, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith(
        "p1 parameter value is an array, shapes are different"
    )


def test_array_equality_nans():
    """Test array equality with nans present."""
    param1 = uvp.UVParameter(name="p1", value=np.array([0, 1, np.nan]))
    param2 = uvp.UVParameter(name="p2", value=np.array([0, 1, np.nan]))
    assert param1 == param2


@pytest.mark.parametrize("atol", [0.001, 1 * units.mm])
@pytest.mark.parametrize(
    "vals",
    (
        Quantity([0 * units.cm, 100 * units.cm, 3000 * units.mm]),
        Quantity([0.09 * units.cm, 100.09 * units.cm, 2999.1 * units.mm]),
        np.array([0, 1000, 3000]) * units.mm,
    ),
)
def test_quantity_equality(atol, vals):
    """Test equality for different quantity values."""
    param1 = uvp.UVParameter(name="p1", value=np.array([0, 1, 3]) * units.m, tols=atol)
    param2 = uvp.UVParameter(name="p2", value=vals, tols=atol)
    assert param1 == param2


def test_quantity_equality_error():
    """Test equality for different quantity values."""
    param1 = uvp.UVParameter(
        name="p1", value=np.array([0, 1, 3]) * units.m, tols=1 * units.mJy
    )
    param2 = uvp.UVParameter(
        name="p2",
        value=Quantity([0 * units.cm, 100 * units.cm, 3000 * units.mm]),
        tols=1 * units.mm,
    )
    with pytest.raises(units.UnitsError):
        assert param1 == param2


@pytest.mark.parametrize(
    ["vals", "p2_atol", "msg"],
    (
        (
            np.array([0, 2, 4]) * units.m,
            1 * units.mm,
            "p1 parameter value is an astropy Quantity, units are equivalent but "
            "values are not close.",
        ),
        (
            np.array([0, 1, 3]) * units.mm,
            1 * units.mm,
            "p1 parameter value is an astropy Quantity, units are equivalent but "
            "values are not close.",
        ),
        (
            np.array([0, 1, 3]) * units.Jy,
            1 * units.mJy,
            "p1 parameter value is an astropy Quantity, units are not equivalent",
        ),
        (
            Quantity([0.101 * units.cm, 100.09 * units.cm, 2999.1 * units.mm]),
            1 * units.mm,
            "p1 parameter value is an astropy Quantity, units are equivalent but "
            "values are not close.",
        ),
        (
            Quantity([0.09 * units.cm, 100.11 * units.cm, 2999.1 * units.mm]),
            1 * units.mm,
            "p1 parameter value is an astropy Quantity, units are equivalent but "
            "values are not close.",
        ),
        (
            np.array([0, 1000, 2998.9]) * units.mm,
            1 * units.mm,
            "p1 parameter value is an astropy Quantity, units are equivalent but "
            "values are not close.",
        ),
    ),
)
def test_quantity_inequality(capsys, vals, p2_atol, msg):
    param1 = uvp.UVParameter(
        name="p1", value=np.array([0, 1, 3]) * units.m, tols=1 * units.mm
    )
    param2 = uvp.UVParameter(name="p2", value=vals, tols=p2_atol)
    assert param1.__ne__(param2, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith(msg)


def test_quantity_array_inequality(capsys):
    param1 = uvp.UVParameter(
        name="p1", value=np.array([0.0, 1.0, 3.0]) * units.m, tols=1 * units.mm
    )
    param2 = uvp.UVParameter(name="p2", value=np.array([0.0, 1.0, 3.0]), tols=1.0)
    assert param1.__ne__(param2, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith(
        "p1 parameter value is a Quantity on left, but is <class 'numpy.ndarray'> "
        "on right."
    )


def test_quantity_equality_nans():
    """Test array equality with nans present."""
    param1 = uvp.UVParameter(name="p1", value=np.array([0, 1, np.nan] * units.m))
    param2 = uvp.UVParameter(name="p2", value=np.array([0, 1, np.nan] * units.m))
    assert param1 == param2


def test_string_inequality(capsys):
    """Test equality error for different string values."""
    param1 = uvp.UVParameter(name="p1", value="Alice")
    param2 = uvp.UVParameter(name="p2", value="Bob")
    assert param1.__ne__(param2, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith(
        "p1 parameter value is a string, values are different"
    )


def test_string_list_inequality(capsys):
    """Test equality error for different string values."""
    param1 = uvp.UVParameter(name="p1", value=["Alice", "Eve"])
    param2 = uvp.UVParameter(name="p2", value=["Bob", "Eve"])
    assert param1.__ne__(param2, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith(
        "p1 parameter value is a list of strings, values are different"
    )


def test_string_equality():
    """Test equality error for different string values."""
    param1 = uvp.UVParameter(name="p1", value="Alice")
    param2 = uvp.UVParameter(name="p2", value="Alice")
    assert param1 == param2


def test_integer_inequality(capsys):
    """Test equality error for different non-array, non-string values."""
    param1 = uvp.UVParameter(name="p1", value=1)
    param2 = uvp.UVParameter(name="p2", value=2)
    assert param1.__ne__(param2, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith(
        "p1 parameter value can be cast to an array and tested with np.allclose. "
        "The values are not close"
    )


def test_dict_equality():
    """Test equality for dict values."""
    param1 = uvp.UVParameter(
        name="p1", value={"v1": 1, "n1": None, "s1": "foo", "arr1": [3, 4, 5]}
    )
    param2 = uvp.UVParameter(
        name="p2", value={"v1": 1, "n1": None, "s1": "foo", "arr1": [3, 4, 5]}
    )
    assert param1 == param2


def test_dict_inequality_int(capsys):
    """Test equality error for integer dict values."""
    param1 = uvp.UVParameter(name="p1", value={"v1": 1, "s1": "test", "n1": None})
    param2 = uvp.UVParameter(name="p2", value={"v1": 2, "s1": "test", "n1": None})
    assert param1.__ne__(param2, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith("p1 parameter is a dict, key v1 is not equal")


def test_dict_inequality_str(capsys):
    """Test equality error for string dict values."""
    param1 = uvp.UVParameter(name="p1", value={"v1": 1, "s1": "test", "n1": None})
    param4 = uvp.UVParameter(name="p3", value={"v1": 1, "s1": "foo", "n1": None})
    assert param1.__ne__(param4, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith("p1 parameter is a dict, key s1 is not equal")


def test_dict_inequality_none(capsys):
    """Test equality error for string dict values."""
    param1 = uvp.UVParameter(name="p1", value={"v1": 1, "s1": "test", "n1": None})
    param4 = uvp.UVParameter(name="p3", value={"v1": 1, "s1": "test", "n1": 2})
    assert param1.__ne__(param4, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith("p1 parameter is a dict, key n1 is not equal")


def test_dict_inequality_arr(capsys):
    """Test equality error for string dict values."""
    param1 = uvp.UVParameter(name="p1", value={"v1": 1, "arr1": [3, 4, 5]})
    param4 = uvp.UVParameter(name="p3", value={"v1": 1, "arr1": [3, 4]})
    assert param1.__ne__(param4, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith("p1 parameter is a dict, key arr1 is not equal")

    param4 = uvp.UVParameter(name="p3", value={"v1": 1, "arr1": [3, 4, 6]})
    assert param1.__ne__(param4, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith("p1 parameter is a dict, key arr1 is not equal")


def test_dict_inequality_keys(capsys):
    """Test equality error for different keys."""
    param1 = uvp.UVParameter(name="p1", value={"v1": 1, "s1": "test", "n1": None})
    param3 = uvp.UVParameter(name="p3", value={"v3": 1, "s1": "test", "n1": None})
    assert param1.__ne__(param3, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith("p1 parameter is a dict, keys are not the same.")


def test_nested_dict_equality():
    """Test equality for nested dicts."""
    param1 = uvp.UVParameter(
        name="p1", value={"d1": {"v1": 1, "s1": "test"}, "d2": {"v1": 1, "s1": "test"}}
    )
    param3 = uvp.UVParameter(
        name="p3", value={"d1": {"v1": 1, "s1": "test"}, "d2": {"v1": 1, "s1": "test"}}
    )
    assert param1 == param3


def test_nested_dict_inequality(capsys):
    """Test equality error for nested dicts."""
    param1 = uvp.UVParameter(
        name="p1", value={"d1": {"v1": 1, "s1": "test"}, "d2": {"v1": 1, "s1": "test"}}
    )
    param3 = uvp.UVParameter(
        name="p3", value={"d1": {"v1": 2, "s1": "test"}, "d2": {"v1": 1, "s1": "test"}}
    )
    assert param1.__ne__(param3, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith(
        "p1 parameter is a dict, key d1 is a dict, key v1 is not equal"
    )


def test_recarray_equality():
    """Test equality for recarray."""
    names = ["foo", "bar", "gah"]
    values = [
        np.arange(35, dtype=float),
        np.arange(35, dtype=int),
        np.array(["gah " + str(ind) for ind in range(35)]),
    ]
    dtype = []
    for val in values:
        dtype.append(val.dtype)
    dtype_obj = np.dtype(list(zip(names, dtype, strict=True)))
    recarr1 = np.rec.fromarrays(values, dtype=dtype_obj)
    recarr2 = copy.deepcopy(recarr1)
    param1 = uvp.UVParameter(name="p1", value=recarr1)
    param3 = uvp.UVParameter(name="p3", value=recarr2)
    assert param1 == param3


@pytest.mark.parametrize(
    ["names2", "values2", "msg"],
    [
        [
            ["foo", "bar", "gah"],
            [
                np.arange(35, dtype=float),
                np.arange(35, dtype=int) + 1,
                np.array(["gah " + str(ind) for ind in range(35)]),
            ],
            "p1 parameter value is a recarray, values in field bar are not close.",
        ],
        [
            ["foo", "bar", "gah"],
            [
                np.arange(35, dtype=float),
                np.arange(35, dtype=int),
                np.array(["bah " + str(ind) for ind in range(35)]),
            ],
            "p1 parameter value is a recarray, values in field gah are not close.",
        ],
        [
            ["fob", "bar", "gah"],
            [
                np.arange(35, dtype=float),
                np.arange(35, dtype=int),
                np.array(["gah " + str(ind) for ind in range(35)]),
            ],
            "p1 parameter value is a recarray, field names "
            "are different. Left has names ('foo', 'bar', 'gah'), right has "
            "names ('fob', 'bar', 'gah').",
        ],
        [
            None,
            np.arange(35, dtype=float),
            "p1 parameter value is a recarray on left, but is "
            "<class 'numpy.ndarray'> on right.",
        ],
    ],
)
def test_recarray_inequality(capsys, names2, values2, msg):
    """Test inequality for recarray."""
    names1 = ["foo", "bar", "gah"]
    values1 = [
        np.arange(35, dtype=float),
        np.arange(35, dtype=int),
        np.array(["gah " + str(ind) for ind in range(35)]),
    ]
    dtype = []
    for val in values1:
        dtype.append(val.dtype)
    dtype_obj1 = np.dtype(list(zip(names1, dtype, strict=True)))
    recarr1 = np.rec.fromarrays(values1, dtype=dtype_obj1)
    param1 = uvp.UVParameter(name="p1", value=recarr1)

    if names2 is None:
        param2 = uvp.UVParameter(name="p2", value=values2)
    else:
        dtype = []
        for val in values2:
            dtype.append(val.dtype)
        dtype_obj2 = np.dtype(list(zip(names2, dtype, strict=True)))
        recarr2 = np.rec.fromarrays(values2, dtype=dtype_obj2)

        param2 = uvp.UVParameter(name="p2", value=recarr2)

    assert param1.__ne__(param2, silent=False)
    captured = capsys.readouterr()
    assert captured.out.startswith(msg)


def test_equality_check_fail(capsys):
    """Test equality error for non string, dict or array values."""
    param1 = uvp.UVParameter(name="p1", value=uvp.UVParameter(name="p1", value="Alice"))
    param2 = uvp.UVParameter(name="p2", value=uvp.UVParameter(name="p1", value="Bob"))
    assert param1.__ne__(param2, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith(
        "p1 parameter value has type <class 'pyuvdata.parameter.UVParameter'> "
        "on left and <class 'pyuvdata.parameter.UVParameter'> on right. The "
        "values are not equal."
    )


def test_notclose(capsys):
    """Test equality error for values not with tols."""
    param1 = uvp.UVParameter(name="p1", value=1.0, expected_type=float)
    param2 = uvp.UVParameter(name="p2", value=1.001, expected_type=float)
    assert param1.__ne__(param2, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith(
        "p1 parameter value can be cast to an array and tested with np.allclose. "
        "The values are not close"
    )


def test_close():
    """Test equality error for values within tols."""
    param1 = uvp.UVParameter(name="p1", value=1.0, expected_type=float)
    param2 = uvp.UVParameter(name="p2", value=1.000001, expected_type=float)
    assert param1 == param2


def test_close_int_vs_float():
    """Test equality tols floats versus default with int."""
    param1 = uvp.UVParameter(name="p1", value=1000000, expected_type=int)
    param2 = uvp.UVParameter(name="p2", value=1000001, expected_type=int)
    assert param1 != param2

    param1 = uvp.UVParameter(name="p1", value=1000000, expected_type=float)
    param2 = uvp.UVParameter(name="p2", value=1000001, expected_type=float)
    assert param1 == param2


def test_acceptability():
    """Test check_acceptability function."""
    param1 = uvp.UVParameter(name="p1", value=1000, acceptable_range=(1, 10))
    assert not param1.check_acceptability()[0]

    param1 = uvp.UVParameter(
        name="p1", value=np.random.rand(100), acceptable_range=(0.1, 0.9)
    )
    assert param1.check_acceptability()[0]
    param1 = uvp.UVParameter(
        name="p1", value=np.random.rand(100) * 1e-4, acceptable_range=(0.1, 0.9)
    )
    assert not param1.check_acceptability()[0]

    param2 = uvp.UVParameter(name="p2", value=5, acceptable_range=(1, 10))
    assert param2.check_acceptability()[0]
    param2 = uvp.UVParameter(name="p2", value=5, acceptable_vals=[1, 10])
    assert not param2.check_acceptability()[0]


def test_string_acceptability():
    """Test check_acceptability function with strings."""
    param1 = uvp.UVParameter(
        name="p1", value="Bob", form="str", acceptable_vals=["Alice", "Eve"]
    )
    assert not param1.check_acceptability()[0]
    param2 = uvp.UVParameter(
        name="p2", value="Eve", form="str", acceptable_vals=["Alice", "Eve"]
    )
    assert param2.check_acceptability()[0]


def test_expected_shape():
    """Test missing shape param."""

    class TestUV(UVBase):
        def __init__(self):
            self._p1 = uvp.UVParameter(name="p1", required=False)
            self._p2 = uvp.UVParameter(name="p2", form=("p1",))
            self._p3 = uvp.UVParameter(name="p3", form=(2,))
            super().__init__()

    obj = TestUV()
    obj.p2 = np.array([0, 5, 8])
    obj.p3 = np.array([4, 9])
    pytest.raises(ValueError, obj.check)
    assert obj._p3.expected_shape(obj) == (2,)


def test_angle_set_degree_none():
    param1 = uvp.AngleParameter(name="p2", value=1)
    param1.set_degrees(None)

    assert param1.value is None
    assert param1.degrees() is None


def test_location_set_lat_lon_alt_none():
    param1 = uvp.LocationParameter(name="p2", value=1)
    param1.set_lat_lon_alt(None)

    assert param1.value is None
    assert param1.lat_lon_alt() is None


def test_location_set_lat_lon_alt_degrees_none():
    param1 = uvp.LocationParameter(name="p2", value=1)
    param1.set_lat_lon_alt_degrees(None)

    assert param1.value is None
    assert param1.lat_lon_alt_degrees() is None


def test_location_set_xyz():
    param1 = uvp.LocationParameter(name="p2", value=1)
    param1.set_xyz(None)

    assert param1.value is None

    assert param1.xyz() is None

    with pytest.raises(ValueError, match="frame must be one of"):
        param1.set_xyz(ref_xyz, frame="foo")


@pytest.mark.parametrize(["frame", "selenoid"], frame_selenoid)
def test_location_xyz_latlonalt_match(frame, selenoid):
    if frame == "itrs":
        xyz_val = ref_xyz
        latlonalt_val = ref_latlonalt
        loc_centric = EarthLocation.from_geocentric(*ref_xyz, unit="m")
        loc_detic = EarthLocation.from_geodetic(
            lat=ref_latlonalt[0] * units.rad,
            lon=ref_latlonalt[1] * units.rad,
            height=ref_latlonalt[2] * units.m,
        )
        wrong_obj = EarthLocation.of_site("mwa")
    else:
        from lunarsky import MoonLocation

        xyz_val = ref_xyz_moon[selenoid]
        latlonalt_val = ref_latlonalt_moon
        loc_centric = MoonLocation.from_selenocentric(*ref_xyz_moon[selenoid], unit="m")
        loc_centric.ellipsoid = selenoid
        loc_detic = MoonLocation.from_selenodetic(
            lat=ref_latlonalt_moon[0] * units.rad,
            lon=ref_latlonalt_moon[1] * units.rad,
            height=ref_latlonalt_moon[2] * units.m,
            ellipsoid=selenoid,
        )
        wrong_obj = MoonLocation.from_selenocentric(0, 0, 0, unit="m")
        wrong_obj.ellipsoid = selenoid

    param1 = uvp.LocationParameter(name="p1", value=loc_centric)
    np.testing.assert_allclose(latlonalt_val, param1.lat_lon_alt())

    param4 = uvp.LocationParameter(name="p1", value=wrong_obj)
    param4.set_xyz(xyz_val)
    assert param1 == param4

    if selenoid == "SPHERE":
        param1 = uvp.LocationParameter(
            name="p1",
            value=MoonLocation.from_selenodetic(
                lat=ref_latlonalt_moon[0] * units.rad,
                lon=ref_latlonalt_moon[1] * units.rad,
                height=ref_latlonalt_moon[2] * units.m,
            ),
        )
        np.testing.assert_allclose(
            latlonalt_val, param1.lat_lon_alt(), rtol=0, atol=utils.RADIAN_TOL
        )

    param2 = uvp.LocationParameter(name="p2", value=loc_detic)
    np.testing.assert_allclose(xyz_val, param2.xyz(), rtol=0, atol=1e-3)

    param5 = uvp.LocationParameter(name="p2", value=wrong_obj)
    param5.set_lat_lon_alt(latlonalt_val, ellipsoid=selenoid)

    assert param2 == param5

    param3 = uvp.LocationParameter(name="p2", value=wrong_obj)
    latlonalt_deg_val = np.array(
        [
            latlonalt_val[0] * 180 / np.pi,
            latlonalt_val[1] * 180 / np.pi,
            latlonalt_val[2],
        ]
    )
    param3.set_lat_lon_alt_degrees(latlonalt_deg_val)

    np.testing.assert_allclose(xyz_val, param3.xyz(), rtol=0, atol=1e-3)


def test_location_acceptability():
    """Test check_acceptability with LocationParameters"""
    param1 = uvp.LocationParameter(
        "p1", value=EarthLocation.from_geocentric(*ref_xyz, unit="m")
    )
    assert param1.check_acceptability()[0]

    val = np.array([0.5, 0.5, 0.5])
    param1 = uvp.LocationParameter("p1", value=val)
    acceptable, reason = param1.check_acceptability()
    assert not acceptable
    assert reason == f"Location must be an object of type: {param1.expected_type}"


@pytest.mark.parametrize(["frame", "selenoid"], frame_selenoid)
def test_location_equality(frame, selenoid):
    if frame == "itrs":
        loc_obj1 = EarthLocation.from_geocentric(*ref_xyz, unit="m")
        xyz_adj = np.array(ref_xyz) + 8e-4
        loc_obj2 = EarthLocation.from_geocentric(*xyz_adj, unit="m")
    else:
        from lunarsky import MoonLocation

        loc_obj1 = MoonLocation.from_selenocentric(*ref_xyz_moon[selenoid], unit="m")
        loc_obj1.ellipsoid = selenoid
        xyz_adj = np.array(ref_xyz_moon[selenoid]) + 8e-4
        loc_obj2 = MoonLocation.from_selenocentric(*xyz_adj, unit="m")
        loc_obj2.ellipsoid = selenoid
    param1 = uvp.LocationParameter("p1", value=loc_obj1)
    param2 = uvp.LocationParameter("p1", value=loc_obj2)
    assert param1 == param2


@pytest.mark.parametrize(
    ["change", "msg"],
    [
        ["par_class", "p1 parameter classes are different."],
        [
            "uvp",
            "p1 parameter value is an EarthLocation on left, but is "
            "<class 'astropy.units.quantity.Quantity'> on right.",
        ],
        [
            "non_loc",
            "p1 parameter values are locations types in one object and not in "
            "the other",
        ],
        ["class", "p1 parameter value classes do not match."],
        ["ellipsoid", "p1 parameter value ellipsoid is not the same."],
        [
            "value",
            "p1 parameter values have the same class but the values are not close.",
        ],
    ],
)
def test_location_inequality(capsys, change, msg):
    param1 = uvp.LocationParameter(
        "p1", value=EarthLocation.from_geocentric(*ref_xyz, unit="m")
    )
    if change == "non_loc":
        param2 = uvp.LocationParameter(
            "p1", value=Quantity(np.array(ref_xyz), unit="m")
        )
    elif change == "class":
        pytest.importorskip("lunarsky")
        from lunarsky import MoonLocation

        param2 = uvp.LocationParameter(
            "p1",
            value=MoonLocation.from_selenocentric(*ref_xyz_moon["SPHERE"], unit="m"),
        )
    elif change == "par_class":
        param2 = uvp.UVParameter(
            "p1", value=Quantity(np.array(ref_xyz), unit="m"), expected_type=Quantity
        )
    elif change == "uvp":
        param1 = uvp.UVParameter(
            "p1",
            value=EarthLocation.from_geocentric(*ref_xyz, unit="m"),
            expected_type=(EarthLocation,),
        )
        param2 = uvp.UVParameter(
            "p1", value=Quantity(np.array(ref_xyz), unit="m"), expected_type=Quantity
        )
    elif change == "ellipsoid":
        pytest.importorskip("lunarsky")
        from lunarsky import MoonLocation

        param1 = uvp.LocationParameter(
            "p1",
            value=MoonLocation.from_selenodetic(
                lat=ref_latlonalt_moon[0] * units.rad,
                lon=ref_latlonalt_moon[1] * units.rad,
                height=ref_latlonalt_moon[2] * units.m,
                ellipsoid="SPHERE",
            ),
        )
        param2 = uvp.LocationParameter(
            "p1",
            value=MoonLocation.from_selenodetic(
                lat=ref_latlonalt_moon[0] * units.rad,
                lon=ref_latlonalt_moon[1] * units.rad,
                height=ref_latlonalt_moon[2] * units.m,
                ellipsoid="GSFC",
            ),
        )
    elif change == "value":
        xyz_adj = np.array(ref_xyz) + 2e-3
        param2 = uvp.LocationParameter(
            "p1", value=EarthLocation.from_geocentric(*xyz_adj, unit="m")
        )

    assert param1.__ne__(param2, silent=False)
    captured = capsys.readouterr()
    assert captured.out.startswith(msg)


@pytest.mark.parametrize(
    "sky2",
    [
        SkyCoord(
            ra=Longitude(5.0, unit="hourangle"),
            dec=Latitude(-30, unit="deg"),
            frame="fk5",
            equinox="J2000",
        ),
        SkyCoord(
            ra=Longitude(5.0, unit="hourangle"),
            dec=Latitude(-30, unit="deg") + Latitude(0.0005, unit="arcsec"),
            frame="fk5",
            equinox="J2000",
        ),
    ],
)
def test_skycoord_param_equality(sky_in, sky2):
    param1 = uvp.SkyCoordParameter(name="sky1", value=sky_in)
    param2 = uvp.SkyCoordParameter(name="sky2", value=sky2)

    assert param1 == param2


@pytest.mark.parametrize(
    "change", ["frame", "representation", "separation", "shape", "type"]
)
def test_skycoord_param_inequality(sky_in, change, capsys):
    param1 = uvp.SkyCoordParameter(name="sky1", value=sky_in)

    if change == "frame":
        param2 = uvp.SkyCoordParameter(name="sky2", value=sky_in.transform_to("icrs"))
        msg = "sky1 parameter has different frames, fk5 vs icrs."
    elif change == "representation":
        sky2 = sky_in.copy()
        sky2.representation_type = CartesianRepresentation
        param2 = uvp.SkyCoordParameter(name="sky2", value=sky2)
        msg = "sky1 parameter has different representation_types"
    elif change == "separation":
        sky2 = SkyCoord(
            ra=Longitude(5.0, unit="hourangle"),
            dec=Latitude(-30, unit="deg") + Latitude(0.002, unit="arcsec"),
            frame="fk5",
            equinox="J2000",
        )
        param2 = uvp.SkyCoordParameter(name="sky2", value=sky2)
        msg = "sky1 parameter is not close."
    elif change == "shape":
        sky2 = SkyCoord(
            ra=Longitude([5.0, 5.0], unit="hourangle"),
            dec=Latitude([-30, -30], unit="deg"),
            frame="fk5",
            equinox="J2000",
        )
        param2 = uvp.SkyCoordParameter(name="sky2", value=sky2)
        msg = "sky1 parameter shapes are different"
    elif change == "type":
        sky2 = Longitude(5.0, unit="hourangle")
        param2 = uvp.SkyCoordParameter(name="sky2", value=sky2)
        msg = (
            "sky1 parameter value is a SkyCoord on left, but is "
            "<class 'astropy.coordinates.angles.core.Longitude'> on right."
        )

    assert param1.__ne__(param2, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith(msg)


def test_non_builtin_expected_type():
    with pytest.raises(ValueError) as cm:
        uvp.UVParameter("_test", expected_type="integer")
    assert str(cm.value).startswith("Input expected_type is a string with value")


def test_strict_expected_type():
    param1 = uvp.UVParameter("_test", expected_type=np.float64, strict_type_check=True)
    assert param1.expected_type == np.float64


@pytest.mark.parametrize(
    "in_type,out_type",
    [
        (np.float64, (float, np.floating)),
        (int, (int, np.integer)),
        (np.complex64, (complex, np.complexfloating)),
        (np.uint, (np.unsignedinteger)),
        (bool, (bool, np.bool_)),
        # str type tests the pass through fallback
        (str, str),
        # check builtin attributes too
        ("str", str),
        ("int", (int, np.integer)),
        ("float", (float, np.floating)),
        ("complex", (complex, np.complexfloating)),
        ("bool", (bool, np.bool_)),
    ],
)
def test_generic_type_conversion(in_type, out_type):
    param1 = uvp.UVParameter("_test", expected_type=in_type)
    assert param1.expected_type == out_type


def test_strict_expected_type_equality(capsys):
    # make sure equality passes if one is strict and one is generic
    param1 = uvp.UVParameter(
        "_test1",
        value=np.float64(3.0),
        expected_type=np.float64,
        strict_type_check=True,
    )
    param2 = uvp.UVParameter(
        "_test2", value=3.0, expected_type=float, strict_type_check=False
    )
    assert param1 == param2
    assert param2 == param1

    # make sure it fails when both are strict and different
    param3 = uvp.UVParameter(
        "_test3", value=3.0, expected_type=float, strict_type_check=True
    )
    assert param1.__ne__(param3, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith("_test1 parameter has incompatible types.")

    assert param3 != param1
    assert param2 == param3

    # also try different precision values
    param4 = uvp.UVParameter(
        "_test4",
        value=np.float32(3.0),
        expected_type=np.float32,
        strict_type_check=True,
    )
    assert param1.__ne__(param4, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith("_test1 parameter has incompatible types")

    # make sure it passes when both are strict and equivalent
    param5 = uvp.UVParameter(
        "_test5",
        value=np.float64(3.0),
        expected_type=np.float64,
        strict_type_check=True,
    )
    assert param1 == param5

    # check that it fails for an incompatible generic type
    param6 = uvp.UVParameter(
        "_test6", value=3, expected_type=int, strict_type_check=False
    )
    assert param1 != param6
    assert param6 != param1

    return


def test_strict_expected_type_equality_arrays(capsys):
    # make sure it also works with numpy arrays when the dtype matches the strict type
    param1 = uvp.UVParameter(
        "_test1",
        value=np.full((2, 3), 3.0, dtype=np.float64),
        expected_type=np.float64,
        strict_type_check=True,
    )
    param2 = uvp.UVParameter(
        "_test2",
        value=np.full((2, 3), 3.0, dtype=float),
        expected_type=float,
        strict_type_check=False,
    )
    assert param1 == param2
    assert param2 == param1

    param3 = uvp.UVParameter(
        "_test3",
        value=np.full((2, 3), 3.0, dtype=float),
        expected_type=float,
        strict_type_check=True,
    )
    assert param1.__ne__(param3, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith("_test1 parameter has incompatible types")

    assert param3 != param1
    assert param2 == param3

    # also try different precision values
    param4 = uvp.UVParameter(
        "_test4",
        value=np.full((2, 3), 3.0, dtype=np.float32),
        expected_type=np.float32,
        strict_type_check=True,
    )
    assert param1.__ne__(param4, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith("_test1 parameter has incompatible types")

    # make sure it passes when both are strict and equivalent
    param5 = uvp.UVParameter(
        "_test5",
        value=np.full((2, 3), 3.0, dtype=np.float64),
        expected_type=np.float64,
        strict_type_check=True,
    )
    assert param1 == param5

    # check that it fails for an incompatible generic type
    param6 = uvp.UVParameter(
        "_test6",
        value=np.full((2, 3), 3, dtype=int),
        expected_type=int,
        strict_type_check=False,
    )
    assert param1.__ne__(param6, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith("_test1 parameter has incompatible dtypes.")

    assert param6.__ne__(param1, silent=False)
    captured = capsys.readouterr()
    assert captured.out.startswith("_test6 parameter has incompatible dtypes.")


def test_scalar_array_parameter_mismatch(capsys):
    param1 = uvp.UVParameter("_test1", value=3.0, expected_type=float)
    param2 = uvp.UVParameter("_test2", value=np.asarray([3.0]), expected_type=float)
    assert param1.__ne__(param2, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith(
        "_test1 parameter value is not an array on left but right is an array."
    )

    assert param2.__ne__(param1, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith(
        "_test2 parameter value is an array on left, but is <class 'float'> on right."
    )

    return


def test_value_none_parameter_mismatch(capsys):
    param1 = uvp.UVParameter("_test1", value=3.0, expected_type=float)
    param2 = uvp.UVParameter("_test2", value=None)
    assert param1.__ne__(param2, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith("_test1 is None on right, but is not None on left")

    assert param2.__ne__(param1, silent=False)

    captured = capsys.readouterr()
    assert captured.out.startswith("_test2 is None on left, but is not None on right")

    return


def test_spoof():
    param = uvp.UVParameter("test", expected_type=float, required=False, spoof_val=1.0)
    assert param.value is None
    param.apply_spoof()
    assert param.value == 1.0


def test_compare_value_err():
    param = uvp.UVParameter("_test1", value=3.0, tols=[0, 1], expected_type=float)
    with pytest.raises(
        ValueError,
        match="UVParameter value and supplied values are of different types.",
    ):
        param.compare_value("test")


@pytest.mark.parametrize(
    "value,param_value,value_type,status",
    [
        (np.array([1, 2]), np.array([1, 2, 3]), float, False),
        (np.array([1, 2, 3]), np.array([1, 2, 3]), float, True),
        (np.array([1.0, 2.0, 3.0]), np.array([1, 2, 3]), float, True),
        (np.array([2, 3, 4]), np.array([1, 2, 3]), float, True),
        (np.array([4, 5, 6]), np.array([1, 2, 3]), float, False),
        (np.array([1, 2, 3, 4, 5, 6]), np.array([1, 2, 3]), float, False),
        ("test_me", "dont_test_me", str, False),
        ("test_me", "test_me", str, True),
    ],
)
def test_compare_value(value, param_value, value_type, status):
    param = uvp.UVParameter(
        "_test1",
        value=param_value,
        tols=None if isinstance(value_type, str) else [0, 1],
        expected_type=value_type,
    )
    assert param.compare_value(value) == status


@pytest.mark.parametrize(
    "form_dict,exp_arr",
    [
        [{"a": slice(None), "b": slice(None)}, np.arange(9).reshape(3, 3)],
        [{"a": slice(None)}, np.arange(9).reshape(3, 3)],
        [{"b": slice(None)}, np.arange(9).reshape(3, 3)],
        [{"a": slice(0, 3, 2), "b": slice(0, 3, 2)}, [[0, 2], [6, 8]]],
        [{"a": slice(0, 3, 2), "b": [0, 2]}, [[0, 2], [6, 8]]],
        [{"a": [0, 2], "b": [0, 2]}, [[0, 2], [6, 8]]],
        [{"a": [0, 2], "b": [2, 0]}, [[2, 0], [8, 6]]],
        [{"a": [2, 0], "b": [0, 2]}, [[6, 8], [0, 2]]],
    ],
)
@pytest.mark.parametrize(
    "partype", ["array", "skycoord", "quantity1", "quantity2", "time"]
)
def test_get_from_form(form_dict, exp_arr, partype):
    init_val = np.arange(9).reshape(3, 3)
    if partype == "array":
        param = uvp.UVParameter("_test1", form=("a", "b"), value=init_val)
        np.testing.assert_array_equal(param.get_from_form(form_dict), exp_arr)
    elif partype == "quantity1":
        param = uvp.UVParameter("_test1", form=("a", "b"), value=init_val * units.Hz)
        np.testing.assert_array_equal((param.get_from_form(form_dict)).value, exp_arr)
    elif partype == "quantity2":
        param = uvp.UVParameter(
            "_test1",
            form=("a", "b"),
            value=Quantity([0, 1, 2, 3, 4, 5, 6, 7, 8], unit="Hz").reshape(3, 3),
        )
        np.testing.assert_array_equal((param.get_from_form(form_dict)).value, exp_arr)
    elif partype == "time":
        t0 = Time("2024-01-01T00:00:00").jd
        param = uvp.UVParameter(
            "_test1", form=("a", "b"), value=Time(t0 + init_val, format="jd")
        )
        np.testing.assert_array_equal(
            (param.get_from_form(form_dict)).value,
            Time(t0 + exp_arr, format="jd").value,
        )
    elif partype == "skycoord":
        sky = SkyCoord(
            ra=Longitude(init_val, unit="hourangle"),
            dec=Latitude(init_val, unit="deg"),
            frame="fk5",
            equinox="J2000",
        )
        param = uvp.SkyCoordParameter("_test1", form=("a", "b"), value=sky)
        exp_sky = SkyCoord(
            ra=Longitude(exp_arr, unit="hourangle"),
            dec=Latitude(exp_arr, unit="deg"),
            frame="fk5",
            equinox="J2000",
        )
        vals = param.get_from_form(form_dict)
        np.testing.assert_array_equal(vals.ra.rad, exp_sky.ra.rad)
        np.testing.assert_array_equal(vals.dec.rad, exp_sky.dec.rad)


@pytest.mark.parametrize(
    "form_dict,exp_arr",
    [
        [{"c": []}, np.arange(9).reshape(3, 3)],
        [{"a": slice(None), "b": slice(None)}, np.arange(9).reshape(3, 3)],
        [{"a": [1], "b": [1]}, np.arange(1).reshape(1, 1)],
        [{"a": [0, 2], "b": [0, 2]}, np.arange(4).reshape(2, 2)],
        [{"a": slice(2), "b": [0, 2]}, np.arange(4).reshape(2, 2)],
        [{"a": [0, 2], "b": slice(2)}, np.arange(4).reshape(2, 2)],
        [{"a": slice(2), "b": slice(2)}, np.arange(4).reshape(2, 2)],
        [{"a": slice(0), "b": slice(0)}, np.arange(0).reshape(0, 0)],  # no-op
        [{"a": [0, 2], "b": [0, 2]}, np.arange(4).reshape(2, 2)],
        [{"a": [2, 0], "b": [0, 2]}, np.arange(4).reshape(2, 2)],
        [{"a": [0, 2], "b": [2, 0]}, np.arange(4).reshape(2, 2)],
        [{"a": [2, 0], "b": [2, 0]}, np.arange(4).reshape(2, 2)],
    ],
)
@pytest.mark.parametrize(
    "partype", ["array", "skycoord", "quantity1", "quantity2", "time"]
)
def test_set_from_form(form_dict, exp_arr, partype):
    init_val = np.full((3, 3), -1)
    if partype == "array":
        param = uvp.UVParameter("_test1", form=("a", "b"), value=init_val)
        exp_val = exp_arr
    elif partype == "quantity1":
        param = uvp.UVParameter("_test1", form=("a", "b"), value=init_val * units.Hz)
        exp_val = exp_arr * units.Hz
    elif partype == "quantity2":
        param = uvp.UVParameter(
            "_test1",
            form=("a", "b"),
            value=Quantity([-1, -1, -1, -1, -1, -1, -1, -1, -1], unit="Hz").reshape(
                3, 3
            ),
        )
        exp_val = exp_arr * units.Hz
    elif partype == "time":
        t0 = Time("2024-01-01T00:00:00").jd
        param = uvp.UVParameter(
            "_test1", form=("a", "b"), value=Time(t0 + init_val, format="jd")
        )
        init_jd = param.value[0, 0].jd
        exp_val = Time(t0 + exp_arr, format="jd")
    elif partype == "skycoord":
        sky = SkyCoord(
            ra=Longitude(init_val, unit="hourangle"),
            dec=Latitude(init_val, unit="deg"),
            frame="fk5",
            equinox="J2000",
        )
        init_ra = sky[0, 0].ra.deg
        init_dec = sky[0, 0].dec.deg
        param = uvp.SkyCoordParameter("_test1", form=("a", "b"), value=sky)
        exp_val = SkyCoord(
            ra=Longitude(exp_arr, unit="hourangle"),
            dec=Latitude(exp_arr, unit="deg"),
            frame="fk5",
            equinox="J2000",
        )

    if "c" in form_dict:
        # no-op handling
        exp_warning = UserWarning
        msg = "form_dict does not match anything in UVParameter.form"
    else:
        exp_warning = None
        msg = ""

    with check_warnings(exp_warning, match=msg):
        param.set_from_form(form_dict, exp_val)

    # Test that the values are set as expected
    val = param.value[form_dict.get("a", slice(None))]
    val = val[:, form_dict.get("b", slice(None))]
    if partype == "array":
        np.testing.assert_array_equal(val, exp_val)
    elif partype in ["quantity1", "quantity2"]:
        np.testing.assert_array_equal(val.value, exp_val.value)
    elif partype == "time":
        np.testing.assert_array_equal(val.jd, exp_val.jd)
    elif partype == "skycoord":
        np.testing.assert_array_equal(val.ra.rad, exp_val.ra.rad)
        np.testing.assert_array_equal(val.dec.rad, exp_val.dec.rad)

    # Check that all the other values were untouched
    a_mask = np.ones(3, dtype=bool)
    a_mask[form_dict.get("a", ())] = False
    b_mask = np.ones(3, dtype=bool)
    b_mask[form_dict.get("b", ())] = False
    if partype == "array":
        assert np.all(param.value[a_mask, :] == -1)
        assert np.all(param.value[:, b_mask] == -1)
    elif partype == "quantity1" or partype == "quantity2":
        assert np.all(param.value[a_mask, :].value == -1)
        assert np.all(param.value[:, b_mask].value == -1)
    elif partype == "time":
        assert np.all(param.value[a_mask, :].jd == init_jd)
        assert np.all(param.value[:, b_mask].jd == init_jd)
    elif partype == "skycoord":
        assert np.all(param.value[a_mask, :].ra.deg == init_ra)
        assert np.all(param.value[:, b_mask].ra.deg == init_ra)
        assert np.all(param.value[a_mask, :].dec.deg == init_dec)
        assert np.all(param.value[:, b_mask].dec.deg == init_dec)


@pytest.mark.parametrize(
    "form_dict,exp_list",
    [
        [{"a": slice(None)}, [1, 2, 3]],
        [{"a": slice(0, 3, 2)}, [1, 3]],
        [{"a": slice(0, 3, 2)}, [1, 3]],
        [{"b": slice(10)}, [1, 2, 3]],
        [{"a": [0, 2]}, [1, 3]],
    ],
)
def test_get_from_form_list(form_dict, exp_list):
    param = uvp.UVParameter("_test1", form=("a",), value=[1, 2, 3])
    assert exp_list == param.get_from_form(form_dict)


@pytest.mark.parametrize(
    "form_dict,exp_list",
    [
        [{"a": slice(None)}, [1, 2, 3]],
        [{"a": slice(0, 3, 2)}, [1, 3]],
        [{"a": slice(0, 3, 2)}, [1, 3]],
        [{"b": slice(10)}, [1, 2, 3]],
        [{"a": [0, 2]}, [1, 3]],
        [{"a": [2, 0]}, [1, 3]],
    ],
)
def test_set_from_form_list(form_dict, exp_list):
    param = uvp.UVParameter("_test1", form=("a",), value=[-1, -1, -1])
    if "b" in form_dict:
        # no-op catch case
        exp_warning = UserWarning
        msg = "form_dict does not match anything in UVParameter.form"
    else:
        exp_warning = None
        msg = ""

    with check_warnings(exp_warning, match=msg):
        param.set_from_form(form_dict, exp_list)

    if isinstance(form_dict.get("a"), list):
        assert exp_list == [param.value[idx] for idx in form_dict["a"]]
    else:
        assert exp_list == param.value[form_dict.get("a", slice(None))]


def test_set_from_form_err():
    param = uvp.UVParameter("_test1", form=("a",))
    with pytest.raises(
        ValueError, match="Cannot call set_from_form if UVParameter.value is None."
    ):
        param.set_from_form({"a": slice(None)}, [1])


def test_set_get_singleton():
    param = uvp.UVParameter("_test1")
    assert param.form == ()
    assert param.value is None
    with check_warnings(
        UserWarning, match="form_dict does not match anything in UVParameter.form"
    ):
        param.set_from_form({"a": []}, 123.456)

    assert param.value == 123.456
    assert param.value == param.get_from_form({"a": 1})