"""Test for User logic tier."""
from unittest.mock import MagicMock
from unittest.mock import patch
import uuid as python_uuid

from owsresponse import response
import pytest
from pythonfeatures import pythonfeatures

from podcast.constants import error as error
from podcast.logic import user as user_logic
from podcast.logic import user_v2 as user_v2_logic
from podcast.models import ows_users
from podcast.models import podcast as podcast_model
from podcast.models import user as user_model
from podcast.utils import api_utils
from podcast.utils.exc import OwsError
from tests.utils import db_operations


next_user_data_id = len(db_operations.user_data) + 1


def test_create_user_fails_if_no_access(mock_current_user):
    """Test create user fails if no access."""
    with pytest.raises(OwsError) as err:
        user_logic.create_user({})
    assert err.value.status == 403


def test_create_user_fails_if_network_admin_has_limited_access(mock_current_network_admin_user):
    """Test create user fails if limited access."""
    with pytest.raises(OwsError) as err:
        user_logic.create_user({'all_networks': True, 'role': 'producer'})
    assert err.value.status == 403
    assert err.value.message == 'Access forbidden for all networks'


def test_create_user_fails_if_network_admin_has_no_access(mock_current_network_admin_user):
    """Test create user fails if no access."""
    with pytest.raises(OwsError) as err:
        user_logic.create_user({'network_ids': [1, 20], 'role': 'producer'})
    assert err.value.status == 403


def test_create_user_fails_if_network_admin_invites_other_org(mock_current_network_admin_user):
    """Test create user fails if network admin tries to invite a different org."""
    with pytest.raises(OwsError) as err:
        user_logic.create_user({'network_ids': [1], 'organization': 'sme', 'role': 'producer'})
    assert err.value.status == 403


@patch('podcast.logic.user.g', spec=['log', 'request_context'])
def test_create_user_already_created(mock_g, monkeypatch, mock_current_admin_user):
    """Test create user already created."""
    monkeypatch.setattr(ows_users, 'get_auth0_user_by_email', MagicMock(return_value='auth0|abc123'))
    monkeypatch.setattr(ows_users, 'check_for_existing_profile', MagicMock(return_value=True))
    monkeypatch.setattr(ows_users, 'get_identity_user_by_email', MagicMock(return_value={}))
    monkeypatch.setattr(ows_users, 'create_user_identity', MagicMock(return_value={'id': 'mock-uuid'}))
    monkeypatch.setattr(
        pythonfeatures,
        'get_single_feature',
        MagicMock(return_value=response.Response(message='disabled')))

    with pytest.raises(OwsError) as err:
        user_logic.create_user({
            'email': 'a@b.com', 'admin': True, 'name': 'Bobby', 'role': 'admin', 'organization': 'sme'})
    assert err.value.status == 400
    assert err.value.message == 'User already exists'


@patch('podcast.logic.user.g', spec=['log', 'request_context'])
def test_create_user_no_podcast_profile(mock_g, monkeypatch, mock_current_admin_user):
    """Test create user no podcast profile."""
    monkeypatch.setattr(ows_users, 'get_auth0_user_by_email', MagicMock(return_value='auth0|abc123'))
    monkeypatch.setattr(ows_users, 'get_identity_user_by_email', MagicMock(return_value={}))
    monkeypatch.setattr(ows_users, 'create_user_identity', MagicMock(return_value={'id': 'mock-uuid'}))
    monkeypatch.setattr(ows_users, 'check_for_existing_profile', MagicMock(return_value=False))
    monkeypatch.setattr(ows_users, 'create_auth0_profile', MagicMock(return_value={'profile_id': 12}))
    monkeypatch.setattr(
        pythonfeatures,
        'get_single_feature',
        MagicMock(return_value=response.Response(message='disabled')))

    result = user_logic.create_user({'email': 'a@b.com', 'role': 'admin', 'organization': 'sme', 'name': 'bob'})
    assert result['id'] == next_user_data_id
    assert result['role'] == 'admin'
    assert result['email'] == 'a@b.com'
    assert result['organization'] == 'sme'
    assert result['uuid'] == 'mock-uuid'
    ows_users.create_auth0_profile.assert_called_once_with('mock-uuid', 'admin', 'sme')


@patch('podcast.logic.user.g', spec=['log', 'request_context'])
def test_create_user(mock_g, monkeypatch, mock_current_admin_user):
    """Test create user no podcast profile."""
    monkeypatch.setattr(ows_users, 'get_auth0_user_by_email', MagicMock(return_value=None))
    monkeypatch.setattr(
        ows_users,
        'get_identity_user_by_email',
        MagicMock(side_effect=[{}]))
    monkeypatch.setattr(ows_users, 'create_user_identity', MagicMock(return_value={}))
    monkeypatch.setattr(ows_users, 'create_auth0_user', MagicMock(return_value={
        'identities': [{'user_id': 'a'}], 'user_metadata': {'orchardIdentityId': 'mock-uuid'}}))
    monkeypatch.setattr(ows_users, 'create_auth0_profile', MagicMock(return_value={'profile_id': 12}))
    monkeypatch.setattr(
        pythonfeatures,
        'get_single_feature',
        MagicMock(return_value=response.Response(message='disbaled')))

    result = user_logic.create_user(
        {'name': 'Cowboy Chris', 'email': 'a@b.com', 'role': 'admin', 'organization': 'sme'})
    assert result['id'] == next_user_data_id
    assert result['email'] == 'a@b.com'
    assert result['organization'] == 'sme'
    assert result['role'] == 'admin'
    assert result['uuid'] == 'mock-uuid'
    ows_users.create_auth0_profile.assert_called_once_with('mock-uuid', 'admin', 'sme')
    assert ows_users.get_identity_user_by_email.call_count == 1


@patch('podcast.logic.user.g', spec=['log', 'request_context'])
def test_create_user_new_flow(mock_g, monkeypatch, mock_current_admin_user, org_invite_data_fixture):
    """Test create user through new user creation flow."""
    monkeypatch.setattr(ows_users, 'get_auth0_user_by_email', MagicMock(return_value=None))
    monkeypatch.setattr(
        ows_users,
        'get_identity_user_by_email',
        MagicMock(side_effect=[{}]))
    monkeypatch.setattr(python_uuid, 'uuid4', MagicMock(return_value='mock-uuid'))
    monkeypatch.setattr(
        pythonfeatures,
        'get_single_feature',
        MagicMock(return_value=response.Response(message='enabled')))
    monkeypatch.setattr(ows_users, 'create_user_identity', MagicMock(return_value={}))
    monkeypatch.setattr(ows_users, 'create_auth0_profile', MagicMock(return_value={'profile_id': 12}))
    monkeypatch.setattr(ows_users, 'create_organization_invitation', MagicMock(return_value=org_invite_data_fixture))

    result = user_logic.create_user(
        {'name': 'Cowboy Chris', 'email': 'a@b.com', 'role': 'admin', 'organization': 'sme'})
    assert ows_users.get_identity_user_by_email.call_count == 1
    ows_users.create_user_identity.assert_called_once_with('mock-uuid', 'Cowboy Chris', 'a@b.com', 'sme')
    ows_users.create_auth0_profile.assert_called_once_with('mock-uuid', 'admin', 'sme')
    ows_users.create_organization_invitation.assert_called_once_with(
        'mock-uuid', 'a@b.com', 'sme')
    assert result['id'] == next_user_data_id
    assert result['email'] == 'a@b.com'
    assert result['organization'] == 'sme'
    assert result['role'] == 'admin'
    assert result['uuid'] == 'mock-uuid'


@patch('podcast.logic.user.g', spec=['log', 'request_context'])
def test_create_user_new_flow_existing_identity(mock_g, monkeypatch, mock_current_admin_user, org_invite_data_fixture):
    """Test create user through new user creation flow for an existing identity in neo4j."""
    monkeypatch.setattr(ows_users, 'get_auth0_user_by_email', MagicMock(return_value=None))
    monkeypatch.setattr(
        ows_users,
        'get_identity_user_by_email',
        MagicMock(return_value={'id': 'existing-uuid'}))
    monkeypatch.setattr(
        pythonfeatures,
        'get_single_feature',
        MagicMock(return_value=response.Response(message='enabled')))
    monkeypatch.setattr(ows_users, 'create_auth0_profile', MagicMock(return_value={'profile_id': 12}))
    monkeypatch.setattr(ows_users, 'create_organization_invitation', MagicMock(return_value=org_invite_data_fixture))

    result = user_logic.create_user(
        {'name': 'Cowboy Chris', 'email': 'a@b.com', 'role': 'admin', 'organization': 'sme'})
    assert ows_users.get_identity_user_by_email.call_count == 1
    ows_users.create_auth0_profile.assert_called_once_with('existing-uuid', 'admin', 'sme')
    ows_users.create_organization_invitation.assert_called_once_with(
        'existing-uuid', 'a@b.com', 'sme')
    assert result['id'] == next_user_data_id
    assert result['email'] == 'a@b.com'
    assert result['organization'] == 'sme'
    assert result['role'] == 'admin'
    assert result['uuid'] == 'existing-uuid'


@patch('podcast.logic.user.g', spec=['log', 'request_context'])
def test_create_user_new_flow_existing_auth0_user(mock_g, monkeypatch, mock_current_admin_user):
    """Test create user through new user creation flow for existing art-relation auth0 user."""
    monkeypatch.setattr(ows_users, 'get_auth0_user_by_email', MagicMock(return_value='auth0|12345'))
    monkeypatch.setattr(
        pythonfeatures,
        'get_single_feature',
        MagicMock(return_value=response.Response(message='enabled')))
    monkeypatch.setattr(
        ows_users,
        'get_identity_user_by_email',
        MagicMock(return_value={'id': 'existing-uuid'}))
    monkeypatch.setattr(ows_users, 'check_for_existing_profile', MagicMock(return_value=False))
    monkeypatch.setattr(ows_users, 'create_auth0_profile', MagicMock(return_value={'profile_id': 12}))
    monkeypatch.setattr(ows_users, 'create_organization_members', MagicMock())

    result = user_logic.create_user(
        {'name': 'Cowboy Chris', 'email': 'a@b.com', 'role': 'admin', 'organization': 'sme'})
    assert ows_users.get_identity_user_by_email.call_count == 1
    ows_users.create_auth0_profile.assert_called_once_with('existing-uuid', 'admin', 'sme')
    ows_users.create_organization_members.assert_called_once_with(
        'sme', ['auth0|12345'])
    assert result['id'] == next_user_data_id
    assert result['email'] == 'a@b.com'
    assert result['organization'] == 'sme'
    assert result['role'] == 'admin'
    assert result['uuid'] == 'existing-uuid'


@patch('podcast.logic.user.g', spec=['log', 'request_context'])
def test_create_podcast_level_user(mock_g, monkeypatch, mock_current_admin_user):
    """Test create user with podcast level access."""
    monkeypatch.setattr(ows_users, 'get_auth0_user_by_email', MagicMock(return_value=None))
    monkeypatch.setattr(ows_users, 'get_identity_user_by_email', MagicMock(return_value={}))
    monkeypatch.setattr(ows_users, 'create_user_identity', MagicMock(return_value={}))
    monkeypatch.setattr(ows_users, 'create_auth0_user', MagicMock(return_value={
        'identities': [{'user_id': 'a'}], 'user_metadata': {'orchardIdentityId': 'mock-uuid'}}))
    monkeypatch.setattr(ows_users, 'create_auth0_profile', MagicMock(return_value={'profile_id': 12}))
    monkeypatch.setattr(
        pythonfeatures,
        'get_single_feature',
        MagicMock(return_value=response.Response(message='disbaled')))

    result = user_logic.create_user(
        {'name': 'Cowboy Chris', 'email': 'a@b.com', 'role': 'producer', 'organization': 'sme', 'podcast_ids': [1]})
    assert result['id'] == next_user_data_id
    assert result['email'] == 'a@b.com'
    assert result['organization'] == 'sme'
    assert result['role'] == 'producer'
    assert result['uuid'] == 'mock-uuid'
    assert len(result['podcasts']) == 1
    assert result['podcasts'][0]['id'] == 1
    ows_users.create_auth0_profile.assert_called_once_with('mock-uuid', 'producer', 'sme')


def test_create_podcast_level_user_no_access(monkeypatch, mock_current_network_admin_user, podcast_fixture):
    """Test create user with podcast level access."""
    with pytest.raises(OwsError) as err:
        user_logic.create_user(
            {'name': 'Cowboy Chris', 'email': 'a@b.com', 'role': 'admin', 'organization': 'sme', 'podcast_ids': [1]})
    assert err.value.status == 403


def test_create_podcast_level_user_incorrect_role(monkeypatch, mock_current_admin_user):
    """Test create user with podcast level access."""
    with pytest.raises(OwsError) as err:
        user_logic.create_user(
            {'name': 'Cowboy Chris', 'email': 'a@b.com', 'role': 'admin', 'organization': 'sme', 'podcast_ids': [1]})
    assert err.value.status == 403


@patch('podcast.logic.user.g', spec=['log', 'request_context'])
def test_create_read_only_producer_user(mock_g, monkeypatch, mock_current_admin_user):
    """Test create user with read only access."""
    monkeypatch.setattr(ows_users, 'get_auth0_user_by_email', MagicMock(return_value=None))
    monkeypatch.setattr(ows_users, 'get_identity_user_by_email', MagicMock(return_value={}))
    monkeypatch.setattr(ows_users, 'create_user_identity', MagicMock(return_value={}))
    monkeypatch.setattr(ows_users, 'create_auth0_user', MagicMock(return_value={
        'identities': [{'user_id': 'a'}], 'user_metadata': {'orchardIdentityId': 'mock-uuid'}}))
    monkeypatch.setattr(ows_users, 'create_auth0_profile', MagicMock(return_value={'profile_id': 12}))
    monkeypatch.setattr(
        pythonfeatures,
        'get_single_feature',
        MagicMock(return_value=response.Response(message='disbaled')))

    input_data = {
        'name': 'Cowboy Chris',
        'email': 'a@b.com',
        'role': 'read-only-producer',
        'organization': 'sme',
        'podcast_ids': [1]
    }
    result = user_logic.create_user(input_data)
    assert result['id'] == next_user_data_id
    assert result['email'] == 'a@b.com'
    assert result['organization'] == 'sme'
    assert result['role'] == 'read-only-producer'
    assert result['uuid'] == 'mock-uuid'
    assert len(result['podcasts']) == 1
    assert result['podcasts'][0]['id'] == 1
    ows_users.create_auth0_profile.assert_called_once_with('mock-uuid', 'read-only-producer', 'sme')


def test_create_read_only_producer_user_no_access(monkeypatch, mock_current_network_admin_user, podcast_fixture):
    """Test create user with no podcast access for network admin."""
    input_data = {
        'name': 'Cowboy Chris',
        'email': 'a@b.com',
        'role': 'read-only-producer',
        'organization': 'orchard',
        'podcast_ids': [7]
    }
    with pytest.raises(OwsError) as err:
        user_logic.create_user(input_data)
    assert err.value.status == 403


def test_create_read_only_producer_user_incorrect_role(monkeypatch, mock_current_admin_user):
    """Test create user with incorrect role."""
    with pytest.raises(OwsError) as err:
        user_logic.create_user(
            {'name': 'Cowboy Chris', 'email': 'a@b.com', 'role': 'admin', 'organization': 'sme', 'podcast_ids': [1]})
    assert err.value.status == 403


@patch('podcast.logic.user.g', spec=['log', 'request_context'])
def test_create_user_role(mock_g, monkeypatch, mock_current_admin_user):
    """Test create user no podcast profile."""
    monkeypatch.setattr(
        ows_users,
        'get_identity_user_by_email',
        MagicMock(side_effect=[{}]))
    monkeypatch.setattr(ows_users, 'get_auth0_user_by_email', MagicMock(return_value=None))
    monkeypatch.setattr(ows_users, 'create_auth0_user', MagicMock(return_value={
        'identities': [{'user_id': 'a'}], 'user_metadata': {'orchardIdentityId': 'mock-uuid'}}))
    monkeypatch.setattr(ows_users, 'create_auth0_profile', MagicMock(return_value={'profile_id': 12}))
    monkeypatch.setattr(
        pythonfeatures,
        'get_single_feature',
        MagicMock(return_value=response.Response(message='disbaled')))

    result = user_logic.create_user(
        {'name': 'Cowboy Chris', 'email': 'a@b.com', 'role': 'admin', 'organization': 'sme'})
    assert result['id'] == next_user_data_id
    assert result['role'] == 'admin'
    assert result['email'] == 'a@b.com'
    assert result['organization'] == 'sme'
    assert result['uuid'] == 'mock-uuid'


def test_update_user_fails_if_no_access(mock_current_user):
    """Test create user fails if no access."""
    with pytest.raises(OwsError) as err:
        user_logic.update_user(1, {})
    assert err.value.status == 403


def test_update_user_fails_for_network_admin(mock_current_network_admin_user):
    """Test update user fails if no access."""
    with pytest.raises(OwsError) as err:
        user_logic.update_user(1, {'network_ids': [1]})
    assert err.value.status == 403


def test_update_user_last_login_success(mock_current_user, monkeypatch):
    """Test update_user_last_login success."""
    monkeypatch.setattr(
        user_model, 'update_user_last_login', MagicMock(
            return_value='data'))
    result = user_logic.update_user_last_login(
        'auth0-test-user-1',
        {'last_login': '2022-11-03T13:23:00.000Z'}
    )
    assert result == 'data'


def test_get_users_org_admin(monkeypatch, mock_current_admin_user):
    """Test get users as org admin calls get_users."""
    monkeypatch.setattr(user_model, 'get_users', MagicMock(return_value=None))
    user_logic.get_users(0, 0, 'orchard', [1, 2])
    user_model.get_users.assert_called_once_with(0, 0, [1, 2], [1, 2], 'orchard')


def test_get_users_network_admin_network_filter(monkeypatch, mock_current_network_admin_user):
    """Test get users as network admin with network_ids."""
    mock_users = [user_model.get_user_by_id(8), user_model.get_user_by_id(11)]
    monkeypatch.setattr(user_model, 'get_users', MagicMock(return_value={'items': mock_users}))
    resp = user_logic.get_users(0, 0, None, [1])
    user_model.get_users.assert_called_once_with(0, 0, [1], [1], exclude_admins=True)
    assert len(resp['items'][0]['networks']) == 1
    assert len(resp['items'][1]['podcasts']) == 1

    assert resp['items'][0]['networks'][0]['id'] == 1
    assert resp['items'][1]['podcasts'][0]['id'] == 1


def test_get_users_network_admin(monkeypatch, mock_current_network_admin_user):
    """Test get users as network admin."""
    monkeypatch.setattr(user_model, 'get_users', MagicMock(return_value={'items': [user_model.get_user_by_id(8)]}))
    resp = user_logic.get_users(0, 0, None, None)
    user_model.get_users.assert_called_once_with(0, 0, [1], [1, 2], exclude_admins=True)
    assert len(resp['items'][0]['networks']) == 1
    assert resp['items'][0]['networks'][0]['id'] == 1
    assert resp['items'][0]['email'] is None


def test_get_users_fails_if_no_access(mock_current_user):
    """Test get users with fails if no access."""
    with pytest.raises(OwsError) as err:
        user_logic.get_users(0, 0, None, None)
    assert err.value.status == 403


def test_get_users_org_filters_fails_if_no_access(mock_current_network_admin_user):
    """Test get users with org filter fails if no access."""
    with pytest.raises(OwsError) as err:
        user_logic.get_users(0, 0, 'orchard', None)
    assert err.value.status == 403


def test_get_users_network_filters_fails_if_no_access(mock_current_network_admin_user):
    """Test get users with network id filters fails if no access."""
    with pytest.raises(OwsError) as err:
        user_logic.get_users(0, 0, None, [1, 2])
    assert err.value.status == 403


def test_delete_user_fails_if_no_access(mock_current_user):
    """Test delete user fails if no access."""
    with pytest.raises(OwsError) as err:
        user_logic.delete_user(1)
    assert err.value.status == 403


def test_delete_user_profile_fails(monkeypatch, mock_current_admin_user):
    """Test create user no podcast profile."""
    monkeypatch.setattr(ows_users, 'delete_profile', MagicMock(return_value=False))

    with pytest.raises(OwsError) as err:
        user_logic.delete_user(1)
    assert err.value.status == 500


def test_delete_user(monkeypatch, mock_current_admin_user):
    """Test create user no podcast profile."""
    monkeypatch.setattr(ows_users, 'delete_profile', MagicMock(return_value=True))

    result = user_logic.delete_user(1)
    ows_users.delete_profile.assert_called_with(1)
    assert result['id'] == 1


def test_users_for_network_fails_if_no_access(mock_current_user):
    """Test users for network fails if no access."""
    with pytest.raises(OwsError) as err:
        user_logic.users_for_network_ids([2])
    assert err.value.status == 403


@patch('podcast.utils.feature_flag_utils.get_feature_flag', return_value=False)
def test_users_by_ids_no_access_for_producer(mock_get_feature_flag, mock_current_user):
    """Test users by ids no access for producer."""
    results = user_logic.get_users_by_ids([7])
    assert results['items'] == []


@patch('podcast.utils.feature_flag_utils.get_feature_flag', return_value=False)
def test_users_by_ids_for_producer(mock_get_feature_flag, mock_current_podcast_level_user):
    """Test users by ids no access for producer."""
    result = user_logic.get_users_by_ids([11])['items']
    assert len(result) == 1
    assert result[0]['name'] == 'podcast-level-user'


@patch('podcast.utils.feature_flag_utils.get_feature_flag', return_value=False)
def test_users_by_ids_for_producer_on_podcast_network(mock_get_feature_flag, mock_current_podcast_level_user):
    """Test users by ids access for producer based podcast's networks."""
    result = user_logic.get_users_by_ids([6])['items']
    assert len(result) == 1
    assert result[0]['name'] == 'network-admin-user'


@patch('podcast.utils.feature_flag_utils.get_feature_flag', return_value=False)
def test_users_by_ids_no_access_for_network_admin(mock_get_feature_flag, mock_current_network_admin_user):
    """Test users for network admin with no access."""
    results = user_logic.get_users_by_ids([7, 8])['items']
    assert len(results) == 1
    assert results[0]['id'] == 8


@patch('podcast.utils.feature_flag_utils.get_feature_flag', return_value=False)
def test_users_by_ids_for_network_admin(mock_get_feature_flag, mock_current_network_admin_user):
    """Test users for network admins."""
    result = user_logic.get_users_by_ids([1, 8])['items']
    assert len(result) == 2
    assert result[0]['name'] == 'username'
    assert result[1]['name'] == 'two-network-user'


@patch('podcast.utils.feature_flag_utils.get_feature_flag', return_value=False)
def test_users_by_ids_for_network_admin_access_show_level_user(mock_get_feature_flag, mock_current_network_admin_user):
    """Test users for network admins can access show level user within it's network."""
    result = user_logic.get_users_by_ids([11])['items']
    assert len(result) == 1
    assert result[0]['name'] == 'podcast-level-user'


@patch('podcast.utils.feature_flag_utils.get_feature_flag', return_value=False)
def test_users_by_ids_for_show_level_user_access_admin(mock_get_feature_flag, mock_current_podcast_level_user):
    """Test users for podcast level can access admin."""
    result = user_logic.get_users_by_ids([2])['items']
    assert len(result) == 1
    assert result[0]['id'] == 2


@patch('podcast.utils.feature_flag_utils.get_feature_flag', return_value=True)
def test_users_by_ids_for_show_family_level_user_access_admin(mock_get_feature_flag, mock_current_podcast_level_user):
    """Test users for show family level can access admin."""
    result = user_logic.get_users_by_ids([2])['items']
    assert len(result) == 1
    assert result[0]['id'] == 2


@patch('podcast.utils.feature_flag_utils.get_feature_flag', return_value=False)
def test_users_by_ids_for_network_admin_all_access(mock_get_feature_flag, mock_current_network_admin_user_all_access):
    """Test users for network admins with all network access."""
    result = user_logic.get_users_by_ids([1, 2, 4, 5, 10, 11])['items']
    assert len(result) == 6


@patch('podcast.utils.feature_flag_utils.get_feature_flag', return_value=False)
def test_users_by_ids_for_admin(mock_get_feature_flag, mock_current_admin_user):
    """Test users for org admin and network admins with all network access."""
    result = user_logic.get_users_by_ids([1, 2, 4, 5, 10, 11])['items']
    assert len(result) == 6


def test_owned_podcast_not_owned_by_id(mock_current_user):
    """Test no ownership."""
    assert user_logic.current_user_owns_podcast_id(2) is False


def test_podcast_ids_owned_by_current_user(mock_current_user):
    """Test podcast ids owned by current user."""
    assert user_logic.podcast_ids_owned_by_current_user() == [1]


def test_podcast_ids_owned_by_current_user_podcast_level(
        mock_current_podcast_level_user):
    """Test podcast ids owned by current user."""
    assert user_logic.podcast_ids_owned_by_current_user() == [1]


def test_podcast_ids_owned_by_current_user_podcast_level_with_available_user():
    """Test podcast ids owned by current with available podcast level user."""
    assert user_logic.podcast_ids_owned_by_current_user(user_model.get_user_by_id(11)) == [1]


def test_current_user_owns_podcast_ids(mock_current_user):
    """Test podcast ids owned by current user."""
    user_logic.current_user_owns_podcast_ids_or_raise([1])


def test_current_user_owns_podcast_ids_podcast_level(
        mock_current_podcast_level_user):
    """Test podcast ids owned by current user."""
    user_logic.current_user_owns_podcast_ids_or_raise([1])


def test_current_user_owns_podcast_ids_podcast_level_with_available_user():
    """Test podcast ids owned by current with available podcast level user."""
    user_logic.current_user_owns_podcast_ids_or_raise([1], user_model.get_user_by_id(11))


def test_current_user_does_not_own_podcast_ids(mock_current_user):
    """Test podcast ids not owned by user."""
    with pytest.raises(OwsError) as err:
        assert user_logic.current_user_owns_podcast_ids_or_raise([2])
    assert err.value.status == 403


def test_current_user_is_org_admin_or_raise(mock_current_admin_user):
    """Test current user is org admin or raise."""
    user_logic.current_user_is_org_admin_or_raise()


def test_current_user_is_org_admin_or_raise_fail(mock_current_user):
    """Test current user is org admin or raise."""
    with pytest.raises(OwsError) as err:
        assert user_logic.current_user_is_org_admin_or_raise()
    assert err.value.status == 403


def test_current_user_is_valid_or_raise(mock_current_user):
    """Test current user is valid or raise."""
    user_id = user_logic.current_user_is_valid_or_raise('auth0-test-user-1')
    assert user_id == 1


def test_current_user_is_valid_or_raise_failure(mock_current_user):
    """Test current user is org admin or raise failure."""
    with pytest.raises(OwsError) as err:
        assert user_logic.current_user_is_valid_or_raise('Billy')
    assert err.value.status == 403


def test_current_user_owns_network_ids(mock_current_user):
    """Test network ids owned by current user."""
    user_logic.current_user_owns_network_ids_or_raise([1])


def test_current_user_owns_network_ids_with_available_user():
    """Test network ids owned by current user."""
    user_logic.current_user_owns_network_ids_or_raise([1], current_user=user_model.get_user_by_id(1))


def test_current_user_does_not_own_network_ids(mock_current_user):
    """Test network ids not owned by user."""
    with pytest.raises(OwsError) as err:
        assert user_logic.current_user_owns_network_ids_or_raise([2])
    assert err.value.status == 403


def test_current_user_podcast_level_owns_network_ids(mock_current_podcast_level_user):
    """Test network ids not owned by user."""
    user_logic.current_user_owns_network_ids_or_raise([1], True)


def test_episode_ids_owned_by_current_user(mock_current_user):
    """Test episode ids owned by current user."""
    user_logic.current_user_owns_episodes_or_raise([1, 2])


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_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."""
    user_logic.current_user_owns_episodes_or_raise([1, 2])


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_logic.current_user_owns_episodes_or_raise([3])
    assert err.value.status == 403


def test_owned_podcast_owned_by_id(mock_current_user):
    """Test ownership works."""
    assert user_logic.current_user_owns_podcast_id(1) is True


def test_admin_owns_podcast_by_id(mock_current_admin_user):
    """Test admin owns podcast."""
    assert user_logic.current_user_owns_podcast_id(2) is True


def test_current_podcast_level_owns_podcast_by_id(mock_current_podcast_level_user):
    """Test podcast level user owns podcast."""
    assert user_logic.current_user_owns_podcast_id(1) is True


def test_podcast_level_owns_podcast_by_id():
    """Test podcast level user owns podcast."""
    assert user_logic.user_owns_podcast_id(11, 1) is True


def test_current_user_is_org_admin(mock_current_admin_user):
    """Test current user is org admin."""
    assert user_logic.current_user_is_org_admin() is True


def test_current_user_is_org_admin_fails(mock_current_network_admin_user):
    """Test current user is not org admin."""
    assert user_logic.current_user_is_org_admin() is False


def test_current_user_is_network_admin(mock_current_network_admin_user):
    """Test current user is network admin."""
    assert user_logic.current_user_is_network_admin() is True


def test_current_user_is_network_admin_with_available_user():
    """Test current user with available network admin  user."""
    assert user_logic.current_user_is_network_admin(user_model.get_user_by_id(6)['role']) is True


def test_current_user_is_network_admin_fails(mock_current_admin_user):
    """Test current user is not network admin."""
    assert user_logic.current_user_is_network_admin() is False


def test_current_user_is_admin_or_raise(mock_current_admin_user):
    """Test current user is admin or raise."""
    user_logic.current_user_is_admin_or_raise()


def test_current_user_is_admin_or_raise_with_available_user():
    """Test current user with available admin user or raise."""
    user_logic.current_user_is_admin_or_raise(user_model.get_user_by_id(2)['role'])


def test_current_user_is_admin_or_raise_fails(mock_current_network_admin_user):
    """Test current user raises error for non admin."""
    with pytest.raises(OwsError) as err:
        user_logic.current_user_is_admin_or_raise(2)
    assert err.value.status == 403


def test_owned_podcast_owned(mock_current_user):
    """Test ownership works."""
    podcast = podcast_model.get_podcast_by_id(1)
    assert user_logic.current_user_owns_podcast(podcast) is True


def test_current_user_owns_podcast_id_or_raise(mock_current_user):
    """Test no ownership raises."""
    with pytest.raises(OwsError) as err:
        user_logic.current_user_owns_podcast_id_or_raise(2)
    assert err.value.status == 403


def test_current_user_owns_podcast_or_raise(mock_current_user):
    """Test no ownership raises."""
    podcast = podcast_model.get_podcast_by_id(2)
    with pytest.raises(OwsError) as err:
        user_logic.current_user_owns_podcast_or_raise(podcast)
    assert err.value.status == 403


def test_current_user_owns_podcasts_or_raise(mock_current_user):
    """Test no ownership raises."""
    podcast = podcast_model.get_podcast_by_id(2)
    with pytest.raises(OwsError) as err:
        user_logic.current_user_owns_podcasts_or_raise([podcast])
    assert err.value.status == 403


def test_current_user_owns_object_success(mock_current_user, monkeypatch):
    """Test check ownership of the object success."""
    success_response = {'authorized': True}
    assert user_logic.current_user_owns_object('network', 1) == success_response
    assert user_logic.current_user_owns_object('podcast', 1) == success_response
    assert user_logic.current_user_owns_object('episode', 1) == success_response
    assert user_logic.current_user_owns_object('adupload', 1) == success_response


def test_current_user_owns_object_fails(monkeypatch):
    """Test check ownership of the object fails."""
    monkeypatch.setattr(api_utils, 'get_user_id', MagicMock(
        return_value=5
    ))
    monkeypatch.setattr(api_utils, 'get_current_user', MagicMock(
        return_value=user_model.get_user_by_id(5)
    ))

    assert {'authorized': False} == user_logic.current_user_owns_object('network', 1)
    assert {'authorized': False} == user_logic.current_user_owns_object('podcast', 1)
    assert {'authorized': False} == user_logic.current_user_owns_object('episode', 1)
    assert {'authorized': False} == user_logic.current_user_owns_object('adupload', 1)
    assert {'authorized': False} == user_logic.current_user_owns_object('cow', 1)


def test_create_user_with_existing_email(mock_current_admin_user):
    """Test create user with existing email."""
    with pytest.raises(OwsError) as err:
        user_logic.create_user(
            {'name': 'Cowboy Chris', 'email': 'user_email@theorchard.com', 'role': 'admin', 'organization': 'sme'})
    assert err.value.status == 400
    assert err.value.message == error.ERROR_MESSAGE_USER_ALREADY_EXISTS


def test_specific_podcast_ids_for_user():
    """Test get podcast ids user has podcast level access to."""
    mock_podcast_level_user = user_model.get_user_by_id(11)
    response = user_logic.specific_podcast_ids_for_user(mock_podcast_level_user)
    assert response == [1]


def test_specific_podcast_ids_for_user_id():
    """Test get podcast ids user has podcast level access to."""
    response = user_logic.specific_podcast_ids_for_user_id(11)
    assert response == [1]


def test_specific_podcast_ids_for_user_id_none():
    """Test get podcast ids user has podcast level access to."""
    response = user_logic.specific_podcast_ids_for_user_id(8)
    assert response == []


def test_specific_podcast_ids_for_current_user(mock_current_podcast_level_user):
    """Test get podcast ids current user has podcast level access to."""
    response = user_logic.specific_podcast_ids_for_current_user()
    assert response == [1]


def test_specific_podcast_ids_for_current_with_available_user():
    """Test get podcast ids current with available user has podcast level access to."""
    response = user_logic.specific_podcast_ids_for_current_user(user_model.get_user_by_id(11))
    assert response == [1]


def test_specific_podcast_ids_for_current_user_none(mock_current_admin_user):
    """Test get podcast ids current user has podcast level access to."""
    response = user_logic.specific_podcast_ids_for_current_user()
    assert response == []


def test_network_ids_for_current_user(mock_current_network_admin_user):
    """Test get network ids for current user has network level access to."""
    response = user_logic.network_ids_for_current_user()
    assert response == [1]


def test_network_ids_for_current_user_with_available_user():
    """Test get network ids for current with available user has network level access to."""
    response = user_logic.network_ids_for_current_user(user_model.get_user_by_id(6))
    assert response == [1]


def test_network_ids_for_current_user_none(mock_current_podcast_level_user):
    """Test get network ids  for current user has network level access to."""
    response = user_logic.network_ids_for_current_user()
    assert response == []


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_logic.users_for_order('mp1')
    assert err.value.status == 403


def test_users_for_order_fails_if_no_access_to_network_or_podcast(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_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_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_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_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_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_logic.current_user_owns_ad_action(
        unowned_ad_read)
    assert result is False


@patch('podcast.logic.user.g', spec=['log', 'request_context'])
def test_create_orchard_user(mock_g, monkeypatch, mock_current_admin_user, org_invite_data_fixture):
    """Test create user with create identity and profile being called with theorchard brand."""
    monkeypatch.setattr(ows_users, 'get_auth0_user_by_email', MagicMock(return_value=None))
    monkeypatch.setattr(
        ows_users,
        'get_identity_user_by_email',
        MagicMock(side_effect=[{}]))
    monkeypatch.setattr(python_uuid, 'uuid4', MagicMock(return_value='mock-uuid'))
    monkeypatch.setattr(
        pythonfeatures,
        'get_single_feature',
        MagicMock(return_value=response.Response(message='enabled')))
    monkeypatch.setattr(ows_users, 'create_user_identity', MagicMock(return_value={}))
    monkeypatch.setattr(ows_users, 'create_auth0_profile', MagicMock(return_value={'profile_id': 12}))
    monkeypatch.setattr(ows_users, 'create_organization_invitation', MagicMock(return_value=org_invite_data_fixture))

    result = user_logic.create_user(
        {'name': 'Cowboy Chris', 'email': 'a@b.com', 'role': 'admin', 'organization': 'orchard'})
    assert ows_users.get_identity_user_by_email.call_count == 1
    ows_users.create_user_identity.assert_called_once_with('mock-uuid', 'Cowboy Chris', 'a@b.com', 'theorchard')
    ows_users.create_auth0_profile.assert_called_once_with('mock-uuid', 'admin', 'theorchard')
    ows_users.create_organization_invitation.assert_called_once_with(
        'mock-uuid', 'a@b.com', 'orchard')
    assert result['id'] == next_user_data_id
    assert result['email'] == 'a@b.com'
    assert result['organization'] == 'orchard'
    assert result['role'] == 'admin'
    assert result['uuid'] == 'mock-uuid'


@patch('podcast.utils.feature_flag_utils.get_feature_flag', return_value=False)
def test_check_ownership_feature_flag_off(
        mock_get_feature_flag, monkeypatch, mock_current_admin_user, participant_fixture, seasons_fixture):
    """Test check ownership when feature flag off."""
    monkeypatch.setattr(user_logic, 'current_user_owns_object', MagicMock())
    user_logic.check_ownership('podcast', 1)
    user_logic.current_user_owns_object.assert_called_once_with('podcast', 1)


@patch('podcast.utils.feature_flag_utils.get_feature_flag', return_value=True)
def test_check_ownership_feature_flag_on(
        mock_get_feature_flag, monkeypatch, mock_current_admin_user, participant_fixture, seasons_fixture):
    """Test check ownership when feature flag on."""
    monkeypatch.setattr(user_v2_logic, 'current_user_owns_object', MagicMock())
    user_logic.check_ownership('podcast', 1)
    user_v2_logic.current_user_owns_object.assert_called_once_with('podcast', 1)