"""Tests for contract term serialization."""

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

from abacus_contract.constants import constants, error
from abacus_contract.schemas.contract_term import (
    ContractTermBulkPostSchema,
    ContractTermPostSchema,
    ContractTermPutSchema,
    ContractTermsByAccountTermTypePostSchema,
    ContractTermSchema,
    ContractTermVerboseSchema,
)
from abacus_contract.tests.utils.factories import (
    ContractFactory,
    ContractTermConditionFactory,
    ContractTermFactory,
)


def test_contract_term_schema():
    """Test contract detail serialization."""
    contract = ContractFactory.create()
    contract_term = ContractTermFactory.create(contract=contract)

    result = ContractTermSchema().dump(contract_term)
    assert result == {
        'term_type': contract_term.term_type,
        'is_base_term': contract_term.is_base_term,
        'contract_term_id': contract_term.contract_term_id,
        'contract_id': contract.contract_id,
        'contract_term_name': contract_term.contract_term_name,
        'attachments': contract_term.attachments,
        'attachments_relations': contract_term.attachments_relations,
    }


def test_contract_term_schema_for_contributor_ids():
    """Test contribution contract term detail serialization."""
    contract = ContractFactory.create()
    contract_term = ContractTermFactory.create(
        contract=contract,
        term_type='contribution',
        attachments_relations={'contributor_ids': ['1', '2']},
    )

    result = ContractTermSchema().dump(contract_term)
    assert result == {
        'term_type': contract_term.term_type,
        'is_base_term': contract_term.is_base_term,
        'contract_term_id': contract_term.contract_term_id,
        'contract_id': contract.contract_id,
        'contract_term_name': contract_term.contract_term_name,
        'attachments': contract_term.attachments,
        'attachments_relations': {'contributor_ids': ['1', '2']},
    }


def test_contract_term_verbose_schema():
    """Test contract term verbose schema includes created / modified data."""
    contract_term = ContractTermFactory.build()
    res = ContractTermVerboseSchema().dump(contract_term)

    assert res['created_at'] == safe_format_datetime(contract_term.created_at)
    assert res['created_by'] == contract_term.created_by
    assert res['last_modified'] == safe_format_datetime(contract_term.last_modified)
    assert res['last_modified_by'] == contract_term.last_modified_by


def test_contract_term_bulk_post_schema():
    """Test contract term bulk post schema includes nested contract_term_conditions."""
    term_conditions = ContractTermConditionFactory.create_batch(2)

    data = [
        {
            'attachments': term_condition.contract_term.attachments,
            'contract_id': term_condition.contract_term.contract_id,
            'is_base_term': term_condition.contract_term.is_base_term,
            'term_type': term_condition.contract_term.term_type,
            'contract_term_conditions': [
                {
                    'conditions': term_condition.conditions,
                    'priority': term_condition.priority,
                    'term_rate': term_condition.term_rate,
                    'commission': term_condition.commission,
                }
            ],
        }
        for term_condition in term_conditions
    ]

    response = ContractTermBulkPostSchema(many=True).dump(data)

    assert len(response) == len(data)
    assert all(res.get('attachments') for res in response)
    assert all(res.get('contract_id') for res in response)
    assert all(res.get('is_base_term') is not None for res in response)
    assert all(res.get('term_type') for res in response)
    assert all(res.get('contract_term_conditions') for res in response)

    contract_term_conditions = list()
    for res in response:
        contract_term_conditions += res.get('contract_term_conditions')

    assert contract_term_conditions
    assert all(ctc.get('conditions') for ctc in contract_term_conditions)
    assert all(ctc.get('priority') for ctc in contract_term_conditions)
    assert all(ctc.get('term_rate') for ctc in contract_term_conditions)
    assert all(ctc.get('commission') for ctc in contract_term_conditions)

    assert all(res.get('contract_term_id') is None for res in response)
    assert all(
        ctc.get('contract_term_condition_id') is None
        for ctc in contract_term_conditions
    )


def test_contract_terms_by_account_term_type_post_schema():
    """Test POST schema to get contract terms by attachments and term_type."""
    params = {
        'term_type': constants.CONTRACT_TERM_TYPES.TRACK,
        'attachments': ['128776'],
    }

    result = ContractTermsByAccountTermTypePostSchema().dump(params)
    assert result == params


def test_contract_term_post_schema():
    """Test contract term post schema."""
    mock_contract = ContractFactory.create()
    mock_contract_term = ContractTermFactory.create(
        contract=mock_contract, contract_term_name='Test Name'
    )
    res = ContractTermPostSchema().dump(mock_contract_term)

    assert res == {
        'contract_term_name': mock_contract_term.contract_term_name,
        'term_type': mock_contract_term.term_type,
        'attachments': mock_contract_term.attachments,
        'attachments_relations': mock_contract_term.attachments_relations,
        'is_base_term': mock_contract_term.is_base_term,
    }


def test_contract_term_post_schema_contributor_schedule_type():
    """Test contract term post schema for contributor_schedule type."""
    mock_contract_term = dict(
        contract_term_name='Test Name',
        term_type='contributor_schedule',
        schedule_ids=['1', '2'],
        is_base_term=1,
    )
    res = ContractTermPostSchema().dump(mock_contract_term)

    assert res == {
        'contract_term_name': mock_contract_term['contract_term_name'],
        'term_type': mock_contract_term['term_type'],
        'schedule_ids': mock_contract_term['schedule_ids'],
        'is_base_term': mock_contract_term['is_base_term'],
    }


def test_contract_term_post_schema_missing_schedule_ids():
    """Test contract term post schema for contributor_schedule type.

    The schema throws an error when the schedule_ids are empty.
    """
    mock_contract_term = dict(
        contract_term_name='Test Name',
        term_type='contributor_schedule',
        schedule_ids=[],
        is_base_term=1,
    )

    with pytest.raises(ValidationError) as excinfo:
        ContractTermPostSchema().load(mock_contract_term)

    assert str(excinfo.value) == str({'_schema': [error.ERROR_MISSING_SCHEDULE_IDS]})


def test_contract_term_put_schema():
    """Test contract term put schema."""
    mock_contract_term = dict(
        contract_term_name='Test Name',
        term_type='contributor_schedule',
        schedule_ids=['1', '2'],
        is_base_term=1,
        attachments=None,
        attachments_relations=None,
    )
    res = ContractTermPutSchema().dump(mock_contract_term)

    assert res == {
        'contract_term_name': mock_contract_term['contract_term_name'],
        'term_type': mock_contract_term['term_type'],
        'schedule_ids': mock_contract_term['schedule_ids'],
        'is_base_term': mock_contract_term['is_base_term'],
        'attachments': mock_contract_term['attachments'],
        'attachments_relations': mock_contract_term['attachments_relations'],
    }


def test_contract_term_put_schema_missing_schedule_ids():
    """Test contract term put schema.

    The schema throws an error when the schedule_ids are empty.
    """
    mock_contract_term = dict(schedule_ids=[])

    with pytest.raises(ValidationError) as excinfo:
        ContractTermPutSchema().load(mock_contract_term)

    assert str(excinfo.value) == str({'_schema': [error.ERROR_MISSING_SCHEDULE_IDS]})


def test_contract_term_put_schema_missing_attachments():
    """Test contract term put schema.

    The schema throws an error when the attachments are empty.
    """
    mock_contract_term = dict(attachments=[])

    with pytest.raises(ValidationError) as excinfo:
        ContractTermPutSchema().load(mock_contract_term)

    assert str(excinfo.value) == str({'_schema': [error.ERROR_MISSING_ATTACHMENT]})