"""Test user logic."""

import random
from unittest.mock import MagicMock

import pytest

from grass.consts.user import AccountTypes
from grass.logic import user
from grass.models import oa_user

from tests.unit.fixtures import fixture_user

ALW_USER = 'alw:{}'.format


@pytest.fixture(params=['label', 'subaccount'])
def simple_workstation_user(request):
    """Create a simple workstation user.

    Args:
        request (object): fixture request object.

    Returns:
        Response: the workstation user.
    """
    is_subaccount = request.param == 'subaccount'
    response = fixture_user.create_workstation_user(is_subaccount=is_subaccount)
    return response


def test_create_workstation_user(simple_workstation_user):
    """Test the creation of a user.

    This test ensures the fixtures behaves as expected (the fixture can
    create two types of account, label and subaccount).
    """
    user, status = simple_workstation_user
    assert user
    assert status == 200


def test_get_workstation_user_by_id(simple_workstation_user):
    """Get a user by its id."""
    current_user, status = simple_workstation_user
    resp, status = user.get_user_by_id(ALW_USER(current_user.id))
    assert resp
    assert status == 200


def test_get_non_existing_workstation_user_by_id():
    """Get a user by its id."""
    resp, status = user.get_user_by_id(ALW_USER(int(100 + 400 * random.random())))
    assert 'errors' in resp
    assert status == 404


def test_get_user_by_id_with_invalid_namespace():
    """Get a user by its id."""
    with pytest.raises(ValueError):
        resp, status = user.get_user_by_id('random:987634')


def test_workstation_user_account_type(simple_workstation_user):
    """Test the account type of a user."""
    resp, status = simple_workstation_user
    assert status == 200
    assert user.is_user_vendor(resp) != user.is_user_subaccount(resp)

    if resp.account_type == AccountTypes.SUBACCOUNT:
        assert user.is_user_subaccount(resp)
    else:
        assert user.is_user_vendor(resp)


@pytest.mark.parametrize('user_id', [('alw:user_id'), ('oa:user_id')])
def test_is_allowed_for_any_resources_on_empty_list(user_id):
    """Check if a user can access resources when no resources are passed."""
    assert user.is_allowed_for_any_resources(user_id, [])


@pytest.mark.parametrize('user_id', [('alw:user_id'), ('oa:user_id')])
def test_is_allowed_for_any_resources(monkeypatch, user_id):
    """Check if a user can access resources when no resources are passed."""
    spy = MagicMock()

    def is_allowed(user_id, resource):
        spy()
        return resource == 'stats2'

    monkeypatch.setattr(user, 'is_allowed_for_resource', is_allowed)
    assert user.is_allowed_for_any_resources(user_id, ['stats', 'stats2', 'stats3'])
    assert spy.call_count == 2


def test_is_allowed_for_resource_on_invalid_values(monkeypatch):
    """Check if a user is allowed for a resource."""
    monkeypatch.setattr(user, 'is_allowed_for_resource', MagicMock(return_value=[]))
    assert not user.is_allowed_for_resource('user_id', 'resource')


@pytest.mark.parametrize('user_id', [('alw:user_id'), ('oa:user_id')])
def test_is_allowed_for_resource(monkeypatch, user_id):
    """Check if a namespaced user is allowed for a resource."""
    monkeypatch.setattr(
        user, 'is_allowed_for_resource', MagicMock(return_value=['list', 'list'])
    )

    assert user.is_allowed_for_resource(user_id, 'resource')


def test_if_non_namespaced_is_allowed_for_resource(monkeypatch):
    """Test if a non alw/oa user is allowed for resources."""
    assert not user.is_allowed_for_resource('user_id', 'resource')


def test_get_oa_user_by_id(monkeypatch):
    """Get a oa user by its id."""
    monkeypatch.setattr(
        oa_user, 'get_oa_user_by_id', MagicMock(wraps=oa_user.get_oa_user_by_id)
    )

    current_user = fixture_user.create_oa_user().message
    resp, status = user.get_user_by_id(current_user.user_id)
    assert resp
    assert status == 200
    assert oa_user.get_oa_user_by_id.called
    oa_user.get_oa_user_by_id.assert_called_with(current_user.user_id)


def test_get_inactive_oa_user_by_id(monkeypatch):
    """Get a oa user by its id."""
    current_user = fixture_user.create_oa_user(is_active=False).message
    resp, status = user.get_user_by_id(current_user.user_id)
    assert resp.get('errors') is oa_user.DEACTIVATED_USER_RESPONSE.errors
    assert status == oa_user.DEACTIVATED_USER_RESPONSE.status


@pytest.mark.parametrize(
    'user_id, groups, expected',
    [
        ('alw:user_id', [], False),
        ('alw:user_id', ['alw'], True),
        ('alw:user_id', ['oa', 'alw'], True),
        ('alw:user_id', ['alw', 'oa'], True),
        ('alw:user_id', ['oa'], False),
    ],
)
def test_is_group_member(monkeypatch, user_id, groups, expected):
    """Test if a user is a group member."""
    actual = user.is_group_member(user_id, groups)
    assert actual == expected