import pytest

from tests import data, tests


@pytest.mark.parametrize("value", [False, True])
class TestSetAndGetBoolHigher:
    __test__ = True

    """strip tests, physical and virtual"""

    @pytest.mark.parametrize(
        "index,param",
        [
            (data.phys_in, "mute"),
            (data.phys_in, "mono"),
            (data.virt_in, "mc"),
            (data.virt_in, "mono"),
        ],
    )
    def test_it_sets_and_gets_strip_bool_params(self, index, param, value):
        setattr(tests.strip[index], param, value)
        assert getattr(tests.strip[index], param) == value

    """ bus tests, physical and virtual """

    @pytest.mark.parametrize(
        "index,param",
        [
            (data.phys_out, "eq"),
            (data.phys_out, "mute"),
            (data.virt_out, "eq_ab"),
            (data.virt_out, "sel"),
        ],
    )
    def test_it_sets_and_gets_bus_bool_params(self, index, param, value):
        setattr(tests.bus[index], param, value)
        assert getattr(tests.bus[index], param) == value

    """  bus modes tests, physical and virtual """

    @pytest.mark.skipif(
        data.name != "basic",
        reason="Skip test if kind is not basic",
    )
    @pytest.mark.parametrize(
        "index,param",
        [
            (data.phys_out, "normal"),
            (data.phys_out, "amix"),
            (data.virt_out, "normal"),
            (data.virt_out, "composite"),
        ],
    )
    def test_it_sets_and_gets_busmode_basic_bool_params(self, index, param, value):
        setattr(tests.bus[index].mode, param, value)
        assert getattr(tests.bus[index].mode, param) == value

    @pytest.mark.skipif(
        data.name == "basic",
        reason="Skip test if kind is basic",
    )
    @pytest.mark.parametrize(
        "index,param",
        [
            (data.phys_out, "normal"),
            (data.phys_out, "amix"),
            (data.phys_out, "rearonly"),
            (data.virt_out, "normal"),
            (data.virt_out, "upmix41"),
            (data.virt_out, "composite"),
        ],
    )
    def test_it_sets_and_gets_busmode_bool_params(self, index, param, value):
        setattr(tests.bus[index].mode, param, value)
        assert getattr(tests.bus[index].mode, param) == value

    """ macrobutton tests """

    @pytest.mark.parametrize(
        "index,param",
        [(data.button_lower, "state"), (data.button_upper, "trigger")],
    )
    def test_it_sets_and_gets_macrobutton_bool_params(self, index, param, value):
        setattr(tests.button[index], param, value)
        assert getattr(tests.button[index], param) == value

    """ vban instream tests """

    @pytest.mark.parametrize(
        "index,param",
        [(data.vban_in, "on")],
    )
    def test_it_sets_and_gets_vban_instream_bool_params(self, index, param, value):
        setattr(tests.vban.instream[index], param, value)
        assert getattr(tests.vban.instream[index], param) == value

    """ vban outstream tests """

    @pytest.mark.parametrize(
        "index,param",
        [(data.vban_out, "on")],
    )
    def test_it_sets_and_gets_vban_outstream_bool_params(self, index, param, value):
        setattr(tests.vban.outstream[index], param, value)
        assert getattr(tests.vban.outstream[index], param) == value

    """ command tests """

    @pytest.mark.parametrize(
        "param",
        [("lock")],
    )
    def test_it_sets_command_bool_params(self, param, value):
        setattr(tests.command, param, value)

    """ recorder tests """

    @pytest.mark.skipif(
        data.name == "basic",
        reason="Skip test if kind is basic",
    )
    @pytest.mark.parametrize(
        "param",
        [("A1"), ("B2")],
    )
    def test_it_sets_and_gets_recorder_bool_params(self, param, value):
        setattr(tests.recorder, param, value)
        assert getattr(tests.recorder, param) == value

    @pytest.mark.skipif(
        data.name == "basic",
        reason="Skip test if kind is basic",
    )
    @pytest.mark.parametrize(
        "param",
        [("loop")],
    )
    def test_it_sets_recorder_bool_params(self, param, value):
        setattr(tests.recorder, param, value)

    """ fx tests """

    @pytest.mark.skipif(
        data.name != "potato",
        reason="Skip test if kind is not potato",
    )
    @pytest.mark.parametrize(
        "param",
        [("reverb"), ("reverb_ab"), ("delay"), ("delay_ab")],
    )
    def test_it_sets_and_gets_fx_bool_params(self, param, value):
        setattr(tests.fx, param, value)
        assert getattr(tests.fx, param) == value

    """ patch tests """

    @pytest.mark.skipif(
        data.name == "basic",
        reason="Skip test if kind is basic",
    )
    @pytest.mark.parametrize(
        "param",
        [("postfadercomposite")],
    )
    def test_it_sets_and_gets_patch_bool_params(self, param, value):
        setattr(tests.patch, param, value)
        assert getattr(tests.patch, param) == value

    """ patch.insert tests """

    @pytest.mark.skipif(
        data.name == "basic",
        reason="Skip test if kind is basic",
    )
    @pytest.mark.parametrize(
        "index, param",
        [(data.insert_lower, "on"), (data.insert_higher, "on")],
    )
    def test_it_sets_and_gets_patch_insert_bool_params(self, index, param, value):
        setattr(tests.patch.insert[index], param, value)
        assert getattr(tests.patch.insert[index], param) == value

    """ option tests """

    @pytest.mark.parametrize(
        "param",
        [("monitoronsel")],
    )
    def test_it_sets_and_gets_option_bool_params(self, param, value):
        setattr(tests.option, param, value)
        assert getattr(tests.option, param) == value


class TestSetAndGetIntHigher:
    __test__ = True

    """strip tests, physical and virtual"""

    @pytest.mark.parametrize(
        "index,param,value",
        [
            (data.phys_in, "limit", -40),
            (data.phys_in, "limit", 12),
            (data.virt_in, "k", 0),
            (data.virt_in, "k", 4),
        ],
    )
    def test_it_sets_and_gets_strip_bool_params(self, index, param, value):
        setattr(tests.strip[index], param, value)
        assert getattr(tests.strip[index], param) == value

    """ vban outstream tests """

    @pytest.mark.parametrize(
        "index,param,value",
        [(data.vban_out, "sr", 48000)],
    )
    def test_it_sets_and_gets_vban_outstream_bool_params(self, index, param, value):
        setattr(tests.vban.outstream[index], param, value)
        assert getattr(tests.vban.outstream[index], param) == value

    """ patch.asio tests """

    @pytest.mark.skipif(
        data.name == "basic",
        reason="Skip test if kind is basic",
    )
    @pytest.mark.parametrize(
        "index,value",
        [
            (0, 1),
            (data.asio_in, 4),
        ],
    )
    def test_it_sets_and_gets_patch_asio_in_int_params(self, index, value):
        tests.patch.asio[index].set(value)
        assert tests.patch.asio[index].get() == value

    """ patch.A2[i]-A5[i] tests """

    @pytest.mark.skipif(
        data.name == "basic",
        reason="Skip test if kind is basic",
    )
    @pytest.mark.parametrize(
        "index,value",
        [
            (0, 1),
            (data.asio_out, 4),
        ],
    )
    def test_it_sets_and_gets_patch_asio_out_int_params(self, index, value):
        tests.patch.A2[index].set(value)
        assert tests.patch.A2[index].get() == value
        tests.patch.A5[index].set(value)
        assert tests.patch.A5[index].get() == value

    """ patch.composite tests """

    @pytest.mark.skipif(
        data.name == "basic",
        reason="Skip test if kind is basic",
    )
    @pytest.mark.parametrize(
        "index,value",
        [
            (0, 3),
            (0, data.channels),
            (7, 8),
            (7, data.channels),
        ],
    )
    def test_it_sets_and_gets_patch_composite_int_params(self, index, value):
        tests.patch.composite[index].set(value)
        assert tests.patch.composite[index].get() == value

    """ option tests """

    @pytest.mark.skipif(
        data.name == "basic",
        reason="Skip test if kind is basic",
    )
    @pytest.mark.parametrize(
        "index,value",
        [
            (data.phys_out, 30),
            (data.phys_out, 500),
        ],
    )
    def test_it_sets_and_gets_patch_delay_int_params(self, index, value):
        tests.option.delay[index].set(value)
        assert tests.option.delay[index].get() == value


class TestSetAndGetFloatHigher:
    __test__ = True

    """strip tests, physical and virtual"""

    @pytest.mark.parametrize(
        "index,param,value",
        [
            (data.phys_in, "gain", -3.6),
            (data.virt_in, "gain", 5.8),
            (data.phys_in, "comp", 0.0),
            (data.virt_in, "comp", 8.2),
            (data.phys_in, "gate", 2.3),
            (data.virt_in, "gate", 6.7),
        ],
    )
    def test_it_sets_and_gets_strip_float_params(self, index, param, value):
        setattr(tests.strip[index], param, value)
        assert getattr(tests.strip[index], param) == value

    @pytest.mark.parametrize(
        "index,value",
        [(data.phys_in, 2), (data.phys_in, 2), (data.virt_in, 8), (data.virt_in, 8)],
    )
    def test_it_gets_prefader_levels_and_compares_length_of_array(self, index, value):
        assert len(tests.strip[index].levels.prefader) == value

    @pytest.mark.parametrize(
        "index,value",
        [(data.phys_in, 2), (data.phys_in, 2), (data.virt_in, 8), (data.virt_in, 8)],
    )
    def test_it_gets_postmute_levels_and_compares_length_of_array(self, index, value):
        assert len(tests.strip[index].levels.postmute) == value

    @pytest.mark.skipif(
        data.name != "potato",
        reason="Only test if logged into Potato version",
    )
    @pytest.mark.parametrize(
        "index, j, value",
        [
            (data.phys_in, 0, -20.7),
            (data.virt_in, 3, -60),
            (data.virt_in, 4, 3.6),
            (data.phys_in, 4, -12.7),
        ],
    )
    def test_it_sets_and_gets_strip_gainlayer_values(self, index, j, value):
        tests.strip[index].gainlayer[j].gain = value
        assert tests.strip[index].gainlayer[j].gain == value

    """ strip tests, physical """

    @pytest.mark.parametrize(
        "index, param, value",
        [
            (data.phys_in, "pan_x", -0.6),
            (data.phys_in, "pan_x", 0.6),
            (data.phys_in, "color_y", 0.8),
            (data.phys_in, "fx_x", -0.6),
        ],
    )
    def test_it_sets_and_gets_strip_xy_params(self, index, param, value):
        assert hasattr(tests.strip[index], param)
        setattr(tests.strip[index], param, value)
        assert getattr(tests.strip[index], param) == value

    @pytest.mark.skipif(
        data.name != "potato",
        reason="Only test if logged into Potato version",
    )
    @pytest.mark.parametrize(
        "index, param, value",
        [
            (data.phys_in, "reverb", -1.6),
            (data.phys_in, "postfx1", True),
        ],
    )
    def test_it_sets_and_gets_strip_effects_params(self, index, param, value):
        assert hasattr(tests.strip[index], param)
        setattr(tests.strip[index], param, value)
        assert getattr(tests.strip[index], param) == value

    """ strip tests, virtual """

    @pytest.mark.parametrize(
        "index, param, value",
        [
            (data.virt_in, "pan_x", -0.6),
            (data.virt_in, "pan_x", 0.6),
            (data.virt_in, "treble", -1.6),
            (data.virt_in, "mid", 5.8),
            (data.virt_in, "bass", -8.1),
        ],
    )
    def test_it_sets_and_gets_strip_eq_params(self, index, param, value):
        setattr(tests.strip[index], param, value)
        assert getattr(tests.strip[index], param) == value

    """ bus tests, physical and virtual """

    @pytest.mark.skipif(
        data.name != "potato",
        reason="Only test if logged into Potato version",
    )
    @pytest.mark.parametrize(
        "index, param, value",
        [(data.phys_out, "returnreverb", 3.6), (data.virt_out, "returnfx1", 5.8)],
    )
    def test_it_sets_and_gets_bus_effects_float_params(self, index, param, value):
        assert hasattr(tests.bus[index], param)
        setattr(tests.bus[index], param, value)
        assert getattr(tests.bus[index], param) == value

    @pytest.mark.parametrize(
        "index, param, value",
        [(data.phys_out, "gain", -3.6), (data.virt_out, "gain", 5.8)],
    )
    def test_it_sets_and_gets_bus_float_params(self, index, param, value):
        setattr(tests.bus[index], param, value)
        assert getattr(tests.bus[index], param) == value

    @pytest.mark.parametrize(
        "index,value",
        [(data.phys_out, 8), (data.virt_out, 8)],
    )
    def test_it_gets_prefader_levels_and_compares_length_of_array(self, index, value):
        assert len(tests.bus[index].levels.all) == value


@pytest.mark.parametrize("value", ["test0", "test1"])
class TestSetAndGetStringHigher:
    __test__ = True

    """strip tests, physical and virtual"""

    @pytest.mark.parametrize(
        "index, param",
        [(data.phys_in, "label"), (data.virt_in, "label")],
    )
    def test_it_sets_and_gets_strip_string_params(self, index, param, value):
        setattr(tests.strip[index], param, value)
        assert getattr(tests.strip[index], param) == value

    """ bus tests, physical and virtual """

    @pytest.mark.parametrize(
        "index, param",
        [(data.phys_out, "label"), (data.virt_out, "label")],
    )
    def test_it_sets_and_gets_bus_string_params(self, index, param, value):
        setattr(tests.bus[index], param, value)
        assert getattr(tests.bus[index], param) == value

    """ vban instream tests """

    @pytest.mark.parametrize(
        "index, param",
        [(data.vban_in, "name")],
    )
    def test_it_sets_and_gets_vban_instream_string_params(self, index, param, value):
        setattr(tests.vban.instream[index], param, value)
        assert getattr(tests.vban.instream[index], param) == value

    """ vban outstream tests """

    @pytest.mark.parametrize(
        "index, param",
        [(data.vban_out, "name")],
    )
    def test_it_sets_and_gets_vban_outstream_string_params(self, index, param, value):
        setattr(tests.vban.outstream[index], param, value)
        assert getattr(tests.vban.outstream[index], param) == value


@pytest.mark.parametrize("value", [False, True])
class TestSetAndGetMacroButtonHigher:
    __test__ = True

    """macrobutton tests"""

    @pytest.mark.parametrize(
        "index, param",
        [
            (0, "state"),
            (39, "stateonly"),
            (69, "trigger"),
            (22, "stateonly"),
            (45, "state"),
            (65, "trigger"),
        ],
    )
    def test_it_sets_and_gets_macrobutton_params(self, index, param, value):
        setattr(tests.button[index], param, value)
        assert getattr(tests.button[index], param) == value