"""Test the model validators."""

from unittest.mock import MagicMock
import pytest

from marketing.models import validators


def test_casting_values():
    """Test casting values."""
    assert validators.cast('10', int) == 10
    assert validators.cast('x10', int, default_value=50) == 50
    assert validators.cast(20, str, default_value='hello') == '20'

    basetype = MagicMock()
    validators.cast(10, basetype)
    basetype.assert_called_with(10)


def test_validate_invalid_data(sample_draft_validator):
    """Test validation when data is missing."""
    required_fields = ['entity', 'entity_id']
    data = {'entity': 'release'}
    response = validators.validate(
        sample_draft_validator, data, required_fields)

    assert not response
    assert response.errors.get('message').get('entity_id')
    assert not response.errors.get('message').get('entity')


@pytest.mark.parametrize('basetype, value, out', [
    ('number', '19884', 19884),
    ('number', '198.84', 198.84),
    ('string', 10, '10')
])
def test_autocasting(sample_draft_validator, basetype, value, out):
    """Test autocasting."""
    assert validators.autocast(value, basetype) == out


@pytest.mark.parametrize('basetype, value, out', [
    ('string', '\n\t\nRandom Value\n   ', 'Random Value'),
    ('string', '  Random   Value', 'Random   Value')
])
def test_autocasting_with_strip(sample_draft_validator, basetype, value, out):
    """Test autocasting with strip enabled."""
    assert validators.autocast(value, basetype, strip=True) == out


@pytest.mark.parametrize('basetype, value', [
    ('string', '\n\t\nRandom Value\n   '),
    ('string', '  Random   Value')
])
def test_autocasting_without_strip(sample_draft_validator, basetype, value):
    """Test autocasting with strip disabled."""
    assert validators.autocast(value, basetype, strip=False) == value


def test_autocast_with_unkwnown_basetype():
    """Test autocasting with an unknown basetype."""
    with pytest.raises(Exception, match='basetype'):
        validators.autocast(10, 'basetype', strip=False)


def test_plucking_values(sample_draft_validator):
    """Test plucking values."""
    data = {'entity_id': '1', 'entity': 'release', 'unknown': 'random'}
    values = validators.pluck_values(
        sample_draft_validator.schema['properties'],
        data)
    assert values.get('entity_id') == 1
    assert values.get('entity') == 'release'
    assert not values.get('unknownd')


def test_plucking_excluded_fields(sample_draft_validator):
    """Test plucking excluded values."""
    data = {'entity_id': '1', 'entity': 'release'}
    values = validators.pluck_values(
        sample_draft_validator.schema['properties'],
        data, excluded_fields=['entity_id'])
    assert not values.get('entity_id')
    assert values.get('entity') == 'release'


def test_plucking_immutability(sample_draft_validator):
    """Test plucking is an immutable operation (returns a new dict)."""
    data = {}
    values = validators.pluck_values({}, data)
    assert data is not values


@pytest.mark.parametrize('data', [{}, None])
def test_validate_with_no_data(sample_draft_validator, data):
    """Test validation when no data is provided."""
    required_fields = ['entity', 'entity_id']
    response = validators.validate(
        sample_draft_validator, data, required_fields)

    assert not response
    assert response.errors.get('message').get('entity_id')
    assert response.errors.get('message').get('entity')


def test_validate(sample_draft_validator):
    """Test validation success scenario."""
    required_fields = ['entity', 'entity_id']
    data = {'entity': 'release', 'entity_id': 19884}
    response = validators.validate(
        sample_draft_validator, data, required_fields)

    assert response
    assert response.message == data


def test_validate_with_autocast(sample_draft_validator, monkeypatch):
    """Test validation with autocast."""
    monkeypatch.setattr(
        validators, 'autocast', MagicMock(wraps=validators.autocast))
    required_fields = ['entity', 'entity_id']
    data = {'entity': 'release', 'entity_id': '19884'}
    expected = {'entity': 'release', 'entity_id': 19884}
    response = validators.validate(
        sample_draft_validator, data, required_fields, cast=True)

    assert response
    assert response.message == expected
    assert validators.autocast.called


def test_extend_validator_without_required_field(sample_draft_validator):
    """Test extending a validator without providing required fields."""
    new_validator = validators.extend_validator(sample_draft_validator)
    assert new_validator is sample_draft_validator
    assert sample_draft_validator.schema is sample_draft_validator.schema


def test_extend_validator_with_required_fields(sample_draft_validator):
    """Test extending a validator with required fields."""
    required_fields = ['entity', 'entity_id']
    new_validator = validators.extend_validator(
        sample_draft_validator, required_fields=required_fields)

    assert new_validator is not sample_draft_validator
    assert new_validator.schema is not sample_draft_validator.schema

    schema = sample_draft_validator.schema
    new_schema = new_validator.schema
    for field in required_fields:
        assert 'required' not in schema['properties'][field]
        assert 'required' in new_schema['properties'][field]


def test_extend_validator_with_new_fields(sample_draft_validator):
    """Test extending a validator without providing required fields."""
    new_fields = {'field': {'type': 'number'}}
    new_validator = validators.extend_validator(
        sample_draft_validator, new_fields=new_fields)

    properties = new_validator.schema['properties']
    assert properties['field']
    assert properties['field'] is not new_fields.get('field')
    assert properties['field'] == new_fields.get('field')