from copy import deepcopy

import pytest

from src.backend.connectors.youtube_apis.content_id import models


class TestAssetLookupResult:
    _class = models.AssetLookupResult

    mandatory_kwargs = {
        "id": "123",
        "kind": "mock_kind",
        "type": "mock_type",
    }

    @pytest.fixture
    def instance(self):
        def _(**kwargs):
            return self._class(**(self.mandatory_kwargs | kwargs))

        return _

    def test_mandatory_fields(self, instance):
        instance = instance()
        for key, value in self.mandatory_kwargs.items():
            assert getattr(instance, key) == value

    def test_title_empty_string_if_missing(self, instance):
        assert instance().title == ""

    @pytest.mark.parametrize("attr", ["isrcs", "iswcs"])
    def test_missing_is_empty_list(self, instance, attr):
        assert getattr(instance(), attr) == []


class TestAssetRelationships:
    _class = models.AssetRelationships

    def test_related_assets(self):
        asset_id = "123"
        child_asset_id = "456"
        parent_asset_id = "789"
        instance = self._class(asset_id, [child_asset_id], [parent_asset_id])
        assert instance.related_assets == [child_asset_id, parent_asset_id]


class TestReference:
    _class = models.Reference

    mock_kwargs = {
        "id": "123",
        "kind": "kind",
        "origination": {models.YT.OWNER: models.YT_OWNER_ID_ORCHARD},
    }

    @pytest.fixture
    def instance(self):
        return self._class(**self.mock_kwargs)

    def test_instantiate(self, instance):
        assert instance.id == self.mock_kwargs["id"]
        assert instance.kind == self.mock_kwargs["kind"]
        assert instance.origination == self.mock_kwargs["origination"]
        assert instance.owned_own is True

    @pytest.mark.parametrize("owned_by_orchard", [True, False])
    def test_post_init(self, owned_by_orchard):
        mock_kwargs = deepcopy(self.mock_kwargs)
        if not owned_by_orchard:
            mock_kwargs["origination"][models.YT.OWNER] = "other"
        instance = self._class(**mock_kwargs)
        assert instance.owned_own is owned_by_orchard

    @pytest.mark.parametrize("check_if_own_returns", [True, False])
    @pytest.mark.parametrize("check_for_conflicts_returns", [True, False])
    def test_conflicts_own(
        self, mocker, instance, check_if_own_returns, check_for_conflicts_returns
    ):
        mocker.patch.object(
            instance, "_check_for_conflicts", return_value=check_for_conflicts_returns
        )
        mocker.patch.object(
            instance, "_check_if_own", return_value=check_if_own_returns
        )
        assert instance._conflicts_own == (
            check_if_own_returns and check_for_conflicts_returns
        )

    @pytest.mark.parametrize(
        "excluded_intervals,expected",
        [
            ([{models.YT.ORIGIN: models.YT.REFERENCE_CONFLICT}], True),
            ([{models.YT.ORIGIN: "other"}], False),
            ([{"other_key": True}], False),
            ([], False),
        ],
    )
    def test_check_for_conflicts(self, instance, excluded_intervals, expected):
        instance.excluded_intervals = excluded_intervals
        assert instance._check_for_conflicts() == expected


class TestOwnership:
    _class = models.Ownership

    mock_params = {
        "asset_id": "123",
        "owner": models.YT_OWNER_ID_ORCHARD,
        "type": "include",
        "ratio": 100,
        "territories": ["IN", "US", "DE"],
    }

    @pytest.fixture
    def instance(self):
        return self._class(*self.mock_params.values())  # Test args

    def test_init(self, instance):
        for key, value in self.mock_params.items():
            assert getattr(instance, key) == value

    def test_len(self, instance):
        assert len(instance) == len(instance.territories)