"""Unit tests for user model."""

from datetime import datetime
from unittest.mock import patch

import pytest

from podcast.connectors import mysql
from podcast.constants import error
from podcast.models import network
from podcast.models import user
from podcast.utils.exc import OwsError


def test_get_user_by_id():
    """Test user model returns data by provided user_id."""
    user_id = 1
    result = user.get_user_by_id(user_id)
    assert isinstance(result, dict)
    assert result['email'] == 'user_email@theorchard.com'


def test_get_user_by_id_not_found():
    """Test user model raises OwsError by provided bad user_id."""
    user_id = 'some-not-existing-user-id'
    with pytest.raises(OwsError) as err:
        user.get_user_by_id(user_id)
    assert err.value.message == '{} {}'.format('some-not-existing-user-id', error.ERROR_MESSAGE_USER_NOT_FOUND)


def test_get_user_by_uuid():
    """Test user model returns data by provided uuid."""
    uuid = 'two-network-user'
    result = user.get_user_by_uuid(uuid)
    assert isinstance(result, dict)
    assert result['email'] == 'two-network-user@theorchard.com'


def test_all_access_users():
    """Test admin_users."""
    result = user.all_access_users()
    ids = [r['id'] for r in result['items']]
    assert ids == [2, 4, 10, 13, 14]


def test_get_user_by_uuid_not_found():
    """Test user model raises OwsError by provided bad uuid."""
    uuid = 'bad-uuid'
    with pytest.raises(OwsError) as err:
        user.get_user_by_uuid(uuid)
    assert err.value.message == '{} {}'.format('bad-uuid', error.ERROR_MESSAGE_USER_NOT_FOUND)


def test_create_user(mock_current_user, user_fixture):
    """Test user model creates row in db."""
    result = user.create_user(user_fixture)
    result['id'] == 'auth0-podcast-user'
    result['email'] == 'podcast_user@theorchard.com'
    result['name'] == 'username'
    result['active'] is True
    result['language'] == 'en'
    result['profile_id'] is None
    result['networks'] == [{'id': 1, 'name': 'Broccoli test'}]
    result['podcasts'] == []
    result['updated_by'] is None
    result['created_by'] is None
    result['role'] == 'producer'
    result['all_networks'] is False


def test_create_user_already_exists_active(mock_current_user, user_fixture):
    """Test user model fails to create if active user already exists."""
    data = user_fixture
    data['uuid'] = 'auth0-test-user-1'
    with pytest.raises(OwsError) as err:
        user.create_user(data)
    assert err.value.status == 400


def test_create_user_already_exists_inactive(mock_current_user, user_fixture):
    """Test user model creates if inactive user already exists."""
    data = user_fixture
    data['uuid'] = 'SammyUnactive'
    result = user.create_user(data)
    assert result['uuid'] == 'SammyUnactive'


def test_create_user_with_multiple_networks(mock_current_user, user_fixture):
    """Test that user can be related to several networks."""
    new_network = network.Network(name='new_name')
    with mysql.pod_db_session() as session:
        session.add(new_network)
    network_ids = [1, new_network.id]
    data = user_fixture
    data['network_ids'] = network_ids
    result = user.create_user(data)
    assert result['networks'] == [
        {'id': 1, 'name': 'Broccoli test', 'is_sony': False, 'megaphone_id': '64756b62-7e5c-4728-895a-2f42f8969e14'},
        {'id': new_network.id, 'name': 'new_name', 'is_sony': False, 'megaphone_id': None}
    ]
    assert result['podcasts'] == []
    assert result['show_families'] == []


def test_create_user_with_multiple_shows(mock_current_user, show_level_podcast_user_fixture):
    """Test that user can be related to several shows."""
    show_level_podcast_user_fixture['uuid'] = '5da737d4d169330c5ad0f889'
    result = user.create_user(show_level_podcast_user_fixture)
    assert result['podcasts'][0]['title'] == 'title'
    assert result['podcasts'][1]['title'] == 'alpha title 1'
    assert result['networks'] == []
    assert result['show_families'] == []


def test_create_user_with_multiple_show_families(mock_current_user, show_level_show_family_user_fixture):
    """Test that user can be related to several shows."""
    show_level_show_family_user_fixture['uuid'] = '5da737d4d169330c5ad0f100'
    result = user.create_user(show_level_show_family_user_fixture)
    assert result['show_families'][0]['title'] == 'show family title 3'
    assert result['show_families'][1]['title'] == '4th show family'
    assert result['networks'] == []
    assert result['podcasts'] == []


def test_get_users():
    """Test get users."""
    limit = 50
    offset = 0

    users = user.get_users(limit, offset)
    assert len(users['items']) == 10
    assert users['pagination']['total_records'] == 10


def test_get_users_by_network_admin():
    """Test get users by network admin."""
    limit = 50
    offset = 0

    users = user.get_users(limit, offset, exclude_admins=True)
    assert len(users['items']) == 8
    assert users['pagination']['total_records'] == 8


def test_get_users_paginates():
    """Test get users."""
    limit = 1
    offset = 1

    users = user.get_users(limit, offset)
    assert len(users['items']) == 1
    assert users['pagination']['total_records'] == 10


def test_get_users_org_filter():
    """Test get users."""
    limit = 50
    offset = 0
    organization = 'sme'
    users = user.get_users(limit, offset, None, None, 'sme')
    assert len(users['items']) == 1
    assert users['pagination']['total_records'] == 1
    assert users['items'][0]['organization'] == organization


def test_get_users_network_filter():
    """Test get users network filter."""
    limit = 50
    offset = 0
    network_ids = [2]
    users = user.get_users(limit, offset, network_ids)
    assert len(users['items']) == 6
    assert users['pagination']['total_records'] == 6


def test_get_users_podcast_filter():
    """Test get users network and podcast filter."""
    limit = 50
    offset = 0
    network_ids = [2]
    podcast_ids = [2]
    users = user.get_users(limit, offset, network_ids, podcast_ids)
    user_ids = [user['id'] for user in users['items']]
    assert len(users['items']) == 7
    assert users['pagination']['total_records'] == 7
    # user list includes user with podcast level access
    assert 6 in user_ids


def test_delete_user():
    """Test delete user."""
    limit = 10
    offset = 0
    users = user.get_users(limit, offset)
    count = len(users['items'])

    deleted_user = user.delete_user(1)
    assert deleted_user['id'] == 1

    users = user.get_users(limit, offset)
    assert len(users['items']) == count - 1


def test_hard_delete_user():
    """Test hard delete user removed from db."""
    active_user = user.get_user_by_id(1)
    assert active_user['id'] == 1

    user.hard_delete_user(1)

    with mysql.pod_db_session() as session:
        now_deleted_user = session.query(user.User).filter(
            user.User.id == 1
        ).first()
        assert now_deleted_user is None


def test_delete_user_not_found():
    """Test delete user not found."""
    with pytest.raises(OwsError) as err:
        user.delete_user(1000)
    assert err.value.status == 404


def test_delete_user_disabled():
    """Test delete user that has already been disabled."""
    with pytest.raises(OwsError) as err:
        user.delete_user(3)
    assert err.value.status == 404


@patch('podcast.utils.feature_flag_utils.get_feature_flag', side_effect=[False])
def test_update_user(mock_feature_flag, mock_current_user):
    """Test update user."""
    fetched_user = user.get_user_by_id(1)
    assert len(fetched_user['networks']) == 1

    updated_user = user.update_user(1, {'network_ids': [1, 2]})
    assert updated_user['networks'][0]['name'] == 'Broccoli test'
    assert updated_user['networks'][1]['name'] == 'Cowhead test'
    assert updated_user['updated_by'] == '1'


def test_update_user_last_login(mock_current_user):
    """Test update_user_last_login."""
    updated_user = user.update_user_last_login(1, {'last_login': datetime(2022, 10, 22, 13, 11, 12)})
    assert updated_user['last_login'] == datetime(2022, 10, 22, 13, 11, 12)


@patch('podcast.utils.feature_flag_utils.get_feature_flag', side_effect=[False])
def test_update_user_podcast_level(mock_feature_flag, mock_current_user):
    """Test update user."""
    fetched_user = user.get_user_by_id(1)
    assert len(fetched_user['networks']) == 1
    assert fetched_user['podcasts'] == []

    updated_user = user.update_user(1, {'network_ids': [], 'podcast_ids': [1]})
    assert updated_user['networks'] == []
    assert updated_user['podcasts'][0]['title'] == 'title'
    assert updated_user['updated_by'] == '1'


@patch('podcast.utils.feature_flag_utils.get_feature_flag', side_effect=[False])
def test_update_user_podcast_level_no_podcast_ids(mock_feature_flag, mock_current_user):
    """Test update user without podcast_ids."""
    fetched_user = user.get_user_by_id(6)
    assert len(fetched_user['podcasts']) == 1

    updated_user = user.update_user(1, {'network_ids': [], 'podcast_ids': []})
    assert updated_user['podcasts'] == []
    assert updated_user['updated_by'] == '1'


@patch('podcast.utils.feature_flag_utils.get_feature_flag', side_effect=[True])
def test_update_user_podcast_level_ia_restructure_turned_on(mock_feature_flag, mock_current_user):
    """Test update user with ia_restructure turned on should not update user podcasts."""
    fetched_user = user.get_user_by_id(1)
    assert len(fetched_user['networks']) == 1
    assert fetched_user['podcasts'] == []

    updated_user = user.update_user(1, {'network_ids': [], 'podcast_ids': [1]})
    assert updated_user['networks'] == []
    assert updated_user['podcasts'] == []
    assert updated_user['updated_by'] == '1'


@patch('podcast.utils.feature_flag_utils.get_feature_flag', side_effect=[True])
def test_update_user_show_family_level(mock_feature_flag, mock_current_user):
    """Test update user."""
    fetched_user = user.get_user_by_id(1)
    assert len(fetched_user['networks']) == 1
    assert fetched_user['show_families'] == []

    updated_user = user.update_user(1, {'network_ids': [], 'show_family_ids': [1]})
    assert updated_user['networks'] == []
    assert updated_user['show_families'][0]['title'] == 'show family title 1'
    assert updated_user['updated_by'] == '1'


@patch('podcast.utils.feature_flag_utils.get_feature_flag', side_effect=[True])
def test_update_user_show_family_level_no_show_family_ids(mock_feature_flag, mock_current_user):
    """Test update user without show_family_ids."""
    fetched_user = user.get_user_by_id(11)
    assert len(fetched_user['show_families']) == 1

    updated_user = user.update_user(1, {'network_ids': []})
    assert updated_user['show_families'] == []
    assert updated_user['updated_by'] == '1'


@patch('podcast.utils.feature_flag_utils.get_feature_flag', side_effect=[False])
def test_update_user_show_family_level_ia_restructure_turned_off(mock_feature_flag, mock_current_user):
    """Test update user with ia_restructure turned off should not update user show families."""
    fetched_user = user.get_user_by_id(1)
    assert len(fetched_user['networks']) == 1
    assert fetched_user['show_families'] == []

    updated_user = user.update_user(1, {'network_ids': [], 'show_family_ids': [1]})
    assert updated_user['networks'] == []
    assert updated_user['show_families'] == []
    assert updated_user['updated_by'] == '1'


@patch('podcast.utils.feature_flag_utils.get_feature_flag', side_effect=[False])
def test_update_user_role(mock_feature_flag, mock_current_user):
    """Test update user role."""
    fetched_user = user.get_user_by_id(1)
    assert len(fetched_user['networks']) == 1
    assert fetched_user['podcasts'] == []

    updated_user = user.update_user(
        1,
        {'network_ids': [], 'podcast_ids': [1], 'role': 'network-admin'}
    )
    assert updated_user['networks'] == []
    assert updated_user['podcasts'][0]['title'] == 'title'
    assert updated_user['updated_by'] == '1'
    assert updated_user['role'] == 'network-admin'


def test_update_user_role_failure(mock_current_user):
    """Test update user role failure."""
    fetched_user = user.get_user_by_id(4)
    assert fetched_user['all_networks'] is True
    assert fetched_user['podcasts'] == []

    with pytest.raises(OwsError) as err:
        user.update_user(
            4,
            {'podcast_ids': [1], 'role': 'network-admin'}
        )
    assert err.value.status == 400
    assert err.value.message == error.ERROR_INCORRECT_ROLE


def test_update_user_not_found():
    """Test update user not found."""
    with pytest.raises(OwsError) as err:
        user.update_user('made-up-id', {'network_ids': [1, 2]})
    assert err.value.status == 404


def test_get_user_by_email():
    """Test user model returns data by provided email."""
    email = 'two-network-user@theorchard.com'
    result = user.get_user_by_email(email)
    assert result['uuid'] == 'two-network-user'


def test_get_user_by_email_false():
    """Test user model returns None for email which doesn't exists."""
    email = 'not-network-user@theorchard.com'
    result = user.get_user_by_email(email)
    assert result is None


def test_get_user_by_email_deleted():
    """Test user model returns None for email which is deleted."""
    email = 'sammy@theorchard.com'
    result = user.get_user_by_email(email)
    assert result is None


def test_delete_favorite_podcast_by_podcast_id():
    """Test delete podcast favorites by ids works."""
    favorites = user.get_user_favorites(6)
    assert favorites['podcasts'] == [{'podcast_id': 1}]

    with mysql.pod_db_session() as session:
        user.delete_favorite_podcast_by_podcast_id(1, session)

        favorites_none = user.get_user_favorites(6)
        assert favorites_none['podcasts'] == []


def test_users_for_podcast_and_network_ids():
    """Test get users for podcast and network ids."""
    response = user.users_for_podcast_and_network_ids([1], [1])
    assert len(response['items']) == 4


def test_user_has_access_to_show_family(mock_current_podcast_level_user):
    """Test get user returns show families."""
    response = user.get_user_by_id(11)
    assert len(response['show_families']) == 1
    assert response['show_families'][0]['id'] == 1


def test_users_for_show_family_and_network_ids():
    """Test get users for show family and network ids."""
    response = user.users_for_show_family_and_network_ids([1], [1])
    assert len(response['items']) == 4


def test_users_for_show_family_and_no_network_ids():
    """Test get users for show family and no network ids."""
    response = user.users_for_show_family_and_network_ids([1], [])
    assert len(response['items']) == 1


def test_users_for_no_show_family_and_network_ids():
    """Test get users for no show family and network ids."""
    response = user.users_for_show_family_and_network_ids([], [1])
    assert len(response['items']) == 3