"""Functional tests for contract term endpoints."""

from unittest.mock import patch

from abacus_common_logic.constants.error import ERROR_ENTITY_DOES_NOT_EXIST

from abacus_contract.constants.constants import (
    CONTRACT_TERM_TYPES,
    CONTRACT_TERMS_SNAPSHOT_HEADER,
)
from abacus_contract.constants.error import (
    ERROR_ATTACHMENT_ALREADY_EXISTS,
    ERROR_ATTACHMENTS_CAN_NOT_BE_NULL,
    ERROR_BASE_TERM_ALREADY_EXISTS,
    ERROR_MISSING_ATTACHMENT,
    ERROR_MISSING_BASE_TERM,
    ERROR_MISSING_SCHEDULE_IDS,
)
from abacus_contract.models.contract_term_condition import ContractTermCondition
from abacus_contract.models.contract_term_schedule import ContractTermSchedule
from abacus_contract.tests.utils.factories import (
    AccountContractFactory,
    ContractFactory,
    ContractTermConditionFactory,
    ContractTermFactory,
    ContractTermScheduleFactory,
)


def test_create_contract_term_success(fixture_client, create_mock_account):
    """POST /contract/<int:contract_id>/contract-term."""
    contract = ContractFactory.create()
    AccountContractFactory.create(contract=contract)
    result = fixture_client.post(
        f'/contract/{contract.contract_id}/contract-term',
        json={
            'attachments': ['1010', '2010'],
            'is_base_term': True,
            'term_type': CONTRACT_TERM_TYPES.LABEL,
        },
    )
    assert result.status_code == 201
    assert result.json == {
        'contract_id': contract.contract_id,
        'term_type': CONTRACT_TERM_TYPES.LABEL,
        'attachments': ['1010', '2010'],
        'attachments_relations': None,
        'is_base_term': True,
        'contract_term_id': 1,
        'contract_term_name': None,
    }


def test_create_contract_term_invalid_contract(fixture_client):
    """POST contract_term fails when parent contract does not exist."""
    json_body = {
        'attachments': ['1010', '2010'],
        'is_base_term': True,
        'term_type': CONTRACT_TERM_TYPES.LABEL,
    }

    result = fixture_client.post('/contract/0/contract-term', json=json_body)
    assert result.status_code == 400


def test_create_contract_term_base_term_already_exists_feature_flag_enabled(
    fixture_client,
):
    """POST contract_term succeeds when a base term already exists and FF is enabled."""
    base_term = ContractTermFactory.create(is_base_term=True)
    res = fixture_client.post(
        f'/contract/{base_term.contract_id}/contract-term',
        json={
            'attachments': ['1010', '2010'],
            'is_base_term': True,
            'term_type': CONTRACT_TERM_TYPES.LABEL,
        },
    )

    assert res.status_code == 201
    assert res.json == {
        'contract_id': base_term.contract_id,
        'term_type': CONTRACT_TERM_TYPES.LABEL,
        'attachments': ['1010', '2010'],
        'attachments_relations': None,
        'is_base_term': True,
        'contract_term_id': 2,
        'contract_term_name': None,
    }


def test_create_contract_term_base_term_required_feature_flag_enabled(fixture_client):
    """POST contract_term succeeds without a base term when FF is enabled."""
    contract = ContractFactory.create()
    json_body = {
        'attachments': ['1010', '2010'],
        'is_base_term': False,
        'term_type': CONTRACT_TERM_TYPES.LABEL,
    }

    res = fixture_client.post(
        f'/contract/{contract.contract_id}/contract-term', json=json_body
    )

    assert res.status_code == 201
    assert res.json == {
        'contract_term_id': 1,
        'contract_id': contract.contract_id,
        'contract_term_name': None,
        'term_type': 'label',
        'attachments': ['1010', '2010'],
        'attachments_relations': None,
        'is_base_term': False,
    }


def test_create_contract_term_missing_attachments(fixture_client):
    """POST contract_term fails when attachment list is empty."""
    contract = ContractFactory.create()
    json_body = {
        'attachments': [],
        'is_base_term': True,
        'term_type': CONTRACT_TERM_TYPES.LABEL,
    }

    result = fixture_client.post(
        f'/contract/{contract.contract_id}/contract-term', json=json_body
    )

    assert result.status_code == 400
    assert result.json['message'] == ERROR_MISSING_ATTACHMENT


def test_create_contract_term_duplicated_attachments(fixture_client):
    """POST contract_term fails when same attachment already exists."""
    contract = ContractFactory.create()
    attachments = ['1111', '2222', '3333']
    ContractTermFactory.create(contract=contract, is_base_term=True)
    ContractTermFactory.create(
        contract=contract,
        attachments=attachments,
        term_type=CONTRACT_TERM_TYPES.PRODUCT,
    )
    json_body = {
        'attachments': ['4444', '2222', '1111', '5555'],
        'is_base_term': False,
        'term_type': CONTRACT_TERM_TYPES.PRODUCT,
    }

    result = fixture_client.post(
        f'/contract/{contract.contract_id}/contract-term', json=json_body
    )
    expected_error = ERROR_ATTACHMENT_ALREADY_EXISTS.format(attachment='1111, 2222')
    assert result.status_code == 400
    assert result.json['message'] == expected_error


def test_get_contract_term_by_contract(fixture_client, create_mock_account):
    """GET /contracts/<int:contract_id>/contract-terms."""
    contract = ContractFactory.create()
    AccountContractFactory.create(contract=contract)
    contract_terms = ContractTermFactory.create(contract=contract)
    res = fixture_client.get(f'/contracts/{contract.contract_id}/contract-terms')

    assert res.status_code == 200
    assert res.json[0]['term_type'] == contract_terms.term_type


def test_get_contract_term_by_contract_soft_deleted(
    fixture_client, create_mock_account
):
    """GET /contracts/<int:contract_id>/contract-terms."""
    contract = ContractFactory.create()
    AccountContractFactory.create(contract=contract)
    contract_terms = ContractTermFactory.create_batch(2, contract=contract)
    contract_terms[0].deleted_at = '2022-01-01'
    res = fixture_client.get(f'/contracts/{contract.contract_id}/contract-terms')

    assert res.status_code == 200
    assert len(res.json) == 1


def test_get_contract_term_by_id(fixture_client):
    """GET /contract-term/<int:contract_term_id>."""
    contract = ContractFactory.create()
    contract_term = ContractTermFactory.create(contract=contract)
    contract_term_id = contract_term.contract_term_id
    result = fixture_client.get(f'/contract-term/{contract_term_id}')
    assert result.status_code == 200
    assert result.json == {
        'contract_id': 1,
        'is_base_term': False,
        'attachments': ['7126'],
        'attachments_relations': {'label_ids': ['1', '2'], 'upcs': ['3']},
        'contract_term_id': 1,
        'term_type': 'label',
        'contract_term_name': contract_term.contract_term_name,
    }


def test_update_contract_term(fixture_client):
    """PUT /contract-term/<int:contract_term_id>."""
    contract = ContractFactory.create()
    contract_term = ContractTermFactory.create(contract=contract)
    contract_term_id = contract_term.contract_term_id
    json_body = {
        'attachments': ['78789'],
        'attachments_relations': {'label_ids': ['1', '2'], 'upcs': ['3']},
    }

    result = fixture_client.put(f'/contract-term/{contract_term_id}', json=json_body)

    assert result.status_code == 200
    assert result.json == {
        'contract_id': contract_term.contract_id,
        'term_type': contract_term.term_type,
        'attachments': json_body['attachments'],
        'attachments_relations': json_body['attachments_relations'],
        'is_base_term': contract_term.is_base_term,
        'contract_term_id': contract_term.contract_term_id,
        'contract_term_name': contract_term.contract_term_name,
    }


def test_update_contract_term_duplicated_attachment(fixture_client):
    """PUT /contract-term/<int:contract_term_id> fails due to duplicated attachment."""
    contract = ContractFactory.create()
    ContractTermFactory.create(contract=contract, is_base_term=True)
    ContractTermFactory.create(
        contract=contract,
        attachments=['1111', '2222'],
        term_type=CONTRACT_TERM_TYPES.PRODUCT,
    )
    contract_term = ContractTermFactory.create(
        contract=contract,
        attachments=['3333', '4444'],
        term_type=CONTRACT_TERM_TYPES.PRODUCT,
    )
    contract_term_id = contract_term.contract_term_id
    json_body = {'attachments': ['3333', '1111']}
    result = fixture_client.put(f'/contract-term/{contract_term_id}', json=json_body)
    expected_error = ERROR_ATTACHMENT_ALREADY_EXISTS.format(attachment='1111')
    assert result.status_code == 400
    assert result.json['message'] == expected_error


def test_update_contract_term_nullable_relations(fixture_client):
    """Test to allow None for attachments_relations on update."""
    contract = ContractFactory.create()
    contract_term = ContractTermFactory.create(contract=contract)
    contract_term_id = contract_term.contract_term_id
    json_body = {
        'attachments': ['111111'],
    }

    result = fixture_client.put(f'/contract-term/{contract_term_id}', json=json_body)

    # Attachments relation remains if we don't provide it
    assert result.status_code == 200
    assert result.json['attachments'] == json_body['attachments']
    assert result.json['attachments_relations'] == contract_term.attachments_relations

    json_body_2 = {'attachments': ['2222222'], 'attachments_relations': None}
    result_2 = fixture_client.put(
        f'/contract-term/{contract_term_id}', json=json_body_2
    )
    # Attachments relation are set to None
    assert result_2.status_code == 200
    assert result_2.json['attachments'] == json_body_2['attachments']
    assert result_2.json['attachments_relations'] is None


def test_update_contract_term_update_contract_term_name(fixture_client):
    """PUT /contract-term/<int:contract_term_id>."""
    contract = ContractFactory.create()
    contract_term = ContractTermFactory.create(contract=contract)
    contract_term_id = contract_term.contract_term_id
    json_body = {
        'attachments': ['78789'],
        'attachments_relations': {'label_ids': ['1', '2'], 'upcs': ['3']},
        'contract_term_name': 'New Contract Name Test',
    }

    result = fixture_client.put(f'/contract-term/{contract_term_id}', json=json_body)

    assert result.status_code == 200
    assert result.json == {
        'contract_id': contract_term.contract_id,
        'term_type': contract_term.term_type,
        'attachments': json_body['attachments'],
        'attachments_relations': json_body['attachments_relations'],
        'is_base_term': contract_term.is_base_term,
        'contract_term_id': contract_term.contract_term_id,
        'contract_term_name': json_body['contract_term_name'],
    }


def test_get_contract_term_snapshot(fixture_client):
    """POST /contract-terms/snapshot."""
    contract_term_condition = ContractTermConditionFactory.create()
    contract_id = contract_term_condition.contract_term.contract_id

    res = fixture_client.post('/contract-terms/snapshot', json=[contract_id])

    assert res.status_code == 200
    assert res.data.decode()

    data = res.data.decode()
    assert data.split('\n')[0] == '\t'.join(CONTRACT_TERMS_SNAPSHOT_HEADER)


def test_get_contract_terms_for_account_and_term_type(
    fixture_client, create_mock_account
):
    """POST /account/{account_id}/contract-terms/."""
    account_id = 1
    tracks_attachments_1 = ['01234', '56781']
    tracks_attachments_2 = ['128776', '129751']
    params = {'attachments': ['128776', '01234', '11111'], 'term_type': 'track'}

    contract_1 = ContractFactory.create()
    AccountContractFactory.create(account_id=account_id, contract=contract_1)
    contract_term_1 = ContractTermFactory.create(
        contract=contract_1,
        term_type=CONTRACT_TERM_TYPES.TRACK,
        attachments=tracks_attachments_1,
    )

    contract_2 = ContractFactory.create()
    AccountContractFactory.create(account_id=account_id, contract=contract_2)
    contract_term_2 = ContractTermFactory.create(
        contract=contract_2,
        term_type=CONTRACT_TERM_TYPES.TRACK,
        attachments=tracks_attachments_2,
    )

    res = fixture_client.post(f'/account/{account_id}/contract-terms/', json=params)

    assert res.status_code == 200
    assert res.json[0]['contract_term_id'] == contract_term_1.contract_term_id
    assert res.json[1]['contract_term_id'] == contract_term_2.contract_term_id
    assert len(res.json) == 2


def test_get_contract_terms_for_account_and_term_type_error(fixture_client):
    """POST /account/{account_id}/contract-terms/ fails when attachments list is empty."""
    account_id = 24601
    params = {'attachments': [], 'term_type': 'product'}

    res = fixture_client.post(f'/account/{account_id}/contract-terms/', json=params)

    assert res.status_code == 400
    assert res.json['message']['attachments'][0] == ERROR_MISSING_ATTACHMENT


def test_get_contribution_contract_term_by_id(fixture_client):
    """Test to get contract terms for contribution term type."""
    contract = ContractFactory.create()
    contract_term = ContractTermFactory.create(
        contract=contract,
        term_type=CONTRACT_TERM_TYPES.CONTRIBUTION_SCHEDULE,
        is_base_term=True,
        attachments_relations={'contributor_ids': ['1', '2']},
    )
    contract_term_id = contract_term.contract_term_id
    result = fixture_client.get(f'/contract-term/{contract_term_id}')
    assert result.status_code == 200
    assert result.json == {
        'contract_id': 1,
        'is_base_term': True,
        'contract_term_name': contract_term.contract_term_name,
        'attachments': ['7126'],
        'attachments_relations': {'contributor_ids': ['1', '2']},
        'contract_term_id': 1,
        'term_type': CONTRACT_TERM_TYPES.CONTRIBUTION_SCHEDULE,
    }


def test_create_contract_term_for_contributor(
    fixture_client, create_mock_account, create_mock_schedule
):
    """POST /contract/<int:contract_id>/contract-term for contributor."""
    contract = ContractFactory.create()
    AccountContractFactory.create(contract=contract)
    result = fixture_client.post(
        f'/contract/{contract.contract_id}/contract-term',
        json={
            'contract_term_name': 'Test',
            'schedule_ids': ['1', '2'],
            'is_base_term': True,
            'term_type': CONTRACT_TERM_TYPES.CONTRIBUTOR_SCHEDULE,
        },
    )
    contract_term_schedules = ContractTermSchedule.query.all()

    assert len(contract_term_schedules) == 2
    assert result.status_code == 201
    assert result.json == {
        'contract_id': contract.contract_id,
        'term_type': CONTRACT_TERM_TYPES.CONTRIBUTOR_SCHEDULE,
        'attachments': None,
        'attachments_relations': None,
        'is_base_term': True,
        'contract_term_id': 1,
        'contract_term_name': 'Test',
    }


def test_create_contract_term_missing_schedule_ids(fixture_client):
    """POST contract_term fails when schedule_ids list is empty."""
    contract = ContractFactory.create()
    json_body = {
        'schedule_ids': [],
        'is_base_term': True,
        'term_type': CONTRACT_TERM_TYPES.CONTRIBUTOR_SCHEDULE,
    }

    result = fixture_client.post(
        f'/contract/{contract.contract_id}/contract-term', json=json_body
    )

    assert result.status_code == 400
    assert result.json['message'] == {'_schema': [ERROR_MISSING_SCHEDULE_IDS]}


def test_update_contract_term_for_contributor(fixture_client, create_mock_schedule):
    """PUT /contract-term/<int:contract_term_id> for contributor."""
    schedule_ids = ['1', '3']
    mock_contract = ContractFactory.create()
    mock_contract_term = ContractTermFactory.create(
        contract=mock_contract,
        term_type=CONTRACT_TERM_TYPES.CONTRIBUTOR_SCHEDULE,
        attachments=None,
        attachments_relations=None,
        is_base_term=True,
    )
    contract_term_id = mock_contract_term.contract_term_id
    [
        ContractTermScheduleFactory.create(
            contract_term=mock_contract_term,
            schedule_id=schedule_id,
        )
        for schedule_id in schedule_ids
    ]

    contract_term_schedules = ContractTermSchedule.query.all()
    assert len(contract_term_schedules) == 2

    json_body = {'schedule_ids': ['1', '3', '2']}

    result = fixture_client.put(f'/contract-term/{contract_term_id}', json=json_body)

    contract_term_schedules = ContractTermSchedule.query.all()
    assert len(contract_term_schedules) == 3
    assert result.status_code == 200
    assert result.json == {
        'contract_id': mock_contract.contract_id,
        'term_type': CONTRACT_TERM_TYPES.CONTRIBUTOR_SCHEDULE,
        'attachments': None,
        'attachments_relations': None,
        'is_base_term': True,
        'contract_term_id': 1,
        'contract_term_name': mock_contract_term.contract_term_name,
    }


def test_update_contract_term_missing_schedule_ids(fixture_client):
    """PUT contract_term fails when schedule_ids list is empty."""
    mock_contract = ContractFactory.create()
    mock_contract_term = ContractTermFactory.create(
        contract=mock_contract, term_type=CONTRACT_TERM_TYPES.CONTRIBUTOR_SCHEDULE
    )
    json_body = {'schedule_ids': []}

    result = fixture_client.put(
        f'/contract-term/{mock_contract_term.contract_term_id}', json=json_body
    )

    assert result.status_code == 400
    assert result.json['message'] == {'_schema': [ERROR_MISSING_SCHEDULE_IDS]}


def test_update_contract_term_to_delete_term_schedule(
    fixture_client, create_mock_schedule
):
    """PUT /contract-term/<int:contract_term_id> deletes existing term_schedules."""
    schedule_ids = ['1', '3']
    mock_contract = ContractFactory.create()
    mock_contract_term = ContractTermFactory.create(
        contract=mock_contract,
        term_type=CONTRACT_TERM_TYPES.CONTRIBUTOR_SCHEDULE,
        attachments=None,
        attachments_relations=None,
        is_base_term=True,
    )
    contract_term_id = mock_contract_term.contract_term_id
    [
        ContractTermScheduleFactory.create(
            contract_term=mock_contract_term,
            schedule_id=schedule_id,
        )
        for schedule_id in schedule_ids
    ]

    contract_term_schedules = ContractTermSchedule.query.all()
    assert len(contract_term_schedules) == 2

    json_body = {'schedule_ids': ['1']}

    result = fixture_client.put(f'/contract-term/{contract_term_id}', json=json_body)

    contract_term_schedules = ContractTermSchedule.query.all()

    assert result.status_code == 200

    assert contract_term_schedules[0].deleted_by is None
    assert contract_term_schedules[0].deleted_at is None

    assert contract_term_schedules[1].deleted_by is not None
    assert contract_term_schedules[1].deleted_at is not None


def test_update_contract_term_to_restore_term_schedule(
    fixture_client, create_mock_schedule
):
    """PUT /contract-term/<int:contract_term_id> restores deleted term_schedules."""
    schedule_ids = ['1', '3']
    mock_contract = ContractFactory.create()
    mock_contract_term = ContractTermFactory.create(
        contract=mock_contract,
        term_type=CONTRACT_TERM_TYPES.CONTRIBUTOR_SCHEDULE,
        attachments=None,
        attachments_relations=None,
        is_base_term=True,
    )
    contract_term_id = mock_contract_term.contract_term_id
    [
        ContractTermScheduleFactory.create(
            contract_term=mock_contract_term,
            schedule_id=schedule_id,
            deleted_by=None if schedule_id == '1' else 'test_user',
            deleted_at=None if schedule_id == '1' else '2023-08-21',
        )
        for schedule_id in schedule_ids
    ]

    contract_term_schedules = ContractTermSchedule.query.all()
    assert contract_term_schedules[0].deleted_by is None
    assert contract_term_schedules[0].deleted_at is None

    assert contract_term_schedules[1].deleted_by is not None
    assert contract_term_schedules[1].deleted_at is not None

    json_body = {'schedule_ids': ['1', '3']}

    result = fixture_client.put(f'/contract-term/{contract_term_id}', json=json_body)

    contract_term_schedules = ContractTermSchedule.query.all()

    assert result.status_code == 200

    assert contract_term_schedules[0].deleted_by is None
    assert contract_term_schedules[0].deleted_at is None

    assert contract_term_schedules[1].deleted_by is None
    assert contract_term_schedules[1].deleted_at is None


def test_soft_delete_distribution_contract_term(fixture_client):
    """Soft DELETE distribution contract_term and attached term conditions."""
    contract = ContractFactory.create()
    contract_term = ContractTermFactory.create(contract=contract)
    ContractTermConditionFactory.create(contract_term=contract_term)
    ContractTermConditionFactory.create(contract_term=contract_term)

    contract_term_conditions = ContractTermCondition.get_active_term_conditions(
        contract_term.contract_term_id
    ).all()
    assert len(contract_term_conditions) == 2

    result = fixture_client.delete(f'/contract-term/{contract_term.contract_term_id}')

    contract_term_conditions = ContractTermCondition.get_active_term_conditions(
        contract_term.contract_term_id
    ).all()

    assert result.status_code == 204
    assert len(contract_term_conditions) == 0


def test_soft_delete_nr_contract_term(fixture_client, create_mock_schedule):
    """Soft DELETE NR contract_term, attached term schedules and conditions."""
    contract = ContractFactory.create()
    contract_term = ContractTermFactory.create(contract=contract)
    ContractTermScheduleFactory.create(contract_term=contract_term)
    ContractTermConditionFactory.create(contract_term=contract_term)
    ContractTermConditionFactory.create(contract_term=contract_term)

    contract_term_conditions = ContractTermCondition.get_active_term_conditions(
        contract_term.contract_term_id
    ).all()
    contract_term_schedules = ContractTermSchedule.get_by_term_id(
        contract_term.contract_term_id
    )

    assert len(contract_term_conditions) == 2
    assert len(contract_term_schedules) == 1

    result = fixture_client.delete(f'/contract-term/{contract_term.contract_term_id}')

    contract_term_conditions = ContractTermCondition.get_active_term_conditions(
        contract_term.contract_term_id
    ).all()
    contract_term_schedules = ContractTermSchedule.get_by_term_id(
        contract_term.contract_term_id
    )

    assert result.status_code == 204
    assert len(contract_term_conditions) == 0
    assert len(contract_term_schedules) == 0


def test_get_contract_term(fixture_client):
    """GET contract_Term."""
    contract = ContractFactory.create()
    contract_term = ContractTermFactory.create(contract=contract)

    result = fixture_client.get(f'/contract-term/{contract_term.contract_term_id}')

    assert result.status_code == 200
    assert result.json == {
        'contract_term_id': 1,
        'is_base_term': False,
        'term_type': 'label',
        'contract_id': 1,
        'attachments_relations': {'upcs': ['3'], 'label_ids': ['1', '2']},
        'contract_term_name': 'Test contract term',
        'attachments': ['7126'],
    }


def test_get_contract_term_error(fixture_client):
    """GET contract_Term throws an error for deleted contract term."""
    contract = ContractFactory.create()
    contract_term = ContractTermFactory.create(
        contract=contract, deleted_by='Testing', deleted_at='2023-09-12 12:09:27'
    )

    result = fixture_client.get(f'/contract-term/{contract_term.contract_term_id}')

    assert result.status_code == 404
    assert result.json['message'] == ERROR_ENTITY_DOES_NOT_EXIST.format(
        object_type='Contract Term', object_id=contract_term.contract_term_id
    )


def test_create_contract_term_null_attachments(fixture_client, create_mock_account):
    """Throws an error if null attachments is send and FF is disabled."""
    contract = ContractFactory.create()
    AccountContractFactory.create(contract=contract)
    result = fixture_client.post(
        f'/contract/{contract.contract_id}/contract-term',
        json={
            'attachments': None,
            'is_base_term': True,
            'term_type': CONTRACT_TERM_TYPES.LABEL,
        },
    )

    assert result.status_code == 400
    assert result.json['message'] == ERROR_ATTACHMENTS_CAN_NOT_BE_NULL


@patch(
    'abacus_contract.logic.contract_term.is_abacus_terms_with_no_tracks_and_products_enabled'
)
def test_create_contract_term_null_attachments_ff_enabled(
    mock_is_feature_enabled, fixture_client, create_mock_account
):
    """Creates a contract term if null attachments is send and FF is enabled."""
    mock_is_feature_enabled.return_value = True
    contract = ContractFactory.create()
    AccountContractFactory.create(contract=contract)
    result = fixture_client.post(
        f'/contract/{contract.contract_id}/contract-term',
        json={
            'attachments': None,
            'is_base_term': True,
            'term_type': CONTRACT_TERM_TYPES.PRODUCT,
        },
    )

    assert result.status_code == 201
    assert result.json == {
        'attachments': None,
        'attachments_relations': None,
        'contract_id': contract.contract_id,
        'contract_term_name': None,
        'contract_term_id': 1,
        'term_type': CONTRACT_TERM_TYPES.PRODUCT,
        'is_base_term': True,
    }


@patch(
    'abacus_contract.logic.contract_term.is_abacus_terms_with_no_tracks_and_products_enabled'
)
def test_update_contract_term_with_null_attachments_ff_disabled(
    mock_is_feature_enabled, fixture_client, create_mock_account
):
    """Throws an error if try to update an attachments to null when FF is disabled."""
    mock_is_feature_enabled.return_value = False
    mock_contract = ContractFactory.create()
    mock_contract_term = ContractTermFactory.create(
        contract=mock_contract, term_type=CONTRACT_TERM_TYPES.PRODUCT
    )

    json_body = {'attachments': None}

    result = fixture_client.put(
        f'/contract-term/{mock_contract_term.contract_term_id}', json=json_body
    )

    assert result.status_code == 400
    assert result.json['message'] == ERROR_ATTACHMENTS_CAN_NOT_BE_NULL


@patch(
    'abacus_contract.logic.contract_term.is_abacus_terms_with_no_tracks_and_products_enabled'
)
def test_update_contract_term_with_null_attachments_ff_enabled(
    mock_is_feature_enabled, fixture_client, create_mock_account
):
    """Updates the attachments of the contract term to null when FF is enabled."""
    mock_is_feature_enabled.return_value = True
    mock_contract = ContractFactory.create()
    mock_contract_term = ContractTermFactory.create(
        contract=mock_contract, term_type=CONTRACT_TERM_TYPES.TRACK
    )

    json_body = {'attachments': None}

    result = fixture_client.put(
        f'/contract-term/{mock_contract_term.contract_term_id}', json=json_body
    )

    assert result.status_code == 200
    assert result.json == {
        'contract_term_id': 1,
        'contract_id': 1,
        'contract_term_name': 'Test contract term',
        'term_type': 'track',
        'attachments': None,
        'attachments_relations': {'label_ids': ['1', '2'], 'upcs': ['3']},
        'is_base_term': False,
    }


@patch(
    'abacus_contract.logic.contract_term.is_abacus_terms_with_no_tracks_and_products_enabled'
)
def test_create_label_contract_term_null_attachments_ff_enabled(
    mock_is_feature_enabled, fixture_client, create_mock_account
):
    """Throws an error if try to create a label term with null attachments and FF is enabled."""
    mock_is_feature_enabled.return_value = True
    contract = ContractFactory.create()
    AccountContractFactory.create(contract=contract)
    result = fixture_client.post(
        f'/contract/{contract.contract_id}/contract-term',
        json={
            'attachments': None,
            'is_base_term': True,
            'term_type': CONTRACT_TERM_TYPES.LABEL,
        },
    )

    assert result.status_code == 400
    assert result.json['message'] == ERROR_ATTACHMENTS_CAN_NOT_BE_NULL


@patch(
    'abacus_contract.logic.contract_term.is_abacus_terms_with_no_tracks_and_products_enabled'
)
def test_update_label_contract_term_with_null_attachments_ff_enabled(
    mock_is_feature_enabled, fixture_client, create_mock_account
):
    """Throws an error if try to update the label contract term with null attachments when FF is disabled."""
    mock_is_feature_enabled.return_value = False
    mock_contract = ContractFactory.create()
    mock_contract_term = ContractTermFactory.create(
        contract=mock_contract, term_type=CONTRACT_TERM_TYPES.LABEL
    )

    json_body = {'attachments': None}

    result = fixture_client.put(
        f'/contract-term/{mock_contract_term.contract_term_id}', json=json_body
    )

    assert result.status_code == 400
    assert result.json['message'] == ERROR_ATTACHMENTS_CAN_NOT_BE_NULL