"""Tests for vendor contract serialization."""

import datetime

import pytest
from marshmallow.exceptions import ValidationError

from abacus_legacy_sync.constants import constants
from abacus_legacy_sync.schemas.vendor_contract import (
    VendorContractDetailSchema,
    VendorContractPostSchema,
    VendorContractPutSchema,
)

from tests.utils.factories import VendorContractFactory


def test_vendor_contract_detail_schema():
    """Test vendor contract detail serialization."""
    vendor_contract = VendorContractFactory.create()

    result = VendorContractDetailSchema().dump(vendor_contract)
    assert result == {
        'cont_end': '2122-12-31',
        'currency_id': 1,
        'territory_carve_out': '17,201,18,19,199',
        'is_automatic_rollover': 'Y',
        'release_term': 0,
        'payment_interval': 'month',
        'cont_start': '2022-01-01',
        'pay_after': '30',
        'contract_type': 'vendor_term',
        'vendor_id': 77,
        'opt_out': 'N',
        'vendor_contract_id': 1,
        'digital_split': 0.75,
    }


def test_vendor_contract_post_schema():
    """Test vendor contract POST serialization."""
    input_data = {
        'vendor_id': 77,
        'cont_start': datetime.date(2022, 1, 1),
        'cont_end': datetime.date(2122, 12, 31),
        'contract_type': constants.VENDOR_CONTRACT_CONTRACT_TYPES.VENDOR_TERM,
        'release_term': 0,
        'opt_out': 'N',
        'is_automatic_rollover': 'Y',
        'payment_interval': constants.VENDOR_CONTRACT_PAYMENT_INTERVALS.MONTH,
        'pay_after': constants.VENDOR_CONTRACT_PAY_AFTER_INTERVALS.AFTER_30,
        'digital_split': 0.75,
        'currency_code': 'USD',
        'country_exclusion': ['USA'],
        'store_exclusion': ['1', '2'],
        'distribution_type_id': 1,
    }
    result = VendorContractPostSchema().dump(input_data)
    assert result == {
        'cont_end': '2122-12-31',
        'currency_code': input_data['currency_code'],
        'country_exclusion': input_data['country_exclusion'],
        'is_automatic_rollover': input_data['is_automatic_rollover'],
        'release_term': input_data['release_term'],
        'payment_interval': input_data['payment_interval'],
        'cont_start': '2022-01-01',
        'pay_after': input_data['pay_after'],
        'contract_type': input_data['contract_type'],
        'vendor_id': input_data['vendor_id'],
        'opt_out': input_data['opt_out'],
        'digital_split': input_data['digital_split'],
        'store_exclusion': input_data['store_exclusion'],
        'distribution_type_id': input_data['distribution_type_id'],
    }
    assert VendorContractPostSchema().load(result) == input_data


def test_vendor_contract_post_schema_null_payment_info():
    """Test vendor contract POST serialization when payment info is null."""
    input_data = {
        'vendor_id': 77,
        'cont_start': datetime.date(2022, 1, 1),
        'cont_end': datetime.date(2122, 12, 31),
        'contract_type': constants.VENDOR_CONTRACT_CONTRACT_TYPES.VENDOR_TERM,
        'release_term': 0,
        'opt_out': 'N',
        'is_automatic_rollover': 'Y',
        'payment_interval': None,
        'pay_after': None,
        'digital_split': 0.75,
        'currency_code': 'USD',
        'country_exclusion': ['USA'],
        'store_exclusion': ['1', '2'],
        'distribution_type_id': 1,
    }
    result = VendorContractPostSchema().dump(input_data)
    assert result == {
        'cont_end': '2122-12-31',
        'currency_code': input_data['currency_code'],
        'country_exclusion': input_data['country_exclusion'],
        'is_automatic_rollover': input_data['is_automatic_rollover'],
        'release_term': input_data['release_term'],
        'payment_interval': input_data['payment_interval'],
        'cont_start': '2022-01-01',
        'pay_after': input_data['pay_after'],
        'contract_type': input_data['contract_type'],
        'vendor_id': input_data['vendor_id'],
        'opt_out': input_data['opt_out'],
        'digital_split': input_data['digital_split'],
        'store_exclusion': input_data['store_exclusion'],
        'distribution_type_id': input_data['distribution_type_id'],
    }
    assert VendorContractPostSchema().load(result) == input_data


def test_vendor_contract_post_schema_errors():
    """Test to return validation errors on corrupted input."""
    input_data = {
        'vendor_id': 1234567891011,
        'cont_start': '2022-01-01',
        'cont_end': None,
        'contract_type': constants.VENDOR_CONTRACT_CONTRACT_TYPES.VENDOR_TERM,
        'release_term': 0,
        'opt_out': 'No',
        'is_automatic_rollover': 'some message',
        'payment_interval': constants.VENDOR_CONTRACT_PAYMENT_INTERVALS.MONTH,
        'pay_after': constants.VENDOR_CONTRACT_PAY_AFTER_INTERVALS.AFTER_30,
        'digital_split': 705,
        'currency_code': 'USD',
        'country_exclusion': ['USA'],
    }
    with pytest.raises(ValidationError) as err:
        VendorContractPostSchema().load(input_data)
    assert err.value.messages == {
        'opt_out': ['Must be one of Y, N'],
        'digital_split': [
            'Must be greater than or equal to 0.0 and less than or equal to 1.0.'
        ],
        'is_automatic_rollover': ['Must be one of Y, N'],
        'vendor_id': [
            'Must be greater than or equal to 0 and less than or equal to 100000000000.'
        ],
    }


def test_vendor_contract_post_schema_missing_distribution_type():
    """Test to return validation errors when distribution_type_id is missing."""
    input_data = {
        'vendor_id': 77,
        'cont_start': '2022-01-01',
        'cont_end': None,
        'contract_type': constants.VENDOR_CONTRACT_CONTRACT_TYPES.VENDOR_TERM,
        'release_term': 0,
        'opt_out': 'N',
        'is_automatic_rollover': 'Y',
        'payment_interval': constants.VENDOR_CONTRACT_PAYMENT_INTERVALS.MONTH,
        'pay_after': constants.VENDOR_CONTRACT_PAY_AFTER_INTERVALS.AFTER_30,
        'digital_split': 0.75,
        'currency_code': 'USD',
        'country_exclusion': ['USA'],
        'store_exclusion': ['1', '2'],
    }

    with pytest.raises(ValidationError) as err:
        VendorContractPostSchema().load(input_data)

    assert err.value.args[0] == {
        '_schema': ['distribution_type_id is required when store_exclusion is present.']
    }  # noqa: E501


def test_vendor_contract_put_schema():
    """Test vendor contract PUT request serialization."""
    mock_put_request_body = {
        'country_exclusion': ['RUS'],
        'store_exclusion': ['1', '2', '3'],
        'distribution_type_id': 1,
    }

    result = VendorContractPutSchema().dump(mock_put_request_body)
    assert result == mock_put_request_body


def test_vendor_contract_put_schema_error():
    """Test to return validation errors when distribution_type_id is missing."""
    mock_put_request_body = {
        'country_exclusion': ['RUS'],
        'store_exclusion': ['1', '2', '3'],
    }

    with pytest.raises(ValidationError) as err:
        VendorContractPutSchema().load(mock_put_request_body)

    assert err.value.args[0] == {
        '_schema': ['distribution_type_id is required when store_exclusion is present.']
    }  # noqa: E501