"""Integration tests suite."""
import random
from random import randint

from abacus_common_logic.connectors.database import db
import pytest
import requests

from abacus_contract.constants import error
from tests.integration.conftest import (
    ows_abacus_contract_api_client,
    update_db_field_value
)
from tests.integration.consts import api
from tests.integration.utils.generic_helper import (
    create_account,
    create_runcontroller,
    create_runcontroller_contract,
    generate_random_string
)


@pytest.mark.jira('ACC-2976')
def test_get_hello():
    """Get Hello Endpoint."""
    response = requests.get(api.HEALTH_CHECK)
    assert response.status_code == 200, 'Reason: {}\nURL: {}'.format(
        response.reason, response.url)
    response_body = response.json()
    assert 'status' in response_body
    assert 'ok' in response_body['status']


@pytest.mark.jira('ACC-2950')
def test_post_get_contract(basic_headers, clear_db):
    """POST and GET /contract endpoints."""
    account_fixture = create_account()
    runcontroller_fixture = create_runcontroller()
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)
    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract_body = ows_abacus_contract_client.generate_contract_body(
        contract_name,
        account_fixture['account_id']
    )
    response_post = ows_abacus_contract_client.post_contract(contract_body)
    assert response_post.status_code == 201
    contract_id = response_post.json()['contract_id']

    create_runcontroller_contract(
        runcontroller_fixture['runcontroller_id'], contract_id
    )

    response_get_contract = ows_abacus_contract_client.get_contract(contract_id)
    assert response_get_contract.status_code == 200
    contract_body['contract_id'] = contract_id
    contract_body['oa_contract_id'] = None
    contract_body['sap_created_at'] = None
    contract_body['execution_date'] = None
    contract_body['initial_start_date'] = None
    contract_body['is_excluded_from_accounting_run'] = False

    assert contract_body == response_get_contract.json()

    response_get_contracts = ows_abacus_contract_client.get_contracts()
    assert response_get_contracts.status_code == 200
    assert response_get_contracts.json()['total_count'] > 0

    response_post_contracts = ows_abacus_contract_client.post_contracts([contract_id])
    assert response_post_contracts.status_code == 200
    assert len(response_post_contracts.json()) > 0


@pytest.mark.jira('ACC-7669')
@pytest.mark.parametrize(
    'contract_id_value, contract_id_case',
    [
        ({'contract_id': None}, 'contract_id_value_none'),
        ({'contract_id': 424242}, 'contract_id_value_passed'),
        ({}, 'contract_id_not_passed'),
    ],
)
def test_post_contract_id_not_null(basic_headers, contract_id_value, contract_id_case):
    """POST /contract with/without contract_id."""
    account_fixture = create_account()
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)
    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    post_body = {
        'contract_id': None,
        'contract_name': contract_name,
        'contract_type': 'distribution',
        'account_id': account_fixture['account_id'],
        'reference_signing_entity_id': 2,
        'term_start': '2019-06-01',
        'term_end': '2020-06-01',
        'summary_note': 'testing',
        'general_note': 'testing'
    }
    post_body.update(contract_id_value)
    response_post = ows_abacus_contract_client.post_contract(post_body)
    assert response_post.status_code == 201
    contract_id = response_post.json()['contract_id']

    response_get_contract = ows_abacus_contract_client.get_contract(contract_id)
    assert response_get_contract.status_code == 200

    match contract_id_case:
        case 'contract_id_value_none':
            assert 'contract_id' in response_get_contract.json()
            assert response_get_contract.json()['contract_id'] is not None
        case 'contract_id_value_passed':
            assert 'contract_id' in response_get_contract.json()
            assert response_get_contract.json()['contract_id'] == \
                   contract_id_value['contract_id']
        case 'contract_id_not_passed':
            assert 'contract_id' in response_get_contract.json()
            assert response_get_contract.json()['contract_id'] is not None


@pytest.mark.jira('ACC-5691')
def test_get_contracts_by_search_term(basic_headers, clear_db):
    """Get contracts by search term."""
    account_fixture = create_account()
    runcontroller_fixture = create_runcontroller()
    account_id_1 = account_fixture['account_id']

    account_fixture = create_account()
    account_id_2 = account_fixture['account_id']

    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)

    contract_name_1 = 'test search by term'
    contract_body = ows_abacus_contract_client.generate_contract_body(
        contract_name_1,
        account_id_1
    )
    response_post = ows_abacus_contract_client.post_contract(contract_body)
    assert response_post.status_code == 201
    contract_id_1 = response_post.json()['contract_id']

    contract_name_2 = 'abcdefg'
    contract_body = ows_abacus_contract_client.generate_contract_body(
        contract_name_2,
        account_id_2
    )
    response_post = ows_abacus_contract_client.post_contract(contract_body)
    assert response_post.status_code == 201
    contract_id_2 = response_post.json()['contract_id']

    create_runcontroller_contract(
        runcontroller_fixture['runcontroller_id'], contract_id_1
    )
    create_runcontroller_contract(
        runcontroller_fixture['runcontroller_id'], contract_id_2
    )

    params = {'search_term': 'search'}
    response = ows_abacus_contract_client.get_contracts_by_search_term(params)
    assert response.status_code == 200
    assert len(response.json()['items']) == 1
    assert response.json()['items'][0]['account_id'] == account_id_1
    assert response.json()['items'][0]['contract_name'] == contract_name_1

    params = {'account_ids': account_id_2}
    response = ows_abacus_contract_client.get_contracts_by_search_term(params)
    assert response.status_code == 200
    assert len(response.json()['items']) == 1
    assert response.json()['items'][0]['account_id'] == account_id_2
    assert response.json()['items'][0]['contract_name'] == contract_name_2


@pytest.mark.jira('ACC-5312')
def test_put_contract(basic_headers):
    """PUT /contract endpoint."""
    account_fixture = create_account()
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)
    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract_body = ows_abacus_contract_client.generate_contract_body(
        contract_name,
        account_fixture['account_id']
    )
    response_post = ows_abacus_contract_client.post_contract(contract_body)
    assert response_post.status_code == 201
    contract_id = response_post.json()['contract_id']

    updated_contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    put_body = {
        'contract_name': updated_contract_name,
        'term_start': '2019-06-01',
        'term_end': '2020-06-01'
    }
    res_put = ows_abacus_contract_client.put_contract(contract_id, put_body)
    assert res_put.status_code == 200
    assert res_put.json()['contract_name'] == updated_contract_name

    res_get = ows_abacus_contract_client.get_contract(contract_id)
    assert res_get.status_code == 200
    assert res_get.json()['term_start'] == put_body['term_start']
    assert res_get.json()['term_end'] == put_body['term_end']


@pytest.mark.jira('ACC-3385')
def test_post_contracts_with_same_name(basic_headers):
    """POST /contract endpoint twice with the same contract name."""
    account_fixture = create_account()
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)
    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract_body = ows_abacus_contract_client.generate_contract_body(
        contract_name,
        account_fixture['account_id']
    )
    response_post = ows_abacus_contract_client.post_contract(contract_body)
    assert response_post.status_code == 201
    contract_id = response_post.json()['contract_id']
    assert contract_id > 0

    other_response_post = ows_abacus_contract_client.post_contract(contract_body)
    assert other_response_post.status_code == 201
    other_contract_id = other_response_post.json()['contract_id']
    assert other_contract_id > 0

    assert contract_id != other_contract_id


@pytest.mark.jira('ACC-3134')
def test_get_contract_term_by_id(basic_headers):
    """GET /contract-term/<id> endpoint."""
    account_fixture = create_account()
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)
    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract_body = ows_abacus_contract_client.generate_contract_body(
        contract_name,
        account_fixture['account_id'],
        'distribution'
    )
    response_post = ows_abacus_contract_client.post_contract(contract_body)
    assert response_post.status_code == 201
    contract_id = response_post.json()['contract_id']

    term = {
        'term_type': 'label',
        'attachments': ['1010', '2010'],
        'attachments_relations': {
            'label_ids': ['1', '2'],
            'upcs': ['3']
        },
        'is_base_term': True
    }

    response_post_term = ows_abacus_contract_client.post_contract_term(
        contract_id, term)
    assert response_post_term.status_code == 201
    contract_term_id = response_post_term.json()['contract_term_id']

    response_get_contract_term = ows_abacus_contract_client.get_contract_term(
        contract_term_id)
    assert response_get_contract_term.status_code == 200
    term.update(contract_term_id=contract_term_id)
    term.update(contract_id=contract_id)
    term.update(contract_term_name=None)
    assert response_get_contract_term.json() == term


@pytest.mark.jira('ACC-2984')
def test_put_contract_term(basic_headers):
    """PUT /contract-term endpoint."""
    account_fixture = create_account()
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)
    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract_body = ows_abacus_contract_client.generate_contract_body(
        contract_name,
        account_fixture['account_id'],
        'distribution'
    )
    response_post = ows_abacus_contract_client.post_contract(contract_body)
    assert response_post.status_code == 201
    contract_id = response_post.json()['contract_id']

    term = {
        'term_type': 'label',
        'attachments': ['1010', '2010'],
        'attachments_relations': {
            'label_ids': ['1', '2'],
            'upcs': ['3']
        },
        'is_base_term': True
    }

    response_post_term = ows_abacus_contract_client.post_contract_term(
        contract_id, term)
    assert response_post_term.status_code == 201
    contract_term_id = response_post_term.json()['contract_term_id']

    term_update = {
        'attachments': ['3010', '4010'],
        'attachments_relations': {
            'label_ids': ['3', '4'],
            'upcs': ['5']
        },
    }

    response_put_term = ows_abacus_contract_client \
        .put_contract_term(contract_term_id, term_update)
    assert response_put_term.status_code == 200
    assert response_put_term.json()['attachments'] == term_update['attachments']
    assert response_put_term.json()['attachments_relations'] == \
           term_update['attachments_relations']


@pytest.mark.jira('ACC-3188')
def test_get_tsv_contract_snapshot(basic_headers):
    """POST /contracts/snapshot endpoint."""
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)
    response_get = ows_abacus_contract_client.get_tsv_contract_snapshot([])
    assert response_get.status_code == 200
    assert response_get.text != ''


@pytest.mark.jira('ACC-3188')
def test_get_tsv_contract_terms_snapshot(basic_headers):
    """POST /contracts/snapshot endpoint."""
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)
    response_get = ows_abacus_contract_client.get_tsv_contract_terms_snapshot([])
    assert response_get.status_code == 200
    assert response_get.text != ''


@pytest.mark.jira('ACC-3393')
def test_post_get_contracts_by_oa_contract_id(basic_headers):
    """POST and GET contracts by oa_contract_id."""
    account_fixture = create_account()
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)

    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract_body = ows_abacus_contract_client.generate_contract_body(
        contract_name,
        account_fixture['account_id']
    )
    oa_contract_id_1 = str(randint(100000, 999999))
    contract_body['oa_contract_id'] = oa_contract_id_1
    response_post = ows_abacus_contract_client.post_contract(contract_body)
    assert response_post.status_code == 201

    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract_body = ows_abacus_contract_client.generate_contract_body(
        contract_name,
        account_fixture['account_id']
    )
    oa_contract_id_2 = str(randint(100000, 999999))
    contract_body['oa_contract_id'] = oa_contract_id_2
    response_post = ows_abacus_contract_client.post_contract(contract_body)
    assert response_post.status_code == 201

    response_get = ows_abacus_contract_client\
        .get_contracts_by_oa_contract_id([oa_contract_id_1])
    assert response_get.status_code == 200
    assert len(response_get.json()) == 1
    assert str(response_get.json()[0]['oa_contract_id']) == oa_contract_id_1


@pytest.mark.jira('ACC-3720')
def test_post_contract_from_template(basic_headers):
    """Test POST /contract-template/{contract_template_id}/contract/."""
    # have to create contract template back since it gets deleted by fresh_db fixture
    CREATE_CONTRACT_TEMPLATE = """
        INSERT INTO royalty_accounting.contract_template (
            template_name,
            reference_signing_entity_id,
            run_controller_id,
            term_duration_year,
            contract_type,
            contract_terms,
            contract_exclusions,
            created_by,
            created_at,
            last_modified_by,
            last_modified
        ) VALUES (
            'GDA Template 1',
            1,
            null,
            1,
            'distribution',
            '[{
                "term_type": "label",
                "conditions": [{
                    "name": "GDA Fraudulent Streams",
                    "stores": [],
                    "priority": 1,
                    "countries": [],
                    "term_rate": 100,
                    "transaction_types": ["59"]
                }, {
                    "name": "GDA Revenue Transaction Types",
                    "stores": [],
                    "priority": 2,
                    "countries": [],
                    "term_rate": 85,
                    "transaction_types": ["1", "4", "5", "6", "7", "8", "9", "10", "12",
                        "13", "14", "15", "16", "17", "19", "20", "23", "25", "27",
                        "28", "29", "30", "39", "41", "42", "43", "45", "48", "51",
                        "52", "53", "54", "55", "56", "61", "62", "63", "66", "67",
                        "68", "69", "70"
                    ]
                }],
                "attachments": "[{vendor_id}]"
            }]',
            '{"stores": [], "countries": ["RUS"]}',
            'default_user_id',
            '2021-09-30 14:19:52',
            'default_user_id',
            '2021-09-30 14:19:52'
        )
    """
    db.engine.execute(CREATE_CONTRACT_TEMPLATE)

    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)
    account_fixture = create_account()
    contract_template_id = 1
    account_name = 'AWAL GDA'
    contract_body = {
        'account_id': account_fixture.get('account_id'),
        'account_name': account_name,
    }
    response_post = ows_abacus_contract_client.post_contract_from_template(
        contract_template_id, contract_body
    )
    assert response_post.status_code == 201
    assert response_post.json()['contract_name'] == account_name
    assert response_post.json()['reference_signing_entity_id'] == 1


@pytest.mark.jira('ACC-3912')
def test_post_duplicate_contract_term_attachments_error(basic_headers):
    """POST, GET and DELETE  /contract_terms/conditions endpoint."""
    account_fixture = create_account()
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)
    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract_body = ows_abacus_contract_client.generate_contract_body(
        contract_name,
        account_fixture['account_id'],
        'distribution'
    )
    response_post = ows_abacus_contract_client.post_contract(contract_body)
    assert response_post.status_code == 201
    contract_id = response_post.json()['contract_id']

    term = {
        'term_type': 'label',
        'attachments': ['1010', '2010'],
        'is_base_term': True
    }

    response_post_term = ows_abacus_contract_client.post_contract_term(
        contract_id, term)
    assert response_post_term.status_code == 201

    term = {
        'term_type': 'label',
        'attachments': ['1010'],
        'is_base_term': False
    }

    response_post_term = ows_abacus_contract_client.post_contract_term(
        contract_id, term)
    assert response_post_term.status_code == 400
    assert response_post_term.json()['message'] == \
        error.ERROR_ATTACHMENT_ALREADY_EXISTS.format(
            attachment=term['attachments'][0]
    )


@pytest.mark.jira('ACC-3912')
def test_put_duplicate_contract_term_attachments_error(basic_headers):
    """POST, GET and DELETE  /contract_terms/conditions endpoint."""
    account_fixture = create_account()
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)
    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract_body = ows_abacus_contract_client.generate_contract_body(
        contract_name,
        account_fixture['account_id'],
        'distribution'
    )
    response_post = ows_abacus_contract_client.post_contract(contract_body)
    assert response_post.status_code == 201
    contract_id = response_post.json()['contract_id']

    term = {
        'term_type': 'label',
        'attachments': ['1010', '2010'],
        'is_base_term': True
    }

    response_post_term = ows_abacus_contract_client.post_contract_term(
        contract_id, term)
    assert response_post_term.status_code == 201

    term = {
        'term_type': 'label',
        'attachments': ['3010', '4010'],
        'is_base_term': False
    }

    response_post_term = ows_abacus_contract_client.post_contract_term(
        contract_id, term)
    assert response_post_term.status_code == 201
    contract_term_id_2 = response_post_term.json()['contract_term_id']

    term_update = {
        'attachments': ['1010']
    }
    response_put_term = ows_abacus_contract_client \
        .put_contract_term(contract_term_id_2, term_update)
    assert response_put_term.status_code == 400
    assert response_put_term.json()['message'] == \
        error.ERROR_ATTACHMENT_ALREADY_EXISTS.format(
            attachment=term_update['attachments'][0]
    )


@pytest.mark.jira('ACC-3901')
def test_get_contract_terms_by_account_id(basic_headers):
    """GET contract terms by account_id."""
    account_fixture = create_account()
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)
    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract_body = ows_abacus_contract_client.generate_contract_body(
        contract_name,
        account_fixture['account_id'],
        'distribution'
    )
    response_post = ows_abacus_contract_client.post_contract(contract_body)
    assert response_post.status_code == 201
    contract_id = response_post.json()['contract_id']

    term = {
        'term_type': 'product',
        'attachments': ['4242', '2424'],
        'is_base_term': True
    }

    response_post_term = ows_abacus_contract_client.post_contract_term(
        contract_id, term)
    assert response_post_term.status_code == 201

    body = {'term_type': 'product', 'attachments': ['4242', '2424']}
    response_get = ows_abacus_contract_client.get_contract_terms_by_account_id(
        account_fixture['account_id'], body
    )
    assert response_get.status_code == 200
    response_body = response_get.json()[0]
    assert response_body['term_type'] == term['term_type']
    assert response_body['attachments'] == term['attachments']
    assert response_body['is_base_term'] == term['is_base_term']


@pytest.mark.skip(reason='This endpoint is deprecated; skip failing tests')
@pytest.mark.jira('ACC-3933')
def test_get_contract_vat_info_by_contract_id(
    basic_headers,
    create_account_fixture,
    create_contract_fixture,
    create_account_contract_fixture,
    create_account_tax_info_fixture
):
    """POST /contracts/vat-info endpoint."""
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)
    # this is defined in fixtures in conftest.py
    contract_id = 1
    response_get = ows_abacus_contract_client.get_contract_vat_info_by_contract_id(
        [contract_id]
    )
    assert response_get.status_code == 200
    assert len(response_get.json()) > 0
    assert response_get.json()[0] == {
        'supplier_tax_rate': '20.00',
        'account_id': 1,
        'country_of_tax_residence': 'GBR',
        'account_is_sba_signed': True,
        'contract_id': 1,
        'client_tax_rate': '20.00'
    }


@pytest.mark.jira('ACC-3721')
def test_get_contracts_by_list_of_contract_ids(
        basic_headers,
        create_account_fixture,
        create_contract_fixture
):
    """POST /contracts (acts as GET)."""
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)

    # defined in fixtures in conftest.py
    contract_id = 1

    res_get = ows_abacus_contract_client.get_contracts_by_list_of_contract_ids(
        [contract_id]
    )
    assert res_get.status_code == 200
    assert len(res_get.json()) > 0
    assert res_get.json()[0]['contract_name'] == 'Test contract'
    assert 'contract_id' in res_get.json()[0]
    assert 'contract_type' in res_get.json()[0]
    assert 'contract_name' in res_get.json()[0]
    assert 'oa_contract_id' in res_get.json()[0]
    assert 'term_start' in res_get.json()[0]
    assert 'sap_created_at' in res_get.json()[0]
    assert 'term_end' in res_get.json()[0]


@pytest.mark.jira('ACC-3721')
def test_get_contracts_by_account_id(
        basic_headers,
        create_account_fixture,
        create_contract_fixture,
        create_account_contract_fixture
):
    """GET /contracts/account/{account_id} ."""
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)

    # defined in fixtures in conftest.py
    account_id = 1

    res_get = ows_abacus_contract_client.get_contracts_by_account_id(account_id)
    assert res_get.status_code == 200
    assert len(res_get.json()['items']) > 0
    item = res_get.json()['items'][0]
    assert item['contract_name'] == 'Test contract'
    assert 'contract_id' in item
    assert 'contract_type' in item
    assert 'contract_name' in item
    assert 'oa_contract_id' in item
    assert 'term_start' in item
    assert 'sap_created_at' in item
    assert 'term_end' in item


@pytest.mark.jira('ACC-3721')
def test_get_contracts_by_list_of_account_ids(
        basic_headers,
        create_account_fixture,
        create_contract_fixture,
        create_account_contract_fixture
):
    """POST /contracts/accounts (acts like GET)."""
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)

    # defined in fixtures in conftest.py
    account_id = 1

    res_get = ows_abacus_contract_client.get_contracts_by_list_of_contract_ids(
        [account_id]
    )
    assert res_get.status_code == 200
    assert len(res_get.json()) > 0
    assert res_get.json()[0]['contract_name'] == 'Test contract'
    assert 'contract_id' in res_get.json()[0]
    assert 'contract_type' in res_get.json()[0]
    assert 'contract_name' in res_get.json()[0]
    assert 'oa_contract_id' in res_get.json()[0]
    assert 'term_start' in res_get.json()[0]
    assert 'sap_created_at' in res_get.json()[0]
    assert 'term_end' in res_get.json()[0]


@pytest.mark.jira('ACC-7937')
def test_get_contract_by_account_id_dataloaded(
        basic_headers,
        create_account_fixture,
        create_contract_fixture,
        create_account_contract_fixture
):
    """POST /contracts/account/dataloader (acts like GET)."""
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)

    # defined in fixtures in conftest.py
    account_ids = [1, 1234]

    res_get = ows_abacus_contract_client.get_contracts_by_account_id_dataloaded(
        account_ids
    )
    assert res_get.status_code == 200
    assert len(res_get.json()) > 0
    first_record = res_get.json()[0].get('data')
    assert first_record[0]['contract_name'] == 'Test contract'
    assert 'contract_id' in first_record[0]
    assert 'contract_type' in first_record[0]
    assert 'contract_name' in first_record[0]
    assert 'oa_contract_id' in first_record[0]
    assert 'term_start' in first_record[0]
    assert 'sap_created_at' in first_record[0]
    assert 'term_end' in first_record[0]

    second_record = res_get.json()[1].get('data')
    assert second_record is None


@pytest.mark.jira('ACC-4902')
def test_post_get_legacy_contract(
        basic_headers,
        create_account_fixture,
        create_contract_fixture,
        create_account_contract_fixture
):
    """POST and GET /contract/{contract_id}/legacy-contract ."""
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)

    # defined in fixtures in conftest.py
    contract_id = 1

    body = {
        'oa_contract_id': 1
    }
    res_post = ows_abacus_contract_client.post_legacy_contract(
        contract_id, body
    )
    assert res_post.status_code == 201
    assert 'legacy_contract_id' in res_post.json()
    assert 'oa_contract_id' in res_post.json()
    assert res_post.json()['contract_id'] == contract_id

    res_get = ows_abacus_contract_client.get_legacy_contract(contract_id)
    assert res_get.status_code == 200
    assert 'legacy_contract_id' in res_post.json()
    assert 'oa_contract_id' in res_post.json()
    assert res_post.json()['contract_id'] == contract_id


@pytest.mark.jira('ACC-6116')
def test_delete_contract_term(
        basic_headers,
        create_schedule_fixtures
):
    """DELETE /contract-term/<term_id>/ ."""
    account_fixture = create_account()
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)

    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract_body = ows_abacus_contract_client.generate_contract_body(
        contract_name,
        account_fixture['account_id'],
        'distribution'
    )
    response_post = ows_abacus_contract_client.post_contract(contract_body)
    assert response_post.status_code == 201
    contract_id = response_post.json()['contract_id']

    term = {
        'contract_term_name': 'automation',
        'term_type': 'contributor_schedule',
        'attachments': ['1010', '2010'],
        'schedule_ids': ['1', '2'],
        'is_base_term': True
    }

    response_post_term = ows_abacus_contract_client.post_contract_term(
        contract_id, term)
    assert response_post_term.status_code == 201
    contract_term_id = response_post_term.json()['contract_term_id']

    get_terms = ows_abacus_contract_client.get_contract_term(contract_term_id)
    assert get_terms.status_code == 200
    assert get_terms.json()['contract_term_name'] == term['contract_term_name']

    delete_terms = ows_abacus_contract_client.delete_contract_term(contract_term_id)
    assert delete_terms.status_code == 204

    get_terms = ows_abacus_contract_client.get_contract_term(contract_term_id)
    assert get_terms.status_code == 404


@pytest.mark.jira('ACC-6459')
def test_get_reference_signing_entities(basic_headers):
    """GET /reference-signing-entities endpoints."""
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)

    res_get_all = ows_abacus_contract_client.get_reference_signing_entities()
    assert res_get_all.status_code == 200
    assert len(res_get_all.json()['items']) > 0

    items = res_get_all.json()['items']

    if items:
        random_index = random.randint(0, len(items) - 1)
        random_node = items[random_index]

        if 'reference_signing_entity_id' in random_node:
            reference_signing_entity_id = random_node['reference_signing_entity_id']
        else:
            print(
                "The selected node doesn't have an 'reference_signing_entity_id' key."
            )
    else:
        print("The 'items' array is empty.")

    res_get = ows_abacus_contract_client.get_reference_signing_entity_by_id(
        reference_signing_entity_id
    )
    assert res_get.status_code == 200
    assert res_get.json() in res_get_all.json()['items']


@pytest.mark.jira('ACC-4334')
def test_get_reference_payment_entities(basic_headers):
    """GET /reference-payment-entities endpoints."""
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)

    res_get_all = ows_abacus_contract_client.get_reference_payment_entities()
    assert res_get_all.status_code == 200
    assert len(res_get_all.json()['items']) > 0

    items = res_get_all.json()['items']

    if items:
        random_index = random.randint(0, len(items) - 1)
        random_node = items[random_index]

        if 'reference_payment_entity_id' in random_node:
            reference_payment_entity_id = random_node['reference_payment_entity_id']
        else:
            print(
                "The selected node doesn't have an 'reference_payment_entity_id' key."
            )
    else:
        print("The 'items' array is empty.")

    res_get = ows_abacus_contract_client.get_reference_payment_entity_by_id(
        reference_payment_entity_id
    )
    assert res_get.status_code == 200
    assert res_get.json() in res_get_all.json()['items']


@pytest.mark.jira('ACC-7404', 'ACC-7411')
def test_terminate_reactivate_contract(
        basic_headers,
        create_account_fixture,
        create_contract_fixture,
        create_contract_lifecycle_schedule_detail_fixture
):
    """Contract lifecycle endpoints."""
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)
    contract_id = 1

    post_body = [
        {
            'renewal_type': 'continuously_active',
            'termination_notice_detail_interval': 90,
            'termination_notice_detail_type': 'day'
        }
    ]

    res_post = ows_abacus_contract_client.post_contract_lifecycle_schedules(
        contract_id, post_body
    )
    assert res_post.status_code == 201
    contract_lifecycle_schedule_id = \
        res_post.json()[0]['contract_lifecycle_schedule_id']

    post_body = {
        'lifecycle_term_start': '2024-07-03'
    }

    res_post = ows_abacus_contract_client.post_contract_lifecycle(
        contract_id, contract_lifecycle_schedule_id, post_body
    )
    assert res_post.status_code == 201

    res_get = ows_abacus_contract_client.get_contract_lifecycle_by_contract_id(
        contract_id
    )
    assert res_get.status_code == 200
    assert res_get.json()['lifecycle_status'] == 'active'

    put_body = {
        'termination_effective': '2024-08-26',
        'termination_notice_received': None,
    }

    res_put = ows_abacus_contract_client.put_contract_terminate(
        contract_id, put_body
    )
    assert res_put.status_code == 200

    res_get = ows_abacus_contract_client.get_contract_lifecycle_by_contract_id(
        contract_id
    )
    assert res_get.status_code == 200
    assert res_get.json()['lifecycle_status'] == 'terminated'

    res_put = ows_abacus_contract_client.put_reactivate_contract(
        contract_id
    )
    assert res_put.status_code == 200

    res_get = ows_abacus_contract_client.get_contract_lifecycle_by_contract_id(
        contract_id
    )
    assert res_get.status_code == 200
    assert res_get.json()['lifecycle_status'] == 'active'


def test_activable_activate_renewable_renew(
        basic_headers,
        create_account_fixture,
        create_contract_fixture,
        create_contract_lifecycle_schedule_detail_fixture
):
    """Contract lifecycle activate/renew endpoints."""
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)
    contract_id = 1

    post_body = [
        {
            'renewal_type': 'renew_periodically',
            'termination_notice_detail_interval': 90,
            'termination_notice_detail_type': 'day',
            'renewal_offset_detail_interval': '10',
            'renewal_offset_detail_type': 'day'
        },
        {
            'renewal_type': 'renew_periodically',
            'termination_notice_detail_interval': 90,
            'termination_notice_detail_type': 'day',
            'renewal_offset_detail_interval': '10',
            'renewal_offset_detail_type': 'day'
        }
    ]

    res_post = ows_abacus_contract_client.post_contract_lifecycle_schedules(
        contract_id, post_body
    )
    assert res_post.status_code == 201
    contract_lifecycle_schedule_id = \
        res_post.json()[0]['contract_lifecycle_schedule_id']

    post_body = {
        'lifecycle_term_start': '2024-07-03'
    }

    res_post = ows_abacus_contract_client.post_contract_lifecycle(
        contract_id, contract_lifecycle_schedule_id, post_body
    )
    assert res_post.status_code == 201
    contract_lifecycle_id = res_post.json()['contract_lifecycle_id']

    # activable -> activate
    res_get = ows_abacus_contract_client.get_activable_contract_lifecycles()
    assert res_get.status_code == 200
    assert len(res_get.json()['items']) == 1
    assert res_get.json()['items'][0]['contract_id'] == contract_id

    res_post = ows_abacus_contract_client.post_contract_lifecycles_activate(
        contract_id
    )
    assert res_post.status_code == 200

    # renewable -> renew
    res_get = ows_abacus_contract_client.get_renewable_contract_lifecycles()
    assert res_get.status_code == 200
    assert len(res_get.json()['items']) == 1
    assert res_get.json()['items'][0]['contract_id'] == contract_id

    res_post = ows_abacus_contract_client.post_contract_lifecycles_renew(
        contract_id
    )
    assert res_post.status_code == 200
    contract_lifecycle_renewed = res_post.json()[0]['contract_lifecycle_id']

    res_get = ows_abacus_contract_client.get_contract_lifecycle_by_contract_lifecycle_id( # noqa
        contract_lifecycle_id
    )
    # since lifecycle was renewed, contract_lifecycle_id is 'inactive' so it's 404
    assert res_get.status_code == 404

    res_get = ows_abacus_contract_client.get_contract_lifecycle_by_contract_lifecycle_id( # noqa
        contract_lifecycle_renewed
    )
    assert res_get.status_code == 200
    assert res_get.json()['contract_id'] == contract_id
    assert res_get.json()['lifecycle_status'] == 'active'


def test_terminable_terminate(
        basic_headers,
        create_account_fixture,
        create_contract_fixture,
        create_contract_lifecycle_schedule_detail_fixture
):
    """Contract lifecycle termination endpoints."""
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)
    contract_id = 1

    post_body = [
        {
            'renewal_type': 'continuously_active',
            'termination_notice_detail_interval': 90,
            'termination_notice_detail_type': 'day'
        }
    ]

    res_post = ows_abacus_contract_client.post_contract_lifecycle_schedules(
        contract_id, post_body
    )
    assert res_post.status_code == 201
    contract_lifecycle_schedule_id = \
        res_post.json()[0]['contract_lifecycle_schedule_id']

    post_body = {
        'lifecycle_term_start': '2024-07-03'
    }

    res_post = ows_abacus_contract_client.post_contract_lifecycle(
        contract_id, contract_lifecycle_schedule_id, post_body
    )
    assert res_post.status_code == 201

    update_db_field_value(
        table='contract_lifecycle',
        column='lifecycle_status',
        condition='contract_id = 1',
        new_value='to_be_terminated'
    )

    update_db_field_value(
        table='contract_lifecycle',
        column='termination_effective',
        condition='contract_id = 1',
        new_value='2024-07-06'
    )

    res_get = ows_abacus_contract_client.get_terrminable_contract_lifecycles()
    assert res_get.status_code == 200
    assert len(res_get.json()['items']) == 1
    assert res_get.json()['items'][0]['contract_id'] == contract_id

    res_post = ows_abacus_contract_client.post_contract_lifecycles_terminate(
        contract_id
    )
    assert res_post.status_code == 200
    contract_lifecycle_terminated = res_post.json()[0]['contract_lifecycle_id']

    res_get = ows_abacus_contract_client.get_contract_lifecycle_by_contract_lifecycle_id( # noqa
        contract_lifecycle_terminated
    )
    assert res_get.status_code == 200
    assert res_get.json()['contract_id'] == contract_id
    assert res_get.json()['lifecycle_status'] == 'terminated'


def test_mechanical_rates(
        basic_headers
):
    """GET mechanical_rates endpoints."""
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)

    res_get = ows_abacus_contract_client.get_mechanical_rates()
    assert res_get.status_code == 200
    items = res_get.json()['items']
    assert len(items) > 0

    random_item = random.choice(items)
    mech_rate_id = random_item['reference_mechanical_rate_id']

    res_get = ows_abacus_contract_client.get_mechanical_rate_by_id(mech_rate_id)
    assert res_get.status_code == 200
    assert res_get.json() == random_item


def test_get_transaction_types_groups_and_transaction_types(
        basic_headers
):
    """GET /reference-transaction-type-group/reference_transaction_type_group_transaction_types .""" # noqa
    ows_abacus_contract_client = ows_abacus_contract_api_client(basic_headers)
    res_get = ows_abacus_contract_client.get_transaction_types_groups_and_transaction_types() # noqa
    assert res_get.status_code == 200

    assert len(res_get.json()) > 0
    for i in res_get.json():
        assert 'reference_transaction_type_group_transaction_type_id' in i
        assert 'reference_transaction_type_group_id' in i
        assert 'reference_transaction_type_id' in i
        assert 'reference_transaction_type_group_admin' in i