"""TaxWithholdingOverride schema tests."""

import datetime
from decimal import Decimal

from marshmallow import ValidationError
import pytest

from payee.schemas.tax_withholding_override import (
    DataloaderEntrySchema,
    TaxWithholdingOverrideCreateSchema,
    TaxWithholdingOverrideDataloaderOutputSchema,
    TaxWithholdingOverrideDataloaderSchema,
    TaxWithholdingOverrideSchema,
)


@pytest.mark.parametrize(
    'test_input,expected_output',
    [
        ([], {'account_payee_ids': []}),
        (
            [1, 2, 5, 100, 999],
            {'account_payee_ids': [1, 2, 5, 100, 999]},
        ),
    ],
)
def test_tax_withholding_override_dataloader_schema_valid_inputs(
    test_input, expected_output
):
    """Test that valid inputs are processed correctly."""
    schema = TaxWithholdingOverrideDataloaderSchema()
    result = schema.load(test_input)
    assert result == expected_output


@pytest.mark.parametrize(
    'invalid_input',
    [
        (None),  # null input
        ([1, -5, 3]),  # negative integers
        ([1, 'invalid', 3]),  # string values
        ([1, 2.5, 3]),  # float values
        ([1, '6666', 3]),  # string numbers
        ([1, None, 3]),  # None in list
        ([1, 1, 1]),  # Duplicate in list
        ({}),  # wrong type (dict instead of list)
        ('not_a_list'),  # string instead of list
    ],
)
def test_tax_withholding_override_dataloader_schema_invalid_inputs(invalid_input):
    """Test that invalid inputs raise ValidationError."""
    schema = TaxWithholdingOverrideDataloaderSchema()

    with pytest.raises(ValidationError) as exc_info:
        schema.load(invalid_input)

    assert 'account_payee_ids' in str(exc_info.value)


@pytest.mark.parametrize(
    'test_input,expected_output',
    [
        (
            {
                'rate_override': 15.25,
                'certificate_expiration_date': '2025-09-27',
                'message': 'Override reason',
            },
            {
                'rate_override': Decimal('15.25'),
                'certificate_expiration_date': datetime.date(2025, 9, 27),
                'message': 'Override reason',
            },
        ),
        ({'rate_override': 15.25}, {'rate_override': Decimal('15.25')}),
    ],
)
def test_tax_withholding_override_create_schema_valid_inputs(
    test_input, expected_output
):
    """Test that valid inputs are processed correctly."""
    schema = TaxWithholdingOverrideCreateSchema()
    result = schema.load(test_input)
    assert result == expected_output


@pytest.mark.parametrize(
    'invalid_input,error_keyword',
    [
        ({}, '_schema'),
        ({'rate_override': -10}, 'rate_override'),
        ({'rate_override': 150}, 'rate_override'),
        ({'rate_override': 'not_a_number'}, 'rate_override'),
        ({'rate_override': None}, 'rate_override'),
        ({'certificate_expiration_date': '2025-13-32'}, 'certificate_expiration_date'),
        ({'certificate_expiration_date': 20251231}, 'certificate_expiration_date'),
        ({'message': ''}, 'message'),
        ({'message': 123}, 'message'),
        (
            {
                'rate_override': '150.0',  # above max
                'certificate_expiration_date': 'invalid-date',
                'message': '',
            },
            'rate_override',
        ),
    ],
)
def test_tax_withholding_override_create_schema_invalid_inputs(
    invalid_input, error_keyword
):
    """Test that invalid inputs raise ValidationError."""
    schema = TaxWithholdingOverrideCreateSchema()

    with pytest.raises(ValidationError) as exc_info:
        schema.load(invalid_input)

    error_message = str(exc_info.value)
    assert error_keyword in error_message


test_data = {
    'tax_withholding_override_id': 123,
    'account_payee_id': 456,
    'rate_override': 15.25,
    'certificate_expiration_date': '2025-09-25',
    'message': 'test message',
    'created_by': 'test_user',
    'created_at': '2025-09-25T10:00:00',
    'last_modified_by': 'test_user',
    'last_modified': '2025-09-25T10:00:00',
}


def test_tax_withholding_override_schema():
    """Test tax withholding override schema."""
    assert TaxWithholdingOverrideSchema().validate(test_data) == {}


def test_dataloader_entry_schema():
    """Test dataloader entry schema with data."""
    params = {'data': test_data}
    params_null = {'data': None}
    assert DataloaderEntrySchema().validate(params) == {}
    assert DataloaderEntrySchema().validate(params_null) == {}


def test_tax_withholding_override_dataloader_output_schema():
    """Test tax withholding override dataloader output schema."""
    params = {
        'items': [
            {'data': test_data},
            {'data': None},
        ]
    }
    params_empty = {'items': []}
    assert TaxWithholdingOverrideDataloaderOutputSchema().validate(params) == {}
    assert TaxWithholdingOverrideDataloaderOutputSchema().validate(params_empty) == {}