"""Test for User logic tier."""
from unittest.mock import MagicMock

import pytest

from podcast.logic import user_v2 as user_v2_logic
from podcast.models import podcast as podcast_model
from podcast.models import user as user_model
from podcast.utils.exc import OwsError
from tests.utils import db_operations


def test_show_family_ids_for_current_user(mock_current_podcast_level_user):
    """Test get podcast ids current user has podcast level access to."""
    response = user_v2_logic.show_family_ids_for_current_user()
    assert response == [1]


def test_current_user_owns_show_family(mock_current_podcast_level_user):
    """Test show family ownership works."""
    assert user_v2_logic.current_user_owns_show_family(1) is True


def test_current_user_owns_show_family_or_raise(mock_current_user):
    """Test no show family ownership raises."""
    with pytest.raises(OwsError) as err:
        user_v2_logic.current_user_owns_show_family_or_raise(2)
    assert err.value.status == 403


def test_admin_owns_show_families_or_raise(mock_current_admin_user):
    """Test admin show family access success."""
    podcasts = podcast_model.get_podcasts_by_ids([1, 2])['items']
    assert user_v2_logic.current_user_owns_show_families_or_raise(podcasts) is None


def test_network_admin_owns_show_families_or_raise(mock_current_network_admin_user_second):
    """Test network admin no show family access raises."""
    podcasts = podcast_model.get_podcasts_by_ids([1, 2])['items']
    with pytest.raises(OwsError) as err:
        user_v2_logic.current_user_owns_show_families_or_raise(podcasts)
    assert err.value.status == 403


def test_podcast_level_owns_show_families_or_raise(mock_current_podcast_level_user):
    """Test podcast level user no show family access raises."""
    podcasts = podcast_model.get_podcasts_by_ids([1, 2])['items']
    with pytest.raises(OwsError) as err:
        user_v2_logic.current_user_owns_show_families_or_raise(podcasts)
    assert err.value.status == 403


def test_current_user_owns_show_families_or_raise(mock_current_user):
    """Test current user no show family access raises."""
    podcasts = podcast_model.get_podcasts_by_ids([1, 2])['items']
    with pytest.raises(OwsError) as err:
        user_v2_logic.current_user_owns_show_families_or_raise(podcasts)
    assert err.value.status == 403


def test_podcast_ids_owned_by_admin_user(mock_current_admin_user, monkeypatch):
    """Test podcast ids owned by admin user."""
    monkeypatch.setattr(
        podcast_model,
        'get_podcast_ids_by_show_family_ids_and_network_ids',
        MagicMock(return_value=[1, 2, 3])
    )
    result = user_v2_logic.podcast_ids_owned_by_current_user()
    podcast_model.get_podcast_ids_by_show_family_ids_and_network_ids.assert_called_once_with([], [1, 2, 3])
    assert result == [1, 2, 3]


def test_podcast_ids_owned_by_network_admin_user(mock_current_network_admin_user, monkeypatch):
    """Test podcast ids owned by network admin user."""
    monkeypatch.setattr(
        podcast_model,
        'get_podcast_ids_by_show_family_ids_and_network_ids',
        MagicMock(return_value=[1, 3])
    )
    result = user_v2_logic.podcast_ids_owned_by_current_user()
    podcast_model.get_podcast_ids_by_show_family_ids_and_network_ids.assert_called_once_with([], [1])
    assert result == [1, 3]


def test_podcast_ids_owned_by_current_user(mock_current_user, monkeypatch):
    """Test podcast ids owned by current user."""
    monkeypatch.setattr(
        podcast_model,
        'get_podcast_ids_by_show_family_ids_and_network_ids',
        MagicMock(return_value=[1, 3])
    )
    result = user_v2_logic.podcast_ids_owned_by_current_user()
    podcast_model.get_podcast_ids_by_show_family_ids_and_network_ids.assert_called_once_with([], [1])
    assert result == [1, 3]


def test_podcast_ids_owned_by_current_user_podcast_level_v2(
        mock_current_podcast_level_user, monkeypatch):
    """Test podcast ids owned by podcast level user."""
    monkeypatch.setattr(
        podcast_model,
        'get_podcast_ids_by_show_family_ids_and_network_ids',
        MagicMock(return_value=[1])
    )
    result = user_v2_logic.podcast_ids_owned_by_current_user()
    podcast_model.get_podcast_ids_by_show_family_ids_and_network_ids.assert_called_once_with([1], [])
    assert result == [1]


def test_episode_ids_owned_by_admin_user(mock_current_admin_user):
    """Test episode ids owned by admin user."""
    result = user_v2_logic.current_user_owns_episodes_or_raise([1, 2, 3])
    assert result is None


def test_episode_ids_owned_by_all_access_network_admin_user(mock_current_network_admin_user_all_access):
    """Test episode ids owned by all access network_admin user."""
    result = user_v2_logic.current_user_owns_episodes_or_raise([1, 2, 3])
    assert result is None


def test_episode_ids_not_owned_by_network_admin_user(mock_current_network_admin_user_second):
    """Test episode ids not owned by network_admin user."""
    with pytest.raises(OwsError) as err:
        user_v2_logic.current_user_owns_episodes_or_raise([1, 2])
    assert err.value.status == 403


def test_episode_ids_owned_by_current_user(mock_current_user):
    """Test episode ids owned by current user."""
    result = user_v2_logic.current_user_owns_episodes_or_raise([1, 2])
    assert result is None


def test_episode_ids_not_owned_by_current_user(mock_current_user):
    """Test episode ids not owned by current user."""
    with pytest.raises(OwsError) as err:
        user_v2_logic.current_user_owns_episodes_or_raise([3])
    assert err.value.status == 403


def test_episode_ids_owned_by_current_user_podcast_level(
        mock_current_podcast_level_user):
    """Test episode ids owned by current user."""
    result = user_v2_logic.current_user_owns_episodes_or_raise([1, 2])
    assert result is None


def test_episode_ids_not_owned_by_current_user_podcast_level(
        mock_current_podcast_level_user):
    """Test episode ids not owned by current user."""
    with pytest.raises(OwsError) as err:
        user_v2_logic.current_user_owns_episodes_or_raise([3])
    assert err.value.status == 403


def test_current_user_owns_episodes_admin_access(mock_current_admin_user):
    """Test current_user_owns_episodes with admin access."""
    result = user_v2_logic.current_user_owns_episodes([1, 2, 3])
    assert result is True


def test_current_user_owns_episodes_all_network_access(mock_current_network_admin_user_all_access):
    """Test current_user_owns_episodes with all network access."""
    result = user_v2_logic.current_user_owns_episodes([1, 2, 3])
    assert result is True


def test_current_user_owns_episodes_user_show_family_access(mock_current_podcast_level_user):
    """Test current_user_owns_episodes with user show family access."""
    result = user_v2_logic.current_user_owns_episodes([1, 2])
    assert result is True


def test_current_user_owns_episodes_user_network_access(mock_current_podcast_level_user):
    """Test current_user_owns_episodes with user network access."""
    result = user_v2_logic.current_user_owns_episodes([1, 2])
    assert result is True


def test_show_family_ids_owned_by_current_user_admin_access(mock_current_admin_user):
    """Test show_family_ids_owned_by_current_user with admin access."""
    result = user_v2_logic.show_family_ids_owned_by_current_user()
    assert result == [1, 2, 4]


def test_show_family_ids_owned_by_current_user_producer_access(mock_current_producer_user):
    """Test show_family_ids_owned_by_current_user with producer access."""
    result = user_v2_logic.show_family_ids_owned_by_current_user()
    assert result == [1, 2, 4]


def test_show_family_ids_owned_by_current_user_network_admin_access(mock_current_network_admin_user):
    """Test show_family_ids_owned_by_current_user with network admin access."""
    result = user_v2_logic.show_family_ids_owned_by_current_user()
    assert result == [1, 4]


def test_show_family_ids_owned_by_current_user_network_admin_no_access(mock_current_network_admin_user_second):
    """Test show_family_ids_owned_by_current_user with network admin no access."""
    result = user_v2_logic.show_family_ids_owned_by_current_user()
    assert result == []


def test_show_family_ids_owned_by_current_user_show_level_user_access(mock_current_podcast_level_user):
    """Test show_family_ids_owned_by_current_user with show level user access."""
    result = user_v2_logic.show_family_ids_owned_by_current_user()
    assert result == [1]


def test_show_family_ids_owned_by_current_user_show_level_user_no_access(mock_current_show_level_user):
    """Test show_family_ids_owned_by_current_user with show level user no access."""
    result = user_v2_logic.show_family_ids_owned_by_current_user()
    assert result == []


def test_current_user_owns_show_family_ids_or_raise_admin_access(mock_current_admin_user):
    """Test current_user_owns_show_family_ids_or_raise with admin access."""
    result = user_v2_logic.current_user_owns_show_family_ids_or_raise([1, 2])
    assert result is None


def test_current_user_owns_show_family_ids_or_raise_admin_access_no_show_family(mock_current_admin_user):
    """Test current_user_owns_show_family_ids_or_raise with admin access with no show family."""
    with pytest.raises(OwsError) as err:
        user_v2_logic.current_user_owns_show_family_ids_or_raise([5])
    assert err.value.status == 404


def test_current_user_owns_show_family_ids_or_raise_producer_limited_access(mock_current_user):
    """Test current_user_owns_show_family_ids_or_raise with producer limited access."""
    with pytest.raises(OwsError) as err:
        user_v2_logic.current_user_owns_show_family_ids_or_raise([1, 2])
    assert err.value.status == 403


def test_current_user_owns_show_family_ids_or_raise_producer_access(mock_current_producer_user):
    """Test current_user_owns_show_family_ids_or_raise with producer access."""
    result = user_v2_logic.current_user_owns_show_family_ids_or_raise([1, 2])
    assert result is None


def test_current_user_owns_show_family_ids_or_raise_producer_access_no_show_family(mock_current_producer_user):
    """Test current_user_owns_show_family_ids_or_raise with producer access with no active show family."""
    with pytest.raises(OwsError) as err:
        user_v2_logic.current_user_owns_show_family_ids_or_raise([3])
    assert err.value.status == 404


def test_current_user_owns_show_family_ids_or_raise_network_admin_access(mock_current_network_admin_user):
    """Test current_user_owns_show_family_ids_or_raise with network admin access."""
    result = user_v2_logic.current_user_owns_show_family_ids_or_raise([1])
    assert result is None


def test_current_user_owns_show_family_ids_or_raise_network_admin_no_access(mock_current_network_admin_user_second):
    """Test current_user_owns_show_family_ids_or_raise with network admin no access."""
    with pytest.raises(OwsError) as err:
        user_v2_logic.current_user_owns_show_family_ids_or_raise([1, 2])
    assert err.value.status == 403


def test_current_user_owns_show_family_ids_or_raise_show_level_user_access(mock_current_podcast_level_user):
    """Test current_user_owns_show_family_ids_or_raise with show level user access."""
    result = user_v2_logic.current_user_owns_show_family_ids_or_raise([1])
    assert result is None


def test_current_user_owns_show_family_ids_or_raise_show_level_user_no_access(mock_current_show_level_user):
    """Test current_user_owns_show_family_ids_or_raise with show level user no access."""
    with pytest.raises(OwsError) as err:
        user_v2_logic.current_user_owns_show_family_ids_or_raise([1])
    assert err.value.status == 403


def test_current_user_owns_network_ids_or_raise_admin_access(mock_current_admin_user):
    """Test test_current_user_owns_network_ids_or_raise with admin access."""
    result = user_v2_logic.current_user_owns_network_ids_or_raise([1], True)
    assert result is None


def test_current_user_owns_network_ids_or_raise_network_admin_access(mock_current_network_admin_user):
    """Test test_current_user_owns_network_ids_or_raise with network admin access."""
    result = user_v2_logic.current_user_owns_network_ids_or_raise([1], True)
    assert result is None


def test_current_user_owns_network_ids_or_raise_network_admin_access_no_access(mock_current_network_admin_user):
    """Test test_current_user_owns_network_ids_or_raise with network admin  no access."""
    with pytest.raises(OwsError) as err:
        user_v2_logic.current_user_owns_network_ids_or_raise([2], True)
    assert err.value.status == 403


def test_current_user_owns_network_ids_or_raise_show_level_user_access(mock_current_podcast_level_user):
    """Test test_current_user_owns_network_ids_or_raise with show level user access."""
    result = user_v2_logic.current_user_owns_network_ids_or_raise([1], True)
    assert result is None


def test_current_user_owns_network_ids_or_raise_show_level_user_access_no_access(mock_current_podcast_level_user):
    """Test test_current_user_owns_network_ids_or_raise with show level user no access."""
    with pytest.raises(OwsError) as err:
        user_v2_logic.current_user_owns_network_ids_or_raise([2], True)
    assert err.value.status == 403


def test_current_user_owns_network_ids_or_raise_show_level_user_no_access(mock_current_show_level_user):
    """Test current_user_owns_show_family_ids_or_raise with show level user no access."""
    with pytest.raises(OwsError) as err:
        user_v2_logic.current_user_owns_show_family_ids_or_raise([1])
    assert err.value.status == 403


def test_user_owns_ad_podcast_level(mock_current_podcast_level_user):
    """Test returns true when user owns ad action."""
    owned_ad_read = db_operations.ad_action_data[0]
    result = user_v2_logic.current_user_owns_ad_action(
        owned_ad_read)
    assert result is True


def test_user_does_not_own_ad_podcast_level(mock_current_podcast_level_user):
    """Test returns false when user does not own ad action."""
    unowned_ad_read = db_operations.ad_action_data[1]
    result = user_v2_logic.current_user_owns_ad_action(
        unowned_ad_read)
    assert result is False


def test_public_and_private_rss_podcasts_owned_by_admin_user(mock_current_admin_user, monkeypatch, podcast_fixture):
    """Test public_and_private_rss podcasts owned by admin user."""
    monkeypatch.setattr(
        podcast_model,
        'get_public_and_private_rss_podcasts_by_network_ids_and_show_family_ids',
        MagicMock(return_value={'items': [podcast_fixture]})
    )
    result = user_v2_logic.public_and_private_rss_podcasts_owned_by_current_user()
    podcast_model.get_public_and_private_rss_podcasts_by_network_ids_and_show_family_ids.assert_called_once_with(
        [1, 2, 3], [])
    assert result['items'] == [podcast_fixture]


def test_public_and_private_rss_podcasts_owned_by_network_admin_user(
        mock_current_network_admin_user, monkeypatch, podcast_fixture):
    """Test public_and_private_rss podcasts owned by network admin user."""
    monkeypatch.setattr(
        podcast_model,
        'get_public_and_private_rss_podcasts_by_network_ids_and_show_family_ids',
        MagicMock(return_value={'items': [podcast_fixture]})
    )
    result = user_v2_logic.public_and_private_rss_podcasts_owned_by_current_user()
    podcast_model.get_public_and_private_rss_podcasts_by_network_ids_and_show_family_ids.assert_called_once_with(
        [1], [])
    assert result['items'] == [podcast_fixture]


def test_public_and_private_rss_podcasts_owned_by_current_show_level_user(
        mock_current_podcast_level_user, monkeypatch, podcast_fixture):
    """Test public_and_private_rss podcasts owned by current_show_level_user."""
    monkeypatch.setattr(
        podcast_model,
        'get_public_and_private_rss_podcasts_by_network_ids_and_show_family_ids',
        MagicMock(return_value={'items': [podcast_fixture]})
    )
    result = user_v2_logic.public_and_private_rss_podcasts_owned_by_current_user()
    podcast_model.get_public_and_private_rss_podcasts_by_network_ids_and_show_family_ids.assert_called_once_with(
        [], [1])
    assert result['items'] == [podcast_fixture]


def test_current_user_owns_object_success_network_admin_user(
        mock_current_network_admin_user, monkeypatch):
    """Test current_user_owns_object success for network admin user."""
    success_response = {'authorized': True}
    assert user_v2_logic.current_user_owns_object('network', 1) == success_response
    assert user_v2_logic.current_user_owns_object('podcast', 1) == success_response
    assert user_v2_logic.current_user_owns_object('episode', 1) == success_response
    assert user_v2_logic.current_user_owns_object('adupload', 1) == success_response


def test_current_user_owns_object_success_show_family_user(
        mock_current_podcast_level_user, monkeypatch):
    """Test current_user_owns_object success for show family level user."""
    success_response = {'authorized': True}
    assert user_v2_logic.current_user_owns_object('podcast', 1) == success_response
    assert user_v2_logic.current_user_owns_object('episode', 1) == success_response
    assert user_v2_logic.current_user_owns_object('adupload', 1) == success_response


def test_current_user_owns_object_fails_network_admin_user(
        mock_current_network_admin_user_second, monkeypatch):
    """Test current_user_owns_object fails for network admin user."""
    assert {'authorized': False} == user_v2_logic.current_user_owns_object('network', 1)
    assert {'authorized': False} == user_v2_logic.current_user_owns_object('podcast', 1)
    assert {'authorized': False} == user_v2_logic.current_user_owns_object('episode', 1)
    assert {'authorized': False} == user_v2_logic.current_user_owns_object('adupload', 1)
    assert {'authorized': False} == user_v2_logic.current_user_owns_object('cow', 1)


def test_current_user_owns_object_fails_show_family_user(
        mock_current_show_level_user, monkeypatch):
    """Test current_user_owns_object fails for show family level user."""
    assert {'authorized': False} == user_v2_logic.current_user_owns_object('podcast', 2)
    assert {'authorized': False} == user_v2_logic.current_user_owns_object('episode', 3)
    assert {'authorized': False} == user_v2_logic.current_user_owns_object('adupload', 7)
    assert {'authorized': False} == user_v2_logic.current_user_owns_object('cow', 1)


def test_specific_podcast_ids_for_current_user():
    """Test get podcast ids current user has show level access."""
    current_user = user_model.get_user_by_id(11)
    response = user_v2_logic.specific_podcast_ids_for_current_user(current_user)
    assert response == [1, 3]


def test_users_for_order_fails_if_no_access(mock_current_user):
    """Test users for order fails if no access to user."""
    with pytest.raises(OwsError) as err:
        user_v2_logic.users_for_order('mp1')
    assert err.value.status == 403


def test_users_for_order_fails_if_no_access_to_network_or_show_family(mock_current_network_admin_user_second):
    """Test users for order fails if no access to network or podcast."""
    with pytest.raises(OwsError) as err:
        user_v2_logic.users_for_order('mp1')
    assert err.value.status == 403


def test_users_for_order_not_found(mock_current_admin_user):
    """Test users for order not found."""
    with pytest.raises(OwsError) as err:
        user_v2_logic.users_for_order('error')
    assert err.value.status == 404


def test_users_for_order(mock_current_admin_user):
    """Test users for order success."""
    results = user_v2_logic.users_for_order('mp2')['items']
    assert len(results) == 3
    assert results[0]['name'] == 'user-other-network'
    assert results[1]['name'] == 'two-network-user'
    assert results[2]['name'] == 'podcast-level-user'


def test_users_for_order_with_network_admin(mock_current_network_admin_user):
    """Test users for order success."""
    results = user_v2_logic.users_for_order('mp1')['items']
    assert len(results) == 4
    assert results[0]['name'] == 'username'
    assert results[1]['name'] == 'network-admin-user'
    assert results[2]['name'] == 'two-network-user'
    assert results[3]['name'] == 'podcast-level-user'