"""Lambda test module."""

import config
from src import app
import pytest
from freezegun import freeze_time

from unittest.mock import call
from unittest.mock import MagicMock
from unittest.mock import patch
from unittest.mock import Mock

from auth0.authentication import GetToken
from auth0.exceptions import Auth0Error


@pytest.fixture
def event():
    """Fixture that returns lambda event."""
    return {
        'version': '0',
        'id': 'test',
        'detail-type': 'Scheduled Event',
        'source': 'aws.events',
        'account': '103233932089',
        'time': '2020-05-27T15:37:00Z',
        'region': 'us-east-1',
        'resources': [
            'arn:aws:events:us-east-1:test:rule/dev-populate-jwt'
        ],
        'detail': {}
    }


@freeze_time('2025-05-02 12:00:00.000000')
@patch('src.app.call_datadog_with_metric')
def test_handler(event, mocker):
    """Test for lambda handler."""
    token_result = {
        'access_token': 'test_token',
        'expires_in': 36000,
        'token_type': 'Bearer'
    }
    mocker.patch.object(
        GetToken,
        'client_credentials',
        return_value=token_result
    )
    config.secrets_manager_client = MagicMock()
    config.secrets_manager_client.get_secret = MagicMock(
        return_value='client_secret')

    secret_manager_client_mock = Mock()
    secret_manager_client_mock.side_effect = [MagicMock(), MagicMock()]

    result = app.handler(event, None)
    assert result == {'status': 'OK'}
    assert GetToken.client_credentials.called
    expected = [
        call('jwt_token_expiration', '2025-05-02 22:00:00.000000'),
        call('jwt_token', token_result['access_token'])
    ]
    assert (
        config.secrets_manager_client.update_secret.call_args_list == expected
    )


@patch('src.app.capture_exception')
@patch('src.app.call_datadog_with_metric')
@patch('src.app.get_auth0_m2m_creds')
def test_handler_with_exception(
    mock_get_auth0_m2m_creds,
    mock_call_datadog_with_metric,
    mock_capture_exception,
    event,
    mocker
):
    """Test for lambda handler."""
    mock_get_auth0_m2m_creds.return_value = {
        'm2m_client_id': 'test_client_id',
        'm2m_client_secret': 'tet_client_secret'
    }
    token_result = Auth0Error(401, 'die', 'you are dead')
    mocker.patch.object(
        GetToken,
        'client_credentials',
        side_effect=token_result
    )
    with pytest.raises(Exception, match='you are dead'):
        app.handler(event, None)

    mock_capture_exception.assert_called_once()
    assert mock_call_datadog_with_metric.call_count == 2
    expected_calls = [
        call('attempt'),
        call('failure')
    ]
    mock_call_datadog_with_metric.assert_has_calls(expected_calls)


def test_get_auth0_m2m_creds():
    """Test extraction of an auth0 m2m creds."""
    config.secrets_manager_client = MagicMock()
    config.secrets_manager_client.get_secret = MagicMock(
        return_value='client_secret'
    )
    assert app.get_auth0_m2m_creds() == {
        'm2m_client_id': config.AUTH0_M2M_CLIENT_ID,
        'm2m_client_secret': 'client_secret'
    }


@pytest.mark.parametrize(
    'm2m_client_creds, token_result',
    [
        (
            {
                'm2m_client_id': config.AUTH0_M2M_CLIENT_ID,
                'm2m_client_secret': 'client_secret'
            },
            {
                'access_token': 'test_token',
                'expires_in': 36000,
                'token_type': 'Bearer'
            }
        ),
    ]
)
def test_get_jwt_token(mocker, m2m_client_creds, token_result):
    """Test extraction of get_jwt_token."""
    mocker.patch.object(
        GetToken,
        'client_credentials',
        return_value=token_result
    )
    app.get_jwt_token(m2m_client_creds)
    assert GetToken.client_credentials.called


@freeze_time('2025-05-02 12:00:00.00000')
def test_populate_jwt_to_secrets():
    """Test populate_jwt_to_secrets."""
    access_token = 'test_token'
    expires_in = 36000
    token = {
        'access_token': access_token,
        'expires_in': expires_in,
        'token_type': 'Bearer'
    }
    secret_manager_client_mock = Mock()
    secret_manager_client_mock.side_effect = [MagicMock(), MagicMock()]
    config.secrets_manager_client = MagicMock()
    config.secrets_manager_client.update_secret = MagicMock(
        return_value=secret_manager_client_mock
    )

    expected = [
        call('jwt_token_expiration', '2025-05-02 22:00:00.000000'),
        call('jwt_token', access_token)
    ]
    app.populate_jwt_to_secrets(token)
    assert (
        config.secrets_manager_client.update_secret.call_args_list == expected
    )


@patch.object(app.config, 'ENVIRONMENT', new='test')
@patch('src.app.util.datadog_connection')
@patch('src.app.time.time')
def test_call_datadog_with_metric(
        mock_time,
        mock_datadog_conn):
    """Test call_datadog_with_metric function."""
    mock_time.return_value = 1549652481

    sample_metric = 'expected_metric'
    config.secrets_manager_client.get_cred = MagicMock(
        return_value='DATADOG_API_KEY')
    app.call_datadog_with_metric(sample_metric)
    mock_datadog_conn.return_value.__enter__.\
        return_value.Metric.send.assert_called_with(
            [
                {
                    'metric': f'lambda-jwt-refresh.{sample_metric}',
                    'type': 'count',
                    'interval': 60,
                    'points': (1549652481, 1),
                    'tags': [
                        'environment:test'
                    ]
                }
            ])