"""Test model for OA user."""

from unittest.mock import MagicMock

import pytest

from grass.connectors import microservices, mysql
from grass.models import oa_user
from grass.utils import response

from tests.unit.fixtures import fixture_user


def test_get_user_by_id():
    """Test getting a OA user by its id."""
    current_user, status = fixture_user.create_oa_user()
    current_user_id = current_user.id

    for user_id_format in ['oa:{}', '{}']:
        user_id = user_id_format.format(current_user_id)
        fetched_user = oa_user.get_oa_user_by_id(user_id)
        assert fetched_user
        assert fetched_user.message.id == current_user.id
        assert fetched_user.message.user_id.startswith('oa:')


def test_get_missing_user():
    """Test getting a user that does not exist."""
    for user_id_format in ['oa:{}', '{}']:
        user_id = user_id_format.format(1984762)
        fetched_user = oa_user.get_oa_user_by_id(user_id)
        assert not fetched_user.success
        assert fetched_user.status == 404


def test_get_inactive_user_by_id():
    """Test getting a OA user by its id."""
    current_user, status = fixture_user.create_oa_user(is_active=False)
    current_user_id = current_user.id

    for user_id_format in ['oa:{}', '{}']:
        user_id = user_id_format.format(current_user_id)
        fetched_user = oa_user.get_oa_user_by_id(user_id)
        assert fetched_user is oa_user.DEACTIVATED_USER_RESPONSE


def test_create_oa_user_in_production(monkeypatch):
    """Try creating a OA user in production.

    Creating a user must only happen in a test environment.
    """
    monkeypatch.setattr(oa_user, 'OrchardAdminUser', MagicMock())
    with pytest.raises(AssertionError):
        monkeypatch.setattr(oa_user.config, 'environment', 'prod')
        oa_user.create_oa_user()

    assert not oa_user.OrchardAdminUser.called


def test_orchard_user_active():
    """Test if a user is active."""
    assert oa_user.is_active({'active': 'Y'})
    assert not oa_user.is_active({'active': 'N'})

    current_user, status = fixture_user.create_oa_user(is_active=True)
    assert oa_user.is_active(current_user)

    current_user, status = fixture_user.create_oa_user(is_active=False)
    assert not oa_user.is_active(current_user)


def setup_mock_raw_mysql_call(monkeypatch, fetchall_result):
    """Create some privileges.

    Args:
        monkeypatch (Patch): the monkeypatch.
        privileges (list): the list of privileges to apply.
    """
    monkeypatch.setattr(mysql, 'engine', MagicMock())
    cursor = MagicMock()
    cursor.fetchall.return_value = fetchall_result

    connection = MagicMock()
    mysql.engine.raw_connection.return_value = connection
    connection.cursor.return_value = cursor


def test_get_resource_privileges_for_user(monkeypatch):
    """Test getting resource privileges for user."""
    privileges = [
        ('user_id', 'resource', 'privilege1'),
        ('user_id', 'resource', 'privilege2'),
    ]

    setup_mock_raw_mysql_call(monkeypatch, privileges)
    response = oa_user.get_resource_privileges_for_user('user_id', 'resource')

    for position, privilege in enumerate(response):
        assert privilege.user_id == privileges[position][0]
        assert privilege.resource == privileges[position][1]
        assert privilege.privilege == privileges[position][2]


def test_get_empty_resource_privileges_for_user(monkeypatch):
    """Test getting empty list of resource privileges for user."""
    privileges = []
    setup_mock_raw_mysql_call(monkeypatch, privileges)

    response = oa_user.get_resource_privileges_for_user('user_id', 'resource')
    assert not response
    assert isinstance(response, list)


def test_get_roles_for_user(monkeypatch):
    """Test get_roles_for_user."""
    roles = [
        (1, 'Administrator'),
        (2, 'Marketing'),
        (3, 'Analytics'),
        (5, 'Accounting'),
        (6, 'Manage Rights'),
    ]
    expected = dict(
        role_ids=[1, 2, 3, 5, 6],
        role_names=[
            'Administrator',
            'Marketing',
            'Analytics',
            'Accounting',
            'Manage Rights',
        ],
    )
    user_id = 'oa:1234'

    cursor = MagicMock()
    cursor.fetchall.return_value = roles
    session = MagicMock()
    session.execute.return_value = cursor
    monkeypatch.setattr(mysql, 'session', lambda: session)

    fetched_roles = oa_user.get_roles_for_user(user_id)
    assert fetched_roles
    assert fetched_roles.message == expected


@pytest.mark.parametrize(
    'status_code,response_object',
    [
        (200, response.Response({'id': 'UUID', 'auth0_user_id': 'auth0id'})),
        (404, response.create_error_response(status=404)),
    ],
)
def test_get_identity_for_user(monkeypatch, status_code, response_object):
    """Test get identity from ows-users for OA user."""
    expected = {'id': 'UUID', 'auth0_user_id': 'auth0id'}
    mock_response = MagicMock()
    mock_response.json.return_value = expected
    mock_response.status_code = status_code
    user_id = 'oa:1234'
    mock_request = MagicMock()
    mock_request.return_value = mock_response
    monkeypatch.setattr(microservices, 'request', mock_request)
    identity_response = oa_user.get_user_identity(user_id)

    mock_request.assert_called_with(
        'GET',
        'ows-users',
        '/profile/profile_id/1234/' 'profile_type/OrchAdminProfile/identity',
    )
    assert identity_response.message == response_object.message
    assert identity_response.status == response_object.status