"""Test Abacus State schema."""

import pytest
from abacus_common_logic.utils import dates
from marshmallow import ValidationError

from abacus_state.schemas.abacus_state import (
    AbacusStateBulkPutSchema,
    AbacusStateBulkQueryParamsSchema,
    AbacusStateBulkQuerySchema,
    AbacusStateDetailSchema,
    AbacusStatePostSchema,
    AbacusStatePutSchema,
)

from tests.utils.factories import AbacusStateFactory


def test_abacus_state_detail_schema():
    """Test Abacus State detail schema."""
    abacus_state = AbacusStateFactory.create()
    dumped = AbacusStateDetailSchema().dump(abacus_state)

    assert dumped == {
        'abacus_state_id': abacus_state.abacus_state_id,
        'action_name': abacus_state.action_name,
        'parent_table_id': abacus_state.parent_table_id,
        'parent_table_name': abacus_state.parent_table_name,
        'action_status': abacus_state.action_status,
        'message': None,
        'created_by': abacus_state.created_by,
        'created_at': dates.safe_format_datetime(abacus_state.created_at),
        'last_modified_by': abacus_state.last_modified_by,
        'last_modified': dates.safe_format_datetime(abacus_state.last_modified),
    }


@pytest.mark.db('mysql')
def test_abacus_state_post_schema():
    """Test Abacus State post schema."""
    abacus_state = AbacusStateFactory.create()
    dumped = AbacusStatePostSchema().dump(abacus_state)

    assert dumped == {
        'action_name': abacus_state.action_name,
        'parent_table_name': abacus_state.parent_table_name,
        'parent_table_id': abacus_state.parent_table_id,
    }


def test_abacus_state_put_schema():
    """Test Abacus State put schema."""
    mock_put_request = {'action_status': 'running', 'message': 'testing'}
    loaded = AbacusStatePutSchema().load(mock_put_request)

    assert loaded == {
        'action_status': mock_put_request['action_status'],
        'message': mock_put_request['message'],
    }

    mock_put_request = {'action_status': 'running', 'message': ''}
    loaded = AbacusStatePutSchema().load(mock_put_request)

    assert loaded == {
        'action_status': mock_put_request['action_status'],
        'message': None,
    }

    mock_put_request = {'action_status': 'running', 'message': None}
    loaded = AbacusStatePutSchema().load(mock_put_request)

    assert loaded == {
        'action_status': mock_put_request['action_status'],
        'message': None,
    }


def test_abacus_state_bulk_put_schema():
    """Test Abacus State bulk put schema."""
    mock_put_request = {
        'action_status': 'running',
        'message': 'testing',
        'parent_table_id': 1,
    }
    dumped = AbacusStateBulkPutSchema().dump(mock_put_request)

    assert dumped == {
        'action_status': mock_put_request['action_status'],
        'message': mock_put_request['message'],
        'parent_table_id': mock_put_request['parent_table_id'],
    }


def test_abacus_state_bulk_query_schema_with_duplicates():
    """Test that AbacusStateBulkQuerySchema raises error for duplicate parent_table_ids."""
    mock_query_request = {
        'parent_table_name': 'accounting_period',
        'parent_table_ids': [1, 2, 3, 2, 4],
    }

    with pytest.raises(ValidationError) as exc_info:
        AbacusStateBulkQuerySchema().load(mock_query_request)

    assert 'parent_table_ids' in exc_info.value.messages
    assert 'must not contain duplicate values' in str(
        exc_info.value.messages['parent_table_ids']
    )


def test_abacus_state_bulk_query_schema_without_duplicates():
    """Test that AbacusStateBulkQuerySchema loads successfully without duplicates."""
    mock_query_request = {
        'parent_table_name': 'accounting_period',
        'parent_table_ids': [1, 2, 3, 4],
        'action_name': 'deliver_sales_files',
    }

    loaded = AbacusStateBulkQuerySchema().load(mock_query_request)

    assert loaded == {
        'parent_table_name': 'accounting_period',
        'parent_table_ids': [1, 2, 3, 4],
        'action_name': 'deliver_sales_files',
    }


def test_abacus_state_bulk_query_schema_empty_parent_table_ids():
    """Test that AbacusStateBulkQuerySchema handles empty parent_table_ids."""
    mock_query_request = {
        'parent_table_name': 'accounting_period',
        'parent_table_ids': [],
    }

    loaded = AbacusStateBulkQuerySchema().load(mock_query_request)

    assert loaded['parent_table_ids'] == []


def test_abacus_state_bulk_query_schema_single_parent_table_id():
    """Test that AbacusStateBulkQuerySchema handles single parent_table_id."""
    mock_query_request = {
        'parent_table_name': 'accounting_period',
        'parent_table_ids': [1],
    }

    loaded = AbacusStateBulkQuerySchema().load(mock_query_request)

    assert loaded['parent_table_ids'] == [1]


def test_abacus_state_bulk_query_params_schema_with_defaults():
    """Test that AbacusStateBulkQueryParamsSchema applies default values."""
    mock_params = {}

    loaded = AbacusStateBulkQueryParamsSchema().load(mock_params)

    assert loaded['limit'] == 100
    assert loaded['offset'] == 0


def test_abacus_state_bulk_query_params_schema_with_custom_values():
    """Test that AbacusStateBulkQueryParamsSchema loads custom values."""
    mock_params = {
        'limit': 50,
        'offset': 10,
    }

    loaded = AbacusStateBulkQueryParamsSchema().load(mock_params)

    assert loaded['limit'] == 50
    assert loaded['offset'] == 10


def test_abacus_state_bulk_query_params_schema_limit_max_validation():
    """Test that AbacusStateBulkQueryParamsSchema validates max limit."""
    mock_params = {
        'limit': 5000,
    }

    with pytest.raises(ValidationError) as exc_info:
        AbacusStateBulkQueryParamsSchema().load(mock_params)

    assert 'limit' in exc_info.value.messages


def test_abacus_state_bulk_query_params_schema_limit_negative_validation():
    """Test that AbacusStateBulkQueryParamsSchema validates negative limit."""
    mock_params = {
        'limit': -1,
    }

    with pytest.raises(ValidationError) as exc_info:
        AbacusStateBulkQueryParamsSchema().load(mock_params)

    assert 'limit' in exc_info.value.messages


def test_abacus_state_bulk_query_params_schema_offset_negative_validation():
    """Test that AbacusStateBulkQueryParamsSchema validates negative offset."""
    mock_params = {
        'offset': -10,
    }

    with pytest.raises(ValidationError) as exc_info:
        AbacusStateBulkQueryParamsSchema().load(mock_params)

    assert 'offset' in exc_info.value.messages


def test_abacus_state_bulk_query_params_schema_limit_zero_validation():
    """Test that AbacusStateBulkQueryParamsSchema accepts limit=0."""
    mock_params = {
        'limit': 0,
    }

    loaded = AbacusStateBulkQueryParamsSchema().load(mock_params)

    assert loaded['limit'] == 0
    assert loaded['offset'] == 0


def test_abacus_state_bulk_query_params_schema_offset_max_validation():
    """Test that AbacusStateBulkQueryParamsSchema validates max offset."""
    mock_params = {
        'offset': 999999999999999999999,
    }

    with pytest.raises(ValidationError) as exc_info:
        AbacusStateBulkQueryParamsSchema().load(mock_params)

    assert 'offset' in exc_info.value.messages