"""Test model for workstation user."""

from unittest.mock import MagicMock

import pytest

from grass.connectors import microservices, mysql
from grass.consts import user
from grass.consts.user import AccountTypes
from grass.models import workstation_user
from grass.utils import response

from tests.unit.fixtures import fixture_user


def setup_mock_privileges(monkeypatch, privileges):
    """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 = privileges

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


def setup_mock_mysql_query(monkeypatch, accounts, restricted_features=[]):
    """Create some linked accounts.

    Args:
        monkeypatch (Patch): the monkeypatch.
        accounts (list): the list of accounts to apply.
        restricted_features (list): the list of restricted features the
            second query should return.
    """
    cursor = MagicMock()
    # cursor.fetchall.return_value = accounts
    cursor.fetchall = MagicMock(side_effect=[accounts, restricted_features])
    session = MagicMock()
    session.execute.return_value = cursor
    monkeypatch.setattr(mysql, 'session', lambda: session)


def test_get_workstation_user_by_id():
    """Get a workstation user by its id."""
    current_user, status = fixture_user.create_workstation_user()
    current_user_id = current_user.id

    for user_id_format in ['alw:{}', '{}']:
        user_id = user_id_format.format(current_user_id)
        fetched_user = workstation_user.get_workstation_user_by_id(user_id)
        assert fetched_user
        assert fetched_user.message.id == current_user.id


def test_get_missing_workstation_user():
    """Get a workstation user with an invalid id."""
    fetched_user = workstation_user.get_workstation_user_by_id('alw:9999')
    assert fetched_user.status == 404
    assert not fetched_user.success


def test_get_workstation_user_with_invalid_id():
    """Get a workstation user with an invalid id."""
    with pytest.raises(ValueError):
        workstation_user.get_workstation_user_by_id('alw:invalid')


def test_user_type_for_subaccount():
    """Test user type value for subaccounts."""
    user_id = 982
    subaccount_id = 115433
    current_user = workstation_user.WorkstationUser(
        id=user_id, vendor_id=3356, contact_id=17253, subaccount_id=subaccount_id
    )

    assert current_user.account_id is subaccount_id
    assert current_user.id is user_id
    assert current_user.account_type == AccountTypes.SUBACCOUNT
    assert current_user.user_id == f'alw:{current_user.id}'


def test_user_type_for_identity_id():
    """Test value for orchard_identity_id."""
    user_id = 982
    orchard_identity_id = 'auth0id23123'
    current_user = workstation_user.WorkstationUser(
        id=user_id, vendor_id=3356, contact_id=17253
    )
    current_user.orchard_identity_id = orchard_identity_id

    assert current_user.orchard_identity_id == orchard_identity_id
    assert current_user.id is user_id
    assert current_user.account_type == AccountTypes.VENDOR
    assert current_user.user_id == f'alw:{user_id}'


def test_user_type_for_label():
    """Test user type for labels."""
    user_id = 1082
    label_id = 115433
    current_user = workstation_user.WorkstationUser(
        id=user_id, vendor_id=label_id, contact_id=17253
    )

    assert current_user.account_id is label_id
    assert current_user.id is user_id
    assert current_user.account_type == AccountTypes.VENDOR
    assert not current_user.subaccount_id
    assert current_user.user_id == f'alw:{current_user.id}'


def test_workstaitonuser_set_roles():
    """Test roles set properly for WorkstationUser."""
    current_user = workstation_user.WorkstationUser()

    roles = ['Analytics', 'Accounting']
    current_user.set_roles(roles)
    assert current_user.roles == ['analytics', 'accounting']

    # test against dupping of roles
    current_user.set_roles(roles)
    assert current_user.roles == ['analytics', 'accounting']


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_privileges(monkeypatch, privileges)

    response = workstation_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_privileges(monkeypatch, privileges)

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


def test_get_linked_account_details_for_user(monkeypatch):
    """Test getting linked account details for user."""
    accounts = [
        (
            123,
            123,
            None,
            None,
            'Client Services',
            'Vendor Name',
            'The Company',
            '123',
            'Y',
        )
    ]
    setup_mock_mysql_query(monkeypatch, accounts)

    response = workstation_user.get_linked_account_details('user_id', 'auth0_user_id')

    for position, account in enumerate(response.message):
        assert account.vc_id == accounts[position][0]
        assert account.vendor_id == accounts[position][1]
        assert account.subaccount_id == accounts[position][2]
        assert account.subaccount_name == accounts[position][3]
        assert account.label_identifier == accounts[position][4]
        assert account.vendor_name == accounts[position][5]
        assert account.company == accounts[position][6]
        assert account.auth0_user_id == accounts[position][7]
        assert account.auth0_primary == accounts[position][8]


def test_get_empty_linked_account_details_for_user(monkeypatch):
    """Test getting linked account details for user."""
    accounts = []
    setup_mock_mysql_query(monkeypatch, accounts)

    response = workstation_user.get_linked_account_details('user_id', 'auth0_user_id')
    assert len(response.message) == 0
    assert type(response.message) is 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 = 'alw:1234'
    setup_mock_mysql_query(monkeypatch, roles)
    fetched_roles = workstation_user.get_roles_for_user(user_id)
    assert fetched_roles
    assert fetched_roles.message == expected


def test_get_roles_for_user_restricted_features(monkeypatch):
    """Test feature control for Analytics and Marketing removes roles."""
    roles = [
        (1, 'Administrator'),
        (2, 'Marketing'),
        (3, 'Analytics'),
        (5, 'Accounting'),
        (6, 'Manage Rights'),
    ]
    restricted_features = [
        (user.MARKETING_FEATURE_CONTROL,),
        (user.ANALYTICS_FEATURE_CONTROL,),
    ]
    expected = dict(
        role_ids=[1, 5, 6], role_names=['Administrator', 'Accounting', 'Manage Rights']
    )
    user_id = 'alw:1234'
    setup_mock_mysql_query(monkeypatch, roles, restricted_features)
    fetched_roles = workstation_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 a workstation 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 = 'alw:1234'
    mock_request = MagicMock()
    mock_request.return_value = mock_response
    monkeypatch.setattr(microservices, 'request', mock_request)
    identity_response = workstation_user.get_user_identity(user_id)

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