"""Tests for Redis Serializer methods."""

from typing import Any, TypeVar

import pytest

from pdp.connectors.redis_client import (
    JSONSerializer,
    NullSerializer,
    PPCacheItemSerializer,
    PydanticSchemaSerializer,
    TypeAdapterSerializer,
)
from pdp.fastapi.schemas.identity import Role, RoleListValidator

T = TypeVar("T")


@pytest.mark.parametrize(
    "description,item,expected_return_value,serializer,expect_error",
    [
        (
            "JSONSerializer.dump should succeed for Python dictionaries",
            {"key": "value"},
            '{"key": "value"}',
            JSONSerializer(),
            False,
        ),
        (
            "JSONSerializer.dump should return None if passed None",
            None,
            None,
            JSONSerializer(),
            False,
        ),
        (
            "JSONSerializer.dump raises an error for a Pydantic model",
            Role(role="test"),
            None,
            JSONSerializer(),
            True,
        ),
        (
            "PydanticSchemaSerializer.dump should succeed for BaseModel schema",
            Role(role="test"),
            '{"role":"test"}',
            PydanticSchemaSerializer(Role),
            False,
        ),
        (
            "PydanticSchemaSerializer.dump returns None if passed None",
            None,
            None,
            PydanticSchemaSerializer(Role),
            False,
        ),
        (
            "PydanticSchemaSerializer.dump raises an error for an invalid payload for BaseModel",  # noqa: E501
            {"test": "data"},
            None,
            PydanticSchemaSerializer(Role),
            True,
        ),
        (
            "TypeAdapterSerializer.dump return succeed for a TypeAdapter[T]",
            RoleListValidator.validate_python([{"role": "zookeeper"}]),
            b'[{"role":"zookeeper"}]',
            TypeAdapterSerializer(RoleListValidator),
            False,
        ),
        (
            "TypeAdapterSerializer.dump returns None if passed None",
            None,
            None,
            TypeAdapterSerializer(RoleListValidator),
            False,
        ),
        (
            "TypeAdapterSerializer.dump raises an error for invalid payload for TypeAdapter.",  # noqa: E501
            Role(role="test"),
            None,
            TypeAdapterSerializer(RoleListValidator),
            True,
        ),
        (
            "TypeAdapterSerializer.dump does not raise an error when json_validation_enabled=False ",  # noqa: E501
            Role(role="test"),
            b'{"role":"test"}',
            TypeAdapterSerializer(RoleListValidator, json_validation_enabled=False),
            False,
        ),
    ],
)
def test_serializer_dump(
    description: str,
    item: Any,
    expected_return_value: Any,
    serializer: PPCacheItemSerializer,
    expect_error: bool,
) -> None:
    """Test the JSONSerializer dump method."""
    if expect_error:
        with pytest.raises(Exception):
            serializer.dump(item)
    else:
        result = serializer.dump(item)
        assert result == expected_return_value, description


@pytest.mark.parametrize(
    "description,item,expected_return_value,serializer,expect_error",
    [
        (
            "JSONSerializer.load should succeed for Python dictionaries",
            '{"key": "value"}',
            {"key": "value"},
            JSONSerializer(),
            False,
        ),
        (
            "JSONSerializer.load should return empty dict if passed None",
            None,
            None,
            JSONSerializer(),
            False,
        ),
        (
            "JSONSerializer.load should raise an error for invalid JSON.",
            "None",
            None,
            JSONSerializer(),
            True,
        ),
        (
            "PydanticSchemaSerializer.load should succeed for Python dictionaries",
            '{"role":"test"}',
            Role(role="test"),
            PydanticSchemaSerializer(Role),
            False,
        ),
        (
            "PydanticSchemaSerializer.load should return empty dict if passed None",
            None,
            None,
            PydanticSchemaSerializer(Role),
            False,
        ),
        (
            "PydanticSchemaSerializer.load should raise an error for invalid JSON.",
            "None",
            None,
            PydanticSchemaSerializer(Role),
            True,
        ),
        (
            "TypeAdapterSerializer.load should succeed for Python dictionaries",
            b'[{"role":"zookeeper"}]',
            RoleListValidator.validate_python([{"role": "zookeeper"}]),
            TypeAdapterSerializer(RoleListValidator),
            False,
        ),
        (
            "TypeAdapterSerializer.load should return empty dict if passed None",
            None,
            None,
            TypeAdapterSerializer(RoleListValidator),
            False,
        ),
        (
            "TypeAdapterSerializer.load should raise an error for invalid JSON.",
            "None",
            None,
            TypeAdapterSerializer(RoleListValidator),
            True,
        ),
        (
            "NullSerializer.load should handle strings",
            "just a string",
            "just a string",
            NullSerializer(),
            False,
        ),
        (
            "NullSerializer.load should handle bytestrings",
            b"just a string",
            "just a string",
            NullSerializer(),
            False,
        ),
        (
            "NullSerializer.load should not decode JSON",
            b'[{"role":"zookeeper"}]',
            '[{"role":"zookeeper"}]',
            NullSerializer(),
            False,
        ),
    ],
)
def test_serializer_load(
    description: str,
    item: Any,
    expected_return_value: Any,
    serializer: PPCacheItemSerializer,
    expect_error: bool,
) -> None:
    """Test the JSONSerializer load method."""
    if expect_error:
        with pytest.raises(Exception):
            serializer.load(item)
    else:
        result = serializer.load(item)
        assert result == expected_return_value, description