"""Test session logic."""

from unittest.mock import MagicMock

import pytest

from grass import api
from grass.connectors.redis import redis_client
from grass.logic import auth, session
from grass.models import oa_user, workstation_user
from grass.models import session as model_session
from grass.utils import headers, response


@pytest.mark.parametrize(
    ('request_user_id', 'roles_call_count', 'identity_call_count'),
    [('alw:user_id', 1, 1), ('oa:user_id', 1, 1), ('dummy', 0, 0)],
)
def test_create_token(
    monkeypatch, request_user_id, roles_call_count, identity_call_count
):
    """Test the creation of the token."""
    actual_roles = dict(
        role_ids=[1, 2, 3, 5, 6],
        role_names=[
            'Administrator',
            'Marketing',
            'Analytics',
            'Accounting',
            'Manage Rights',
        ],
    )

    actual_identity = {'id': 'UUID', 'auth0_user_id': 'auth0id'}

    def create(
        client_id,
        user_id,
        token_id,
        roles=[],
        roles_by_name=[],
        identity_uuid=None,
        auth0_user_id=None,
    ):
        assert client_id
        assert user_id == request_user_id
        assert token_id
        if user_id.startswith('alw'):
            assert roles == actual_roles['role_ids']
            assert roles_by_name == actual_roles['role_names']
            assert identity_uuid
            assert auth0_user_id

        if user_id.startswith('oa'):
            assert roles == actual_roles['role_ids']
            assert roles_by_name == actual_roles['role_names']
            assert identity_uuid
            assert auth0_user_id

    monkeypatch.setattr(model_session, 'create', create)

    if request_user_id.startswith('alw'):
        user_model = workstation_user
    elif request_user_id.startswith('oa'):
        user_model = oa_user

    if request_user_id != 'dummy':
        monkeypatch.setattr(
            user_model,
            'get_roles_for_user',
            MagicMock(return_value=response.Response(actual_roles)),
        )
        monkeypatch.setattr(
            user_model,
            'get_user_identity',
            MagicMock(return_value=response.Response(actual_identity)),
        )

    session.create_token('client_id', request_user_id)

    if request_user_id != 'dummy':
        assert user_model.get_roles_for_user.call_count == roles_call_count
        assert user_model.get_user_identity.call_count == identity_call_count


def test_create_token_no_identity(monkeypatch):
    request_user_id = 'alw:user_id'
    actual_roles = dict(
        role_ids=[1, 2, 3, 5, 6],
        role_names=[
            'Administrator',
            'Marketing',
            'Analytics',
            'Accounting',
            'Manage Rights',
        ],
    )

    def create(
        client_id,
        user_id,
        token_id,
        roles=[],
        roles_by_name=[],
        identity_uuid=None,
        auth0_user_id=None,
    ):
        assert client_id
        assert user_id == request_user_id
        assert token_id
        if user_id.startswith('alw'):
            assert roles == actual_roles['role_ids']
            assert roles_by_name == actual_roles['role_names']
            assert not identity_uuid
            assert not auth0_user_id

    monkeypatch.setattr(model_session, 'create', create)
    monkeypatch.setattr(
        workstation_user,
        'get_roles_for_user',
        MagicMock(return_value=response.Response(actual_roles)),
    )
    monkeypatch.setattr(
        workstation_user,
        'get_user_identity',
        MagicMock(return_value=response.create_error_response('Not found', 404)),
    )

    session.create_token('client_id', request_user_id)
    assert workstation_user.get_user_identity.call_count == 1


def test_create_random_token():
    """Test the creation of random token."""
    token1 = session.create_random_token()
    token2 = session.create_random_token()

    assert token1 != token2


def test_get_token():
    """Test the token validation."""
    data, status = session.create_token(10, '50')
    token = data.get('token')

    data, status = session.get_token(token)
    assert status == 200
    assert data.get('user_id') == '50'
    assert data.get('client_id') == '10'


def test_get_token_not_in_redis(monkeypatch):
    """Test the validation of a token that is not in redis."""
    monkeypatch.setattr(redis_client, 'set', MagicMock(return_value=True))

    data, status = session.create_token(10, '50')
    data, status = session.get_token(data.get('token'))

    assert status == 404
    assert 'errors' in data


def test_store_auth_token_on_logout(monkeypatch):
    """Test store auth token."""
    token = 'Bearer token'
    payload = {
        'iss': 'https://dummy-auth0-url.com/',
        'sub': 'sometoken@clients',
        'aud': 'https://dummy-ows.url.io',
        'iat': 123,
        'exp': 123,
        'azp': 'sometoken',
        'gty': 'client-credentials',
    }
    expire_time = 123
    ttl = 134
    validate_result = (None, 200, payload)
    message = 'Token cached'
    monkeypatch.setattr(
        headers, 'extract_authorization_token', MagicMock(return_value=True)
    )
    monkeypatch.setattr(
        auth, 'validate_auth0_token', MagicMock(return_value=validate_result)
    )
    monkeypatch.setattr(session, 'calculate_time_to_live', MagicMock(return_value=ttl))
    monkeypatch.setattr(
        model_session, 'store_auth_on_logout', MagicMock(return_value=True)
    )
    valid_token = headers.extract_authorization_token(token)
    data = session.store_auth_token_on_logout(valid_token)
    auth.validate_auth0_token.assert_called_with(valid_token)
    session.calculate_time_to_live.assert_called_with(expire_time)
    model_session.store_auth_on_logout.assert_called_with(valid_token, ttl)
    assert data == message


def test_does_not_store_auth_token_on_logout(monkeypatch):
    """Test that doesn't store auth token."""
    token = 'Bearer invalidtoken'
    log_message = 'Unable to parse authentication token'
    message = 'Token not cached'
    status = 401
    validate_result = (log_message, status, {})
    monkeypatch.setattr(
        headers, 'extract_authorization_token', MagicMock(return_value=True)
    )
    monkeypatch.setattr(
        auth, 'validate_auth0_token', MagicMock(return_value=validate_result)
    )
    monkeypatch.setattr(
        model_session, 'store_auth_on_logout', MagicMock(return_value=True)
    )
    monkeypatch.setattr(api.logger, 'info', MagicMock())
    data = session.store_auth_token_on_logout(token)
    api.logger.info.assert_called_with(f'{status}:{log_message}')
    assert data == message