"""Tests for logging utilities."""

from auditlogger.record_event import RecordEvent
import pytest

from collaborator.utils import logging


def test_bulk_log_events(mocker, mock_user):
    """Test bulk logging of events."""
    event_type = logging.LOG_EVENT_CREATE
    entity_type = "test"
    data = [
        {"id": 123, "original": {"name": "Yes"}, "updated": {"name": "No"}},
        {"id": 234, "original": {"name": "What"}, "updated": {"name": "Why"}},
        {"id": 345, "original": {"name": "In"}, "updated": {"name": "Out"}},
    ]

    logger_mock = mocker.MagicMock()

    logging.bulk_log_events(
        event_type, entity_type, data, mock_user, logger=logger_mock
    )

    assert logger_mock.log.called

    call_arg = logger_mock.log.call_args[0][0]
    assert isinstance(call_arg, list)
    assert len(call_arg) == len(data)

    for i in range(len(call_arg)):
        event_data = call_arg[i].get_event_data()
        assert event_data["event_name"] == event_type
        assert event_data["target_type"] == entity_type
        assert event_data["target_id"] == str(data[i]["id"])
        assert event_data["changeset"] == {
            "original": data[i]["original"],
            "updated": data[i]["updated"],
        }
        assert event_data["user_type"] == mock_user.type
        assert event_data["user_id"] == str(mock_user.id)
        assert event_data["timestamp"]  # just check if it exists


@pytest.mark.parametrize(
    (
        "example_event_type",
        "example_type",
        "example_id",
        "example_original_data",
        "example_updated_data",
    ),
    [
        ("create", "test", 1234, None, {"id": 1234}),
        (
            logging.LOG_EVENT_UPDATE,
            "collaborator",
            24601,
            {"id": 24601, "email": "test@example.org"},
            {"id": 24601, "email": "whatever@example.org"},
        ),
        (
            logging.LOG_EVENT_DELETE,
            "collaborator",
            24601,
            {"id": 24601, "email": "whatever@example.org"},
            None,
        ),
    ],
)
def test_log_create_event(
    example_event_type,
    example_type,
    example_id,
    example_original_data,
    example_updated_data,
    mocker,
    mock_user,
):
    """Test logging an event."""
    logger_mock = mocker.MagicMock()

    logging.log_event(
        example_event_type,
        example_type,
        example_id,
        example_original_data,
        example_updated_data,
        mock_user,
        logger=logger_mock,
    )

    assert logger_mock.log.called
    assert isinstance(logger_mock.log.call_args[0][0], RecordEvent)

    event_data = logger_mock.log.call_args[0][0].get_event_data()
    assert event_data["event_name"] == example_event_type
    assert event_data["target_type"] == example_type
    assert event_data["target_id"] == str(example_id)
    assert event_data["changeset"] == {
        "original": example_original_data,
        "updated": example_updated_data,
    }
    assert event_data["user_type"] == mock_user.type
    assert event_data["user_id"] == str(mock_user.id)
    assert event_data["timestamp"]  # just check if it exists


def test_log_create_event_no_user(mocker):
    """Test logging an event with no user."""
    logger_mock = mocker.MagicMock()

    logging.log_event(
        logging.LOG_EVENT_CREATE,
        "test",
        1,
        None,
        {"test": "yes"},
        None,
        logger=logger_mock,
    )

    assert logger_mock.log.called
    assert isinstance(logger_mock.log.call_args[0][0], RecordEvent)

    event_data = logger_mock.log.call_args[0][0].get_event_data()
    assert event_data["event_name"] == logging.LOG_EVENT_CREATE
    assert event_data["target_type"] == "test"
    assert event_data["target_id"] == str(1)
    assert event_data["changeset"] == {"original": None, "updated": {"test": "yes"}}
    assert not event_data["user_type"]
    assert not event_data["user_id"]
    assert event_data["timestamp"]  # just check if it exists