"""Unit Tests for contract_party logic."""

from unittest.mock import patch

import pytest

from abacus_contract.constants.constants import CONTRACT_PARTY_TARGET_TYPES
from abacus_contract.constants.error import ERROR_INVALID_LIMIT_OFFSET
from abacus_contract.logic import contract_party as logic
from tests.utils.factories import ContractFactory
from tests.utils.factories import ContractPartyFactory


@patch('abacus_contract.logic.contract_party.models')
def test_create_contract_party(mock_models):
    """Test create_contract_party function."""
    mock_contract = ContractFactory.create()
    mock_contract_party = ContractPartyFactory.create(contract=mock_contract)
    mock_models.Contract.get_by_id_or_error.return_value = mock_contract
    mock_models.ContractParty.get_contract_party.return_value = None
    mock_models.ContractParty.create.return_value = mock_contract_party

    contract_id = mock_contract.contract_id
    target_id = mock_contract_party.target_id
    target_type = mock_contract_party.target_type

    res = logic.create_contract_party(
        contract_id,
        target_id,
        target_type
    )

    assert res.status == 201
    mock_models.ContractParty.create.assert_called_once_with(
        contract_id=contract_id,
        target_id=target_id,
        target_type=target_type
    )


@patch('abacus_common_logic.models.base.CRUDMixin.update_attributes')
@patch('abacus_contract.logic.contract_party.models')
def test_create_contract_party_for_deleted_record(mock_models, mock_update_attributes):
    """Test create_contract_party function for deleted record."""
    mock_contract = ContractFactory.create()
    mock_contract_party = ContractPartyFactory.create(
        contract=mock_contract,
        deleted_by='Testing',
        deleted_at='2023-07-21 12:42:32'
    )
    mock_models.Contract.get_by_id_or_error.return_value = mock_contract
    mock_models.ContractParty.get_contract_party.return_value = mock_contract_party
    mock_models.ContractParty.commit_changes.return_value = True

    res = logic.create_contract_party(
        mock_contract.contract_id,
        mock_contract_party.target_id,
        mock_contract_party.target_type
    )

    assert res.status == 201
    mock_update_attributes.assert_called_once_with(
        contract_party_id=mock_contract_party.contract_party_id,
        deleted_by=None,
        deleted_at=None
    )
    mock_models.ContractParty.commit_changes.assert_called_once()


@patch('abacus_contract.logic.contract_party._validate_request_params')
@patch('abacus_contract.logic.contract_party.models')
def test_get_contract_parties(mock_models, mock_validation):
    """Test get_contract_parties function."""
    mock_contract = ContractFactory.create()
    mock_contract_party = ContractPartyFactory.create(contract=mock_contract)
    mock_models.ContractParty.get_by_contract_id.return_value = \
        ([mock_contract_party], 1)

    contract_id = mock_contract.contract_id
    target_type = CONTRACT_PARTY_TARGET_TYPES.CONTRIBUTOR
    limit = 5
    offset = 0
    mock_validation.return_value = {
        'contract_id': contract_id,
        'target_type': target_type,
        'limit': limit,
        'offset': offset
    }

    res = logic.get_contract_parties(
        contract_id,
        target_type,
        {limit: limit, offset: offset}
    )

    assert res.status == 200
    assert res.message['items'] == [{
        'contract_party_id': 1,
        'contract_id': 1,
        'target_id': '1ec7c1bf-2318-4052-9406-a3e35a620bd3',
        'target_type': 'contributor'
    }]
    assert res.message['total_count'] == 1
    mock_models.ContractParty.get_by_contract_id.assert_called_once_with(
        contract_id=contract_id,
        target_type=target_type,
        limit=limit,
        offset=offset
    )


@patch('abacus_contract.logic.contract_party.models')
def test_validate_request_params(mock_models):
    """Test _validate_request_params function."""
    mock_contract = ContractFactory.create()
    mock_models.Contract.get_by_id_or_error.return_value = mock_contract
    contract_id = mock_contract.contract_id
    target_type = CONTRACT_PARTY_TARGET_TYPES.CONTRIBUTOR
    request_params = {'limit': 5, 'offset': 0}
    res = logic._validate_request_params(contract_id, target_type, request_params)

    assert res == {
        'contract_id': contract_id,
        'target_type': target_type,
        **request_params
    }


@patch('abacus_contract.logic.contract_party.models')
def test_validate_request_params_with_invalid_target_type(mock_models):
    """Test _validate_request_params function for invalid target_type."""
    mock_contract = ContractFactory.create()
    mock_models.Contract.get_by_id_or_error.return_value = mock_contract
    contract_id = mock_contract.contract_id
    target_type = 'Test'
    request_params = {'limit': 5, 'offset': 0}

    with pytest.raises(Exception) as exc_info:
        logic._validate_request_params(contract_id, target_type, request_params)

    assert str(exc_info.value) == \
        str({'target_type': ['Must be one of contributor, label']})


@patch('abacus_contract.logic.contract_party.models')
def test_validate_request_params_with_invalid_pagination_params(mock_models):
    """Test _validate_request_params function for invalid pagination params."""
    mock_contract = ContractFactory.create()
    mock_models.Contract.get_by_id_or_error.return_value = mock_contract
    contract_id = mock_contract.contract_id
    target_type = CONTRACT_PARTY_TARGET_TYPES.CONTRIBUTOR
    request_params = {'limit': 'Test', 'offset': 0}

    with pytest.raises(Exception, match=ERROR_INVALID_LIMIT_OFFSET):
        logic._validate_request_params(contract_id, target_type, request_params)


@patch('abacus_contract.logic.contract_party.models')
def test_delete_contract_party(mock_models):
    """Test delete_contract_party function."""
    mock_contract = ContractFactory.create()
    mock_contract_party = ContractPartyFactory.create(contract=mock_contract)

    mock_models.ContractParty.commit_changes.return_value = None
    response = logic.delete_contract_party(mock_contract_party)

    assert response.status == 204

    mock_models.ContractParty.delete_by_id_or_error.assert_called_once_with(
        mock_contract_party.contract_party_id,
        soft_delete=True
    )
    mock_models.ContractParty.commit_changes.assert_called_once()