"""Integration tests."""

import operator
from typing import Any, Dict

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

from tests.integration.conftest import (
    ows_abacus_account_api_client,
    ows_abacus_event_api_client,
    ows_ledger_api_client,
    ows_royalties_api_client,
)
from tests.integration.consts import api
from tests.integration.utils.db_helper import check_db_empty
from tests.integration.utils.generic_helper import (
    generate_ledger_event,
    generate_post_ledger_account_body,
    generate_random_string,
)


@pytest.mark.jira('ACC-2532')
def test_get_hello():
    """GET /hello ."""
    response = requests.get(api.HEALTH_CHECK)
    assert response.status_code == 200, '\nReason: {}\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-3763', 'ACC-3495')
def test_get_ledger_account_currency_balance(
    basic_headers,
    create_accounting_run,
    create_run_controller,
    create_account,
):
    """GET /ledger-account/account/{acc_id}/current-balance."""
    ows_ledger_client = ows_ledger_api_client(basic_headers)
    ows_royalties_client = ows_royalties_api_client(basic_headers)
    ows_abacus_client = ows_abacus_event_api_client(basic_headers)

    # defined in fixtures
    account_id = 1

    response_get_accounting_runs = ows_royalties_client.get_accounting_periods()
    assert response_get_accounting_runs.status_code == 200
    accounting_runs = response_get_accounting_runs.json()['items']
    open_period = next(
        (item for item in accounting_runs if item['closed_date'] is None), None
    )
    accounting_run_response = ows_royalties_client.get_accounting_period_runs(
        open_period['accounting_period_id']
    )
    assert accounting_run_response.status_code == 200
    accounting_run_response_data = accounting_run_response.json()['items']
    accounting_run_id = accounting_run_response_data[0]['accounting_run_id']

    ledger_event = generate_ledger_event(accounting_run_id)
    response_post_abacus_event = ows_abacus_client.post_abacus_event(ledger_event)
    assert response_post_abacus_event.status_code == 201
    abacus_event_id = response_post_abacus_event.json()['abacus_event_id']

    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract = ows_royalties_client.generate_contract_body(
        contract_name, 'distribution'
    )
    contract.update(account_id=account_id)
    response_post_contract = ows_royalties_client.post_contract(contract)
    assert response_post_contract.status_code == 201
    contract_id = response_post_contract.json()['contract_id']

    post_ledger_account_body = [
        generate_post_ledger_account_body(abacus_event_id, account_id, contract_id)
    ]

    response_post_ledger_account = ows_ledger_client.post_ledger_bulk(
        post_ledger_account_body
    )
    assert response_post_ledger_account.status_code == 201

    response_get_ledger_account_current_balance = (
        ows_ledger_client.get_ledger_account_current_balance(account_id)
    )
    account_current_balance = response_get_ledger_account_current_balance.json()
    assert response_get_ledger_account_current_balance.status_code == 200
    assert (
        account_current_balance['currency_code']
        == post_ledger_account_body[0]['currency_code']
    )
    assert float(account_current_balance['current_balance']) == float(
        post_ledger_account_body[0]['currency_amount']
    )


@pytest.mark.jira('ACC-3763', 'ACC-2577')
def test_post_get_ledger_bulk(
    basic_headers,
    create_run_controller,
    create_accounting_run,
    create_account,
):
    """POST GET /ledger endpoints."""
    ows_ledger_client = ows_ledger_api_client(basic_headers)
    ows_royalties_client = ows_royalties_api_client(basic_headers)
    ows_abacus_client = ows_abacus_event_api_client(basic_headers)

    # defined in fixtures
    account_id = 1

    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract = ows_royalties_client.generate_contract_body(
        contract_name, 'distribution'
    )
    contract.update(account_id=account_id)
    response_post_contract = ows_royalties_client.post_contract(contract)
    assert response_post_contract.status_code == 201
    contract_id = response_post_contract.json()['contract_id']

    response_get_accounting_runs = ows_royalties_client.get_accounting_periods()
    assert response_get_accounting_runs.status_code == 200
    accounting_runs = response_get_accounting_runs.json()['items']
    open_period = next(
        (item for item in accounting_runs if item['closed_date'] is None), None
    )
    accounting_period_id = open_period['accounting_period_id']
    accounting_run_response = ows_royalties_client.get_accounting_period_runs(
        accounting_period_id
    )
    assert accounting_run_response.status_code == 200

    ledger_event = generate_ledger_event(
        accounting_period_id, target_type='accounting_period'
    )
    response_post_abacus_event = ows_abacus_client.post_abacus_event(ledger_event)
    assert response_post_abacus_event.status_code == 201
    abacus_event_id = response_post_abacus_event.json()['abacus_event_id']

    post_ledger_account_body = [
        generate_post_ledger_account_body(abacus_event_id, account_id, contract_id)
    ]

    response_post_ledger_account = ows_ledger_client.post_ledger_bulk(
        post_ledger_account_body
    )
    assert response_post_ledger_account.status_code == 201

    response_get_ledger_account = ows_ledger_client.get_ledger_account(account_id)
    assert response_get_ledger_account.status_code == 200
    response_get_ledger_account_body = response_get_ledger_account.json()[0]
    assert response_get_ledger_account_body['account_id'] == account_id
    assert (
        response_get_ledger_account_body['transaction_type']
        == ledger_event['event_name']
    )
    assert 'accounting_period_id' in response_get_ledger_account_body
    assert (
        response_get_ledger_account_body['currency_code']
        == post_ledger_account_body[0]['currency_code']
    )
    assert (
        response_get_ledger_account_body['ending_balance']
        == post_ledger_account_body[0]['currency_amount']
    )
    assert 'currency_name' in response_get_ledger_account_body
    assert 'opening_balance' in response_get_ledger_account_body
    assert 'date' in response_get_ledger_account_body
    assert (
        response_get_ledger_account_body['amount']
        == post_ledger_account_body[0]['currency_amount']
    )


@pytest.mark.jira('ACC-2758')
def test_get_bulk_account_balance(
    basic_headers,
    create_accounting_run,
    create_run_controller,
    create_account,
):
    """GET /bulk/account-balance endpoint."""
    ows_ledger_client = ows_ledger_api_client(basic_headers)
    ows_royalties_client = ows_royalties_api_client(basic_headers)
    ows_abacus_client = ows_abacus_event_api_client(basic_headers)

    # defined in fixtures
    account_id = 1

    response_get_accounting_runs = ows_royalties_client.get_accounting_periods()
    assert response_get_accounting_runs.status_code == 200
    accounting_runs = response_get_accounting_runs.json()['items']
    open_period = next(
        (item for item in accounting_runs if item['closed_date'] is None), None
    )
    accounting_run_response = ows_royalties_client.get_accounting_period_runs(
        open_period['accounting_period_id']
    )
    assert accounting_run_response.status_code == 200
    accounting_run_response_data = accounting_run_response.json()['items']
    accounting_run_id = accounting_run_response_data[0]['accounting_run_id']

    ledger_event = generate_ledger_event(accounting_run_id)
    response_post_abacus_event = ows_abacus_client.post_abacus_event(ledger_event)
    assert response_post_abacus_event.status_code == 201
    abacus_event_id = response_post_abacus_event.json()['abacus_event_id']

    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract = ows_royalties_client.generate_contract_body(
        contract_name, 'distribution'
    )

    contract.update(account_id=account_id)
    response_post_contract = ows_royalties_client.post_contract(contract)
    assert response_post_contract.status_code == 201
    contract_id = response_post_contract.json()['contract_id']

    currency_amount = 4242
    post_ledger_account_body = [
        generate_post_ledger_account_body(
            abacus_event_id, account_id, contract_id, currency_amount=currency_amount
        )
    ]

    response_post_ledger_account = ows_ledger_client.post_ledger_bulk(
        post_ledger_account_body
    )
    assert response_post_ledger_account.status_code == 201

    response_get_accounts_balance = ows_ledger_client.get_bulk_accounts_balance()
    assert response_get_accounts_balance.status_code == 200
    assert len(response_get_accounts_balance.json()) > 0
    assert (
        next(
            filter(
                lambda elem: elem['account_id'] == account_id,
                response_get_accounts_balance.json(),
            )
        )
        is not None
    )

    params = {'account_ids': account_id}
    response_with_filter = ows_ledger_client.get_bulk_accounts_balance(params)
    assert response_with_filter.status_code == 200
    assert len(response_with_filter.json()) == 1

    params = {'balance_min': currency_amount, 'balance_max': currency_amount}
    response_with_filter = ows_ledger_client.get_bulk_accounts_balance(params)
    assert response_with_filter.status_code == 200
    assert len(response_with_filter.json()) > 0
    for item in response_with_filter.json():
        assert float(item['current_balance']) == currency_amount


@pytest.mark.jira('ACC-3933', 'ACC-3934')
def test_post_get_accounting_run_balance(
    basic_headers, create_account, create_accounting_run, create_run_controller
):
    """POST and GET /ledger-accounting-run-balance endpoints."""
    ows_ledger_client = ows_ledger_api_client(basic_headers)
    ows_royalties_client = ows_royalties_api_client(basic_headers)

    # defined in fixtures
    account_id = 1

    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract = ows_royalties_client.generate_contract_body(
        contract_name, 'distribution'
    )

    contract.update(account_id=account_id)
    response_post_contract = ows_royalties_client.post_contract(contract)
    assert response_post_contract.status_code == 201
    contract_id = response_post_contract.json()['contract_id']

    params_post = [
        {
            'abacus_event_id': 17,
            'adjusted_net_revenue': '-12.10',
            'contract_id': contract_id,
            'currency_code': 'USD',
            'distribution_fee': '-22.00',
            'total_gross_revenue_amount': '67.90',
            'mechanical_deduction_total': '90.00',
            'mechanical_deduction_admin_fee_total': '12.00',
            'total_net_revenue_amount': '89.90',
        }
    ]

    response_post = ows_ledger_client.post_acc_run_balance_bulk('1337', params_post)
    assert response_post.status_code == 201

    response_get = ows_ledger_client.get_acc_run_balance(1337)
    assert response_get.status_code == 200
    response_get_body = response_get.json()['items'][0]
    assert response_get_body['abacus_event_id'] == params_post[0]['abacus_event_id']
    assert response_get_body['contract_id'] == params_post[0]['contract_id']
    assert response_get_body['distribution_fee'] == params_post[0]['distribution_fee']
    assert (
        response_get_body['total_gross_revenue_amount']
        == params_post[0]['total_gross_revenue_amount']
    )
    assert (
        response_get_body['mechanical_deduction_total']
        == params_post[0]['mechanical_deduction_total']
    )
    assert (
        response_get_body['mechanical_deduction_admin_fee_total']
        == params_post[0]['mechanical_deduction_admin_fee_total']
    )
    assert (
        response_get_body['total_net_revenue_amount']
        == params_post[0]['total_net_revenue_amount']
    )
    assert (
        response_get_body['adjusted_net_revenue']
        == params_post[0]['adjusted_net_revenue']
    )


@pytest.mark.jira('ACC-3923')
def test_get_reference_vat_rate(basic_headers):
    """GET /reference-vat-rate ."""
    ows_ledger_client = ows_ledger_api_client(basic_headers)

    vat_rate = {
        'vat_type': 'client',
        'country_of_tax_residence': 'GBR',
        'tax_rate': 42.00,
    }

    query = """
        INSERT INTO reference_vat_rate (
            vat_type,
            country_of_tax_residence,
            is_sba_signed,
            is_tax_applicable,
            transaction_type,
            tax_rate,
            effective_date,
            created_by,
            created_at,
            last_modified_by,
            last_modified
        ) VALUES (
            '{vat_type}',
            '{country_of_tax_residence}',
            1,
            1,
            Null,
            {tax_rate},
            '2021-10-03',
            'QA',
            '2021-10-14',
            'QA',
            '2021-10-14'
        )
    """
    db.engine.execute(query.format(**vat_rate))

    response_get = ows_ledger_client.get_reference_vat_rate()
    assert response_get.status_code == 200
    response_item = response_get.json()['items'][0]
    assert response_item['vat_type'] == vat_rate['vat_type']
    assert (
        response_item['country_of_tax_residence']
        == vat_rate['country_of_tax_residence']
    )
    assert float(response_item['tax_rate']) == vat_rate['tax_rate']


@pytest.mark.jira('ACC-3389')
def test_get_ledger_accounts_by_period_id(
    basic_headers, create_account, create_accounting_run, create_run_controller
):
    """GET /ledger-account/accounting-period/{acc_period_id}/accounts endpoint."""
    accounting_period_id = 1  # this is created in create_db_fixtures.py
    ows_ledger_client = ows_ledger_api_client(basic_headers)
    ows_royalties_client = ows_royalties_api_client(basic_headers)
    ows_abacus_client = ows_abacus_event_api_client(basic_headers)

    # defined in fixtures
    account_id = 1

    response_get_accounting_runs = ows_royalties_client.get_accounting_periods()
    assert response_get_accounting_runs.status_code == 200
    accounting_runs = response_get_accounting_runs.json()['items']
    open_period = next(
        (item for item in accounting_runs if item['closed_date'] is None), None
    )
    accounting_run_response = ows_royalties_client.get_accounting_period_runs(
        open_period['accounting_period_id']
    )
    assert accounting_run_response.status_code == 200
    accounting_run_response_data = accounting_run_response.json()['items']
    accounting_run_id = accounting_run_response_data[0]['accounting_run_id']

    ledger_event = generate_ledger_event(
        accounting_run_id, target_type='accounting_run'
    )
    response_post_abacus_event = ows_abacus_client.post_abacus_event(ledger_event)
    assert response_post_abacus_event.status_code == 201
    abacus_event_id = response_post_abacus_event.json()['abacus_event_id']

    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract = ows_royalties_client.generate_contract_body(
        contract_name, 'distribution'
    )

    contract.update(account_id=account_id)
    response_post_contract = ows_royalties_client.post_contract(contract)
    assert response_post_contract.status_code == 201
    contract_id = response_post_contract.json()['contract_id']

    post_ledger_account_body = [
        generate_post_ledger_account_body(abacus_event_id, account_id, contract_id)
    ]

    response_post_ledger_account = ows_ledger_client.post_ledger_bulk(
        post_ledger_account_body
    )
    assert response_post_ledger_account.status_code == 201

    response_get_accounts_by_period_id = (
        ows_ledger_client.get_ledger_account_by_acc_period(accounting_period_id)
    )
    assert response_get_accounts_by_period_id.status_code == 200
    account = response_get_accounts_by_period_id.json()['items'][0]
    assert account['account_id'] == account_id
    assert account['currency_code'] == post_ledger_account_body[0]['currency_code']
    assert account['abacus_event_id'] == post_ledger_account_body[0]['abacus_event_id']
    assert account['currency_amount'] == post_ledger_account_body[0]['currency_amount']


@pytest.mark.jira('ACC-3933')
def test_bulk_create_ledger_accounting_run_vat_records(
    basic_headers, create_account, create_accounting_run, create_run_controller
):
    """POST /ledger-accounting-run-vat/bulk ."""
    accounting_period_id = 1  # this is created in create_db_fixtures.py
    ows_royalties_client = ows_royalties_api_client(basic_headers)
    ows_abacus_client = ows_abacus_event_api_client(basic_headers)

    # defined in fixtures
    account_id = 1

    response_get_accounting_runs = ows_royalties_client.get_accounting_periods()
    assert response_get_accounting_runs.status_code == 200
    accounting_runs = response_get_accounting_runs.json()['items']
    open_period = next(
        (item for item in accounting_runs if item['closed_date'] is None), None
    )
    accounting_run_response = ows_royalties_client.get_accounting_period_runs(
        open_period['accounting_period_id']
    )
    assert accounting_run_response.status_code == 200
    accounting_run_response_data = accounting_run_response.json()['items']
    accounting_run_id = accounting_run_response_data[0]['accounting_run_id']

    ledger_event = generate_ledger_event(accounting_run_id)
    response_post_abacus_event = ows_abacus_client.post_abacus_event(ledger_event)
    assert response_post_abacus_event.status_code == 201
    abacus_event_id = response_post_abacus_event.json()['abacus_event_id']

    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract = ows_royalties_client.generate_contract_body(
        contract_name, 'distribution'
    )

    contract.update(account_id=account_id)
    response_post_contract = ows_royalties_client.post_contract(contract)
    assert response_post_contract.status_code == 201
    contract_id = response_post_contract.json()['contract_id']

    ows_ledger_client = ows_ledger_api_client(basic_headers)
    body = [
        {
            'accounting_run_id': accounting_run_id,
            'abacus_event_id': abacus_event_id,
            'contract_id': contract_id,
            'currency_code': 'USD',
            'country_of_tax_residence': 'USA',
            'exempt_reason': 'US citizenship',
        },
        {
            'accounting_run_id': accounting_run_id,
            'abacus_event_id': abacus_event_id,
            'contract_id': contract_id,
            'currency_code': 'GBP',
            'country_of_tax_residence': 'GBR',
            'gross_revenue': 200.00,
            'net_revenue': 180.00,
            'distribution_fee': 2.00,
            'gross_vat_rate': 20.00,
            'distribution_vat_rate': 20.00,
            'gross_vat': 20.00,
            'distribution_vat': 0.25,
            'adjusted_net_revenue': 175.00,
        },
    ]
    response_post = ows_ledger_client.post_ledger_accounting_run_vat(body)
    assert response_post.status_code == 201
    assert response_post.json()['total_count'] == 2
    items = response_post.json()['items']
    for i in items:
        del i['ledger_accounting_run_vat_id']
    assert sorted(items, key=lambda x: x['currency_code']) == [
        {
            'accounting_run_id': accounting_run_id,
            'abacus_event_id': abacus_event_id,
            'contract_id': contract_id,
            'currency_code': 'GBP',
            'country_of_tax_residence': 'GBR',
            'gross_revenue': '200.00',
            'net_revenue': '180.00',
            'distribution_fee': '2.00',
            'gross_vat_rate': '20.00',
            'distribution_vat_rate': '20.00',
            'gross_vat': '20.00',
            'distribution_vat': '0.25',
            'adjusted_net_revenue': '175.00',
            'exempt_reason': None,
        },
        {
            'accounting_run_id': accounting_run_id,
            'abacus_event_id': abacus_event_id,
            'contract_id': contract_id,
            'currency_code': 'USD',
            'country_of_tax_residence': 'USA',
            'gross_revenue': None,
            'net_revenue': None,
            'distribution_fee': None,
            'gross_vat_rate': None,
            'distribution_vat_rate': None,
            'gross_vat': None,
            'distribution_vat': None,
            'adjusted_net_revenue': None,
            'exempt_reason': 'US citizenship',
        },
    ]

    response_get = ows_ledger_client.get_ledger_accounting_run_vat_period_overview(
        accounting_period_id
    )
    assert response_get.status_code == 200
    assert len(response_get.json()) == 2


@pytest.mark.jira('ACC-3931')
def test_get_accounting_run_vat_by_period_id_and_vat_category(
    basic_headers, create_account, create_accounting_run, create_run_controller
):
    """/ledger-accounting-run-vat/accounting-period/<period>/vat-category/<category>."""
    accounting_period_id = 1  # this is created in create_db_fixtures.py
    ows_royalties_client = ows_royalties_api_client(basic_headers)
    ows_abacus_client = ows_abacus_event_api_client(basic_headers)

    # defined in fixtures
    account_id = 1
    account_name = 'integration tests'

    response_get_accounting_runs = ows_royalties_client.get_accounting_periods()
    assert response_get_accounting_runs.status_code == 200
    accounting_runs = response_get_accounting_runs.json()['items']
    open_period = next(
        (item for item in accounting_runs if item['closed_date'] is None), None
    )
    accounting_run_response = ows_royalties_client.get_accounting_period_runs(
        open_period['accounting_period_id']
    )
    assert accounting_run_response.status_code == 200
    accounting_run_response_data = accounting_run_response.json()['items']
    accounting_run_id = accounting_run_response_data[0]['accounting_run_id']

    ledger_event = generate_ledger_event(accounting_run_id)
    response_post_abacus_event = ows_abacus_client.post_abacus_event(ledger_event)
    assert response_post_abacus_event.status_code == 201
    abacus_event_id = response_post_abacus_event.json()['abacus_event_id']

    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract = ows_royalties_client.generate_contract_body(
        contract_name, 'distribution'
    )

    contract.update(account_id=account_id)
    response_post_contract = ows_royalties_client.post_contract(contract)
    assert response_post_contract.status_code == 201
    contract_id = response_post_contract.json()['contract_id']

    ows_ledger_client = ows_ledger_api_client(basic_headers)
    body = [
        {
            'accounting_run_id': accounting_run_id,
            'abacus_event_id': abacus_event_id,
            'contract_id': contract_id,
            'currency_code': 'USD',
            'country_of_tax_residence': 'USA',
            'exempt_reason': 'US citizenship',
        },
        {
            'accounting_run_id': accounting_run_id,
            'abacus_event_id': abacus_event_id,
            'contract_id': contract_id,
            'currency_code': 'GBP',
            'country_of_tax_residence': 'GBR',
            'gross_revenue': 200.00,
            'net_revenue': 180.00,
            'distribution_fee': 2.00,
            'gross_vat_rate': 20.00,
            'distribution_vat_rate': 20.00,
            'gross_vat': 20.00,
            'distribution_vat': 0.25,
            'adjusted_net_revenue': 175.00,
        },
    ]
    response_post = ows_ledger_client.post_ledger_accounting_run_vat(body)
    assert response_post.status_code == 201
    assert response_post.json()['total_count'] == 2

    response_get = ows_ledger_client.get_acc_run_vat_by_period_and_category(
        accounting_period_id, 'vat_exempt'
    )
    assert response_get.status_code == 200
    item = response_get.json()['items'][0]
    item.pop('ledger_accounting_run_vat_id', None)
    assert item == {
        'accounting_run_id': accounting_run_id,
        'abacus_event_id': abacus_event_id,
        'accounting_period_id': accounting_period_id,
        'contract_id': contract_id,
        'currency_code': 'USD',
        'country_of_tax_residence': 'USA',
        'gross_revenue': None,
        'net_revenue': None,
        'distribution_fee': None,
        'gross_vat_rate': None,
        'distribution_vat_rate': None,
        'gross_vat': None,
        'distribution_vat': None,
        'adjusted_net_revenue': None,
        'exempt_reason': 'US citizenship',
        'account_name': account_name,
        'contract_name': contract_name,
        'account_id': account_id,
    }

    response_get = ows_ledger_client.get_acc_run_vat_by_period_and_category(
        accounting_period_id, 'vat_applied', {'country_code': 'GBR'}
    )
    assert response_get.status_code == 200
    item = response_get.json()['items'][0]
    item.pop('ledger_accounting_run_vat_id', None)
    assert item == {
        'accounting_run_id': accounting_run_id,
        'abacus_event_id': abacus_event_id,
        'contract_id': contract_id,
        'accounting_period_id': accounting_period_id,
        'currency_code': 'GBP',
        'country_of_tax_residence': 'GBR',
        'gross_revenue': '200.00',
        'net_revenue': '180.00',
        'distribution_fee': '2.00',
        'gross_vat_rate': '20.00',
        'distribution_vat_rate': '20.00',
        'gross_vat': '20.00',
        'distribution_vat': '0.25',
        'adjusted_net_revenue': '175.00',
        'exempt_reason': None,
        'account_name': account_name,
        'contract_name': contract_name,
        'account_id': account_id,
    }


@pytest.mark.jira('ACC-3931')
def test_get_ledger_accounting_run_balance_for_a_period(
    basic_headers, create_account, create_accounting_run, create_run_controller
):
    """/ledger-accounting-run-balance/accounting-period/<prd>/vat-category/<cat>."""
    ows_royalties_client = ows_royalties_api_client(basic_headers)
    ows_abacus_client = ows_abacus_event_api_client(basic_headers)

    # defined in fixtures
    account_id = 1
    accounting_period_id = 1

    query = """
    INSERT INTO account_payment_term(
        account_payment_term_id,
        account_id,
        currency_code,
        payment_minimum,
        payment_entity_id,
        payment_schedule,
        created_by,
        created_at,
        last_modified_by,
        last_modified
    ) VALUES (
        1,
        {},
        'USD',
        42.00,
        1,
        null,
        'QA',
        NOW(),
        'QA',
        NOW()
    );""".format(account_id)
    db.engine.execute(query)

    response_get_accounting_runs = ows_royalties_client.get_accounting_periods()
    assert response_get_accounting_runs.status_code == 200
    accounting_runs = response_get_accounting_runs.json()['items']
    open_period = next(
        (item for item in accounting_runs if item['closed_date'] is None), None
    )
    accounting_run_response = ows_royalties_client.get_accounting_period_runs(
        open_period['accounting_period_id']
    )
    assert accounting_run_response.status_code == 200
    accounting_run_response_data = accounting_run_response.json()['items']
    accounting_run_id = accounting_run_response_data[1]['accounting_run_id']

    ledger_event = generate_ledger_event(accounting_run_id)
    response_post_abacus_event = ows_abacus_client.post_abacus_event(ledger_event)
    assert response_post_abacus_event.status_code == 201
    abacus_event_id = response_post_abacus_event.json()['abacus_event_id']

    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract = ows_royalties_client.generate_contract_body(
        contract_name, 'distribution'
    )

    contract.update(account_id=account_id)
    response_post_contract = ows_royalties_client.post_contract(contract)
    assert response_post_contract.status_code == 201, (
        f'Failed to create contract: {response_post_contract.json()}'
    )
    contract_id = response_post_contract.json()['contract_id']

    ows_ledger_client = ows_ledger_api_client(basic_headers)
    body = [
        {
            'accounting_run_id': accounting_run_id,
            'abacus_event_id': abacus_event_id,
            'contract_id': contract_id,
            'currency_code': 'USD',
            'country_of_tax_residence': 'USA',
            'exempt_reason': 'US citizenship',
        }
    ]
    response_post = ows_ledger_client.post_ledger_accounting_run_vat(body)
    assert response_post.status_code == 201

    query = """
    INSERT INTO royalty_accounting.ledger_accounting_run_balance(
        accounting_run_id,
        abacus_event_id,
        contract_id,
        currency_code,
        total_gross_revenue_amount,
        total_net_revenue_amount,
        mechanical_deduction_total,
        mechanical_deduction_admin_fee_total,
        adjusted_net_revenue,
        distribution_fee,
        created_at,
        created_by,
        last_modified,
        last_modified_by
    ) VALUES (
        {accounting_run_id},
        {abacus_event_id},
        {contract_id},
        'USD',
        42.00,
        24.00,
        18.00,
        66.00,
        -60.00,
        18.00,
        '2021-11-09 04:45:06',
        'VZ',
        '2021-11-09 04:45:10',
        'VZ'
    )"""
    values = {
        'accounting_run_id': accounting_run_id,
        'abacus_event_id': abacus_event_id,
        'contract_id': contract_id,
    }
    db.engine.execute(query.format(**values))

    query = """
        INSERT INTO account_tax_info (
            account_id,
            country_of_tax_residence,
            is_sba_signed,
            is_vat_exempt,
            created_by,
            created_at,
            last_modified_by,
            last_modified
        ) VALUES (
            {account_id},
            'USA',
            0,
            0,
            'VZ',
            '2021-11-09 04:46:11',
            'VZ',
            '2021-11-09 04:46:14'
        )
    """
    values = {'account_id': account_id}
    db.engine.execute(query.format(**values))

    response_get = (
        ows_ledger_client.get_ledger_accounting_run_balance_by_period_and_category(
            accounting_period_id, 'vat_exempt'
        )
    )
    assert response_get.status_code == 200
    items = response_get.json()['items']
    assert len(items) == 1
    assert items[0]['accounting_run_id'] == accounting_run_id
    assert items[0]['abacus_event_id'] == abacus_event_id
    assert items[0]['contract_id'] == contract_id


@pytest.mark.jira('ACC-4574')
def test_post_reserves_taken_record_exists_error(
    basic_headers, create_event_fixtures, create_run_controller
):
    """POST GET reserves_taken endpoints."""
    ows_ledger_client = ows_ledger_api_client(basic_headers)

    post_body = [
        {
            'abacus_event_id': 1,
            'contract_reserve_id': 1,
            'accounting_run_id': 1,
            'statement_period_id': 1,
            'currency_code': 'USD',
            'gross_sales': '100.00',
            'gross_returns': '-50.00',
            'net_revenue': '150.00',
            'reserve_amount': '-60.00',
            'net_revenue_after_reserve': '90.00',
        }
    ]

    res_post = ows_ledger_client.post_reserve_taken_bulk(post_body)
    assert res_post.status_code == 201

    res_get = ows_ledger_client.get_reserves_taken_by_run_id(
        post_body[0]['accounting_run_id']
    )
    assert res_get.status_code == 200
    expected_results = res_get.json()['items'][0]
    expected_results.pop('ledger_reserve_taken_id')
    expected_results.pop('account_id')
    expected_results.pop('contract_id')
    assert post_body[0] == expected_results

    res_post = ows_ledger_client.post_reserve_taken_bulk(post_body)
    assert res_post.status_code == 400
    assert 'already exists' in res_post.json()['message']


@pytest.mark.jira('ACC-4574')
def test_post_reserves_taken_duplicate_records_error(
    basic_headers, create_event_fixtures, create_run_controller
):
    """POST GET reserves_taken endpoints."""
    ows_ledger_client = ows_ledger_api_client(basic_headers)

    post_body = [
        {
            'abacus_event_id': 1,
            'contract_reserve_id': 1,
            'accounting_run_id': 1,
            'statement_period_id': 1,
            'currency_code': 'USD',
            'gross_sales': '100.00',
            'gross_returns': '-50.00',
            'net_revenue': '150.00',
            'reserve_amount': '-60.00',
            'net_revenue_after_reserve': '90.00',
        },
        {
            'abacus_event_id': 1,
            'contract_reserve_id': 1,
            'accounting_run_id': 1,
            'statement_period_id': 1,
            'currency_code': 'USD',
            'gross_sales': '100.00',
            'gross_returns': '-50.00',
            'net_revenue': '150.00',
            'reserve_amount': '-60.00',
            'net_revenue_after_reserve': '90.00',
        },
    ]

    res_post = ows_ledger_client.post_reserve_taken_bulk(post_body)
    assert res_post.status_code == 400
    assert 'duplicate records' in res_post.json()['message']


@pytest.mark.jira('ACC-4575')
def test_post_get_reserve_release_schedule(
    basic_headers, create_account, create_event_fixtures
):
    """POST and GET reserve_release_schedule endpoints."""
    ows_ledger_client = ows_ledger_api_client(basic_headers)

    # created upon spinning up the docker stack
    statement_period_id = 300

    post_body = [
        {
            'abacus_event_id': 1,
            'contract_reserve_id': 1,
            'accounting_run_id': 1,
            'statement_period_id': 1,
            'currency_code': 'USD',
            'gross_sales': '100.00',
            'gross_returns': '-50.00',
            'net_revenue': '150.00',
            'reserve_amount': '-60.00',
            'net_revenue_after_reserve': '90.00',
        }
    ]

    res_post = ows_ledger_client.post_reserve_taken_bulk(post_body)
    assert res_post.status_code == 201

    post_schedule_body = [
        {
            'abacus_event_id': 1,
            'account_id': 1,
            'taken_statement_period_id': statement_period_id,
            'release_statement_period_id': statement_period_id,
            'ledger_reserve_taken_id': 1,
            'currency_code': 'USD',
            'installment_amount': '-1500.11',
            'outstanding_amount_after_installment': '-2100.01',
            'early_release_date': None,
        }
    ]

    res_post = ows_ledger_client.post_reserve_release_schedule(post_schedule_body)
    assert res_post.status_code == 201

    res_get = ows_ledger_client.get_reserve_release_schedule(statement_period_id)
    assert res_get.status_code == 200

    post_schedule_body[0]['ledger_reserve_release_schedule_id'] = 1
    post_schedule_body[0]['ledger_reserve_taken_id'] = 1
    post_schedule_body[0]['contract_id'] = 1
    assert res_get.json() == post_schedule_body


@pytest.mark.jira('ACC-4575', 'ACC-5439')
def test_post_reserve_release_schedule_entry_exists_error(
    basic_headers, create_account, create_event_fixtures
):
    """POST reserve_release_schedule endpoint error if entry exists."""
    ows_ledger_client = ows_ledger_api_client(basic_headers)

    # created upon spinning up the docker stack
    statement_period_id = 300

    post_body = [
        {
            'abacus_event_id': 1,
            'contract_reserve_id': 1,
            'accounting_run_id': 1,
            'statement_period_id': 1,
            'currency_code': 'USD',
            'gross_sales': '100.00',
            'gross_returns': '-50.00',
            'net_revenue': '150.00',
            'reserve_amount': '-60.00',
            'net_revenue_after_reserve': '90.00',
        }
    ]

    res_post = ows_ledger_client.post_reserve_taken_bulk(post_body)
    assert res_post.status_code == 201

    post_schedule_body = [
        {
            'abacus_event_id': 1,
            'account_id': 1,
            'taken_statement_period_id': statement_period_id,
            'release_statement_period_id': statement_period_id,
            'ledger_reserve_taken_id': 1,
            'currency_code': 'USD',
            'installment_amount': '-1500.11',
            'outstanding_amount_after_installment': '-2100.01',
        }
    ]

    res_post = ows_ledger_client.post_reserve_release_schedule(post_schedule_body)
    assert res_post.status_code == 201

    res_get = ows_ledger_client.get_reserve_release_schedule(statement_period_id)
    assert res_get.status_code == 200

    post_schedule_body[0]['ledger_reserve_taken_id'] = 1

    res_post = ows_ledger_client.post_reserve_release_schedule(post_schedule_body)
    assert res_post.status_code == 409
    assert 'already exists' in res_post.json()['message']


@pytest.mark.jira('ACC-4575', 'ACC-5440')
def test_post_reserve_release_schedule_duplicate_error(
    basic_headers, create_account, create_event_fixtures
):
    """POST reserve_release_schedule error if duplicate entries."""
    ows_ledger_client = ows_ledger_api_client(basic_headers)

    # created upon spinning up the docker stack
    statement_period_id = 300

    post_body = [
        {
            'abacus_event_id': 1,
            'contract_reserve_id': 1,
            'accounting_run_id': 1,
            'statement_period_id': 1,
            'currency_code': 'USD',
            'gross_sales': '100.00',
            'gross_returns': '-50.00',
            'net_revenue': '150.00',
            'reserve_amount': '-60.00',
            'net_revenue_after_reserve': '90.00',
        }
    ]

    res_post = ows_ledger_client.post_reserve_taken_bulk(post_body)
    assert res_post.status_code == 201

    post_schedule_body = [
        {
            'abacus_event_id': 1,
            'account_id': 1,
            'taken_statement_period_id': statement_period_id,
            'release_statement_period_id': statement_period_id,
            'ledger_reserve_taken_id': 1,
            'currency_code': 'USD',
            'installment_amount': '-1500.11',
            'outstanding_amount_after_installment': '-2100.01',
        },
        {
            'abacus_event_id': 1,
            'account_id': 1,
            'taken_statement_period_id': statement_period_id,
            'release_statement_period_id': statement_period_id,
            'ledger_reserve_taken_id': 1,
            'currency_code': 'USD',
            'installment_amount': '-1500.11',
            'outstanding_amount_after_installment': '-2100.01',
        },
    ]

    res_post = ows_ledger_client.post_reserve_release_schedule(post_schedule_body)
    assert res_post.status_code == 400
    assert 'duplicate records with fields' in res_post.json()['message']


@pytest.mark.jira('ACC-4597')
def test_post_ledger_adjustment_applied_bulk(
    basic_headers,
    create_account,
    create_event_fixtures,
    create_worksheet_adjustment_detail,
):
    """POST /adjustments_applied/bulk endpoint."""
    ows_ledger_client = ows_ledger_api_client(basic_headers)

    # created upon spinning up the docker stack
    statement_period_id = 300

    post_body = [
        {
            'abacus_event_id': 1,
            'account_id': 1,
            'contract_id': 1,
            'statement_period_id': statement_period_id,
            'ledger_adjustment_id': 1,
            'worksheet_adjustment_id': 1,
            'adjustment_currency_code': 'USD',
            'adjustment_amount': '1500.00',
            'adjustment_amount_payee_currency': '1362.20',
            'adjustment_payee_currency_code': 'GBP',
            'details': [
                {
                    'ledger_adjustment_detail_id': 1,
                    'worksheet_adjustment_id': 1,
                    'worksheet_adjustment_detail_id': 1,
                    'adjustment_currency_code': 'USD',
                    'adjustment_amount': '1500.00',
                    'adjustment_payee_currency_code': 'GBP',
                    'adjustment_amount_payee_currency': '1362.20',
                }
            ],
        }
    ]
    res = ows_ledger_client.post_ledger_adjustment_applied_bulk(post_body)
    assert res.status_code == 201
    assert res.json()['created'] == 1
    assert res.json()['filtered'] == 0

    res = ows_ledger_client.post_ledger_adjustment_applied_bulk(post_body)
    assert res.status_code == 201
    assert res.json()['created'] == 0
    assert res.json()['filtered'] == 1

    post_body_duplicate_details = [
        {
            'abacus_event_id': 1,
            'account_id': 1,
            'contract_id': 1,
            'statement_period_id': statement_period_id,
            'ledger_adjustment_id': 2,
            'worksheet_adjustment_id': 2,
            'adjustment_currency_code': 'USD',
            'adjustment_amount': '2000.00',
            'adjustment_amount_payee_currency': '1816.29',
            'adjustment_payee_currency_code': 'GBP',
            'details': [
                {
                    'ledger_adjustment_detail_id': 2,
                    'worksheet_adjustment_id': 2,
                    'worksheet_adjustment_detail_id': 1,  # Same detail ID as before
                    'adjustment_currency_code': 'USD',
                    'adjustment_amount': '2000.00',
                    'adjustment_payee_currency_code': 'GBP',
                    'adjustment_amount_payee_currency': '1816.29',
                }
            ],
        }
    ]
    res = ows_ledger_client.post_ledger_adjustment_applied_bulk(
        post_body_duplicate_details
    )
    assert res.status_code == 201
    assert res.json()['created'] == 1
    assert res.json()['filtered'] == 0


@pytest.mark.jira('ACC-4549')
def test_get_pending_adjustments_by_statement_period(
    basic_headers,
    create_account,
    create_event_fixtures,
    create_ledger_adjustment,
    create_reference_adjustment_type_fixture,
    create_ledger_adjustment_detail_fixture,
    create_ledger_adjustment_adjustment_detail_fixture,
):
    """GET /ledger-adjustment/statement-period/<id>/pending'."""
    ows_ledger_client = ows_ledger_api_client(basic_headers)

    # created upon spinning up the docker stack
    statement_period_id = 300

    res = ows_ledger_client.get_pending_adjustments_by_statement_period(
        statement_period_id
    )
    assert res.status_code == 200
    item = res.json()['items'][0]

    # defined in fixtures
    assert item['account_id'] == 1
    assert item['contract_id'] == 1
    assert item['ledger_adjustment_id'] == 1
    assert item['abacus_event_id'] == 1
    assert item['adjustment_amount'] == '12.00'
    assert item['adjustment_currency_code'] == 'GBP'
    assert item['reference_adjustment_type_id'] == 1
    assert item['apply_to_statement_period_id'] == 300
    assert item['activity_statement_period_id'] == 300
    assert item['account_currency_code'] == 'USD'
    assert item['note'] == 'vz'
    assert item['details'][0] == {
        'ledger_adjustment_detail_id': 1,
        'account_id': 1,
        'contract_id': 1,
        'activity_statement_period_id': 300,
        'apply_to_statement_period_id': 300,
        'reference_adjustment_type_id': 1,
        'currency_code': 'USD',
        'amount': '123.00',
        'upc': '13',
        'distribution_type': 'digital',
        'note': None,
    }


@pytest.mark.jira('ACC-4399')
def test_get_ledger_adjustments(
    basic_headers,
    create_account,
    create_event_fixtures,
    create_ledger_adjustment,
    create_reference_adjustment_type_fixture,
    create_ledger_adjustment_detail_fixture,
    create_ledger_adjustment_adjustment_detail_fixture,
):
    """GET /ledger-adjustments/ ."""
    ows_ledger_client = ows_ledger_api_client(basic_headers)

    res = ows_ledger_client.get_ledger_adjustments()
    assert res.status_code == 200
    item = res.json()['items'][0]

    # defined in fixtures
    assert item['account_id'] == 1
    assert item['contract_id'] == 1
    assert item['ledger_adjustment_id'] == 1
    assert item['adjustment_amount'] == '12.00'
    assert item['adjustment_ledger_status'] == 'Pending'
    assert item['adjustment_type'] == 'Label Earnings'
    assert item['adjustment_currency_code'] == 'GBP'
    assert item['apply_to_statement_period_id'] == 300
    assert item['activity_statement_period_id'] == 300
    assert item['note'] == 'vz'
    assert item['details'][0] == {
        'ledger_adjustment_detail_id': 1,
        'account_id': 1,
        'contract_id': 1,
        'activity_statement_period_id': 300,
        'apply_to_statement_period_id': 300,
        'reference_adjustment_type_id': 1,
        'currency_code': 'USD',
        'amount': '123.00',
        'upc': '13',
        'distribution_type': 'digital',
        'note': None,
    }

    params = {'account_id': 1}
    response_with_filter = ows_ledger_client.get_ledger_adjustments(params)
    assert response_with_filter.status_code == 200
    assert len(response_with_filter.json()['items']) == 1
    adjustment_item = response_with_filter.json()['items'][0]
    assert adjustment_item['details'][0] == {
        'ledger_adjustment_detail_id': 1,
        'account_id': 1,
        'contract_id': 1,
        'activity_statement_period_id': 300,
        'apply_to_statement_period_id': 300,
        'reference_adjustment_type_id': 1,
        'currency_code': 'USD',
        'amount': '123.00',
        'upc': '13',
        'distribution_type': 'digital',
        'note': None,
    }


@pytest.mark.jira('ACC-4684', 'ACC-6485')
def test_post_contract_advance_paid(basic_headers, create_event_fixtures):
    """POST /ledger-contract-advance-applied/contract-advance/{}/paid ."""
    ows_ledger_client = ows_ledger_api_client(basic_headers)

    check_db_empty(operator.le, 'ledger_contract_advance_applied')

    contract_advance_id = 1
    post_body = {
        'abacus_event_id': 1,
        'account_id': 1,
        'contract_id': 1,
        'statement_period_id': 1,
        'advance_amount': -100.90,
        'advance_currency_code': 'AUD',
        'account_payment_currency_code': 'AUD',
        'amount_after_withholding_and_vat': '15',
        'worksheet_payment_contract_advance_id': 1,
        'advance_amount_payee_currency': 1,
        'amount_after_withholding_and_vat_payee_currency': 1,
        'withholding_tax_amount_payee_currency': 1,
        'vat_amount_payee_currency': 1,
    }
    res_post = ows_ledger_client.post_contract_advance_paid(
        contract_advance_id, post_body
    )
    assert res_post.text == 'Successfully created ledger entries for contract advance.'
    assert res_post.status_code == 201
    check_db_empty(operator.gt, 'ledger_contract_advance_applied')

    res_get = ows_ledger_client.get_contract_advance_applied_by_advance_applied_id(1)
    assert res_get.status_code == 200
    assert res_get.json()['abacus_event_id'] == post_body['abacus_event_id']
    assert res_get.json()['account_id'] == post_body['account_id']
    assert res_get.json()['contract_id'] == post_body['contract_id']
    assert res_get.json()['statement_period_id'] == post_body['statement_period_id']
    assert res_get.json()['advance_currency_code'] == post_body['advance_currency_code']

    res_get = ows_ledger_client.get_ledger_contract_advance_applied_by_advance_id(
        contract_advance_id
    )
    assert res_get.status_code == 200
    assert res_get.json()['abacus_event_id'] == post_body['abacus_event_id']
    assert res_get.json()['account_id'] == post_body['account_id']
    assert res_get.json()['contract_id'] == post_body['contract_id']
    assert res_get.json()['statement_period_id'] == post_body['statement_period_id']
    assert res_get.json()['advance_currency_code'] == post_body['advance_currency_code']


@pytest.mark.jira('ACC-4576')
def test_post_ledger_reserve_release_bulk(
    basic_headers, create_account, create_event_fixtures
):
    """POST /ledger-reserve-release/bulk ."""
    # created upon spinning up the docker stack
    statement_period_id = 300

    ows_ledger_client = ows_ledger_api_client(basic_headers)

    post_body = [
        {
            'abacus_event_id': 1,
            'contract_reserve_id': 1,
            'accounting_run_id': 1,
            'statement_period_id': 1,
            'currency_code': 'USD',
            'gross_sales': '100.00',
            'gross_returns': '-50.00',
            'net_revenue': '150.00',
            'reserve_amount': '-60.00',
            'net_revenue_after_reserve': '90.00',
        }
    ]

    res_post = ows_ledger_client.post_reserve_taken_bulk(post_body)
    assert res_post.status_code == 201

    post_schedule_body = [
        {
            'abacus_event_id': 1,
            'account_id': 1,
            'taken_statement_period_id': statement_period_id,
            'release_statement_period_id': statement_period_id,
            'ledger_reserve_taken_id': 1,
            'currency_code': 'USD',
            'installment_amount': '-1500.11',
            'outstanding_amount_after_installment': '-2100.01',
        }
    ]

    res_post = ows_ledger_client.post_reserve_release_schedule(post_schedule_body)
    assert res_post.status_code == 201

    body = [
        {
            'abacus_event_id': 2,
            'ledger_reserve_release_schedule_id': 1,
            'statement_period_id': 2,
            'installment_amount': '1500.11',
        }
    ]

    res = ows_ledger_client.post_ledger_reserve_release_bulk(body)
    assert res.status_code == 201
    res_body = res.json()[0]
    assert (
        res_body['ledger_reserve_release_schedule_id']
        == body[0]['ledger_reserve_release_schedule_id']
    )
    assert res_body['installment_amount'] == body[0]['installment_amount']
    assert res_body['statement_period_id'] == body[0]['statement_period_id']
    assert res_body['abacus_event_id'] == body[0]['abacus_event_id']


@pytest.mark.jira('ACC-4548')
def test_get_reference_adjustment_types(basic_headers):
    """GET /reference-adjustment-types ."""
    ows_ledger_client = ows_ledger_api_client(basic_headers)

    reference_adjustment_type_id = 1
    type_name = 'test_name'
    oa_category_name = 'test_oa_category_name'
    query = """
        INSERT INTO reference_adjustment_type (
            reference_adjustment_type_id,
            type_name,
            oa_category_name
        ) VALUES (
            {},
            '{}',
            '{}'
        )
    """.format(reference_adjustment_type_id, type_name, oa_category_name)
    db.engine.execute(query)

    res = ows_ledger_client.get_reference_adjustment_types()
    assert res.status_code == 200
    res_body = res.json()['items'][0]
    assert res_body['type_name'] == type_name
    assert res_body['oa_category_name'] == oa_category_name

    res = ows_ledger_client.get_reference_adjustment_types_by_id(
        reference_adjustment_type_id
    )
    assert res.status_code == 200
    assert res.json()['type_name'] == type_name
    assert res.json()['oa_category_name'] == oa_category_name


@pytest.mark.jira('ACC-4970', 'PLATFORM-4425')
def test_get_payable_balance(
    auth_headers: Dict[str, Any],
    create_event_fixtures: Any,
) -> None:
    """GET /ledger-account-contract/account/{account_id}/payable-balance ."""
    ows_ledger_client = ows_ledger_api_client(auth_headers)

    # defined in fixtures
    account_id = 1

    payable_balance = '444.00'
    currency_code = 'USD'
    query = """
        INSERT INTO ledger_account_contract (
            ledger_account_contract_id,
            abacus_event_id,
            account_id,
            contract_id,
            currency_code,
            currency_amount,
            previous_balance,
            current_balance,
            note,
            created_by,
            created_at,
            last_modified_by,
            last_modified
        ) VALUES (
            1,
            1,
            {},
            1,
            '{}',
            123.00,
            321.00,
            {},
            null,
            'vz',
            '2022-10-27 03:02:36',
            'vz',
            '2022-10-27 03:02:41'
        )
    """.format(account_id, currency_code, payable_balance)

    db.engine.execute(query)

    res_get = ows_ledger_client.get_payable_balance_by_account_id(account_id)
    assert res_get.status_code == 200
    assert res_get.json()['payable_balance'] == payable_balance
    assert res_get.json()['currency_code'] == currency_code
    assert res_get.json()['account_id'] == account_id


@pytest.mark.jira('PLATFORM-4425')
def test_get_payable_balance__unauthorized(
    unauthorized_headers: Dict[str, Any],
    create_event_fixtures: Any,
) -> None:
    """Test get_payable_balance_by_account_id with an unauthorized account ."""
    ows_ledger_client = ows_ledger_api_client(unauthorized_headers)

    # defined in fixtures
    account_id = 1

    res_get = ows_ledger_client.get_payable_balance_by_account_id(account_id)
    assert res_get.status_code == 403, res_get.text
    assert res_get.json() == {'code': 'authorization_error', 'message': 'Unauthorized'}


@pytest.mark.jira('ACC-5704')
def test_post_ledger_correction_bulk(
    basic_headers, create_event_fixtures, create_worksheet_correction
):
    """POST /ledger-correction/bulk ."""
    ows_ledger_client = ows_ledger_api_client(basic_headers)

    body = [
        {
            'abacus_event_id': 1,
            'worksheet_correction_id': 1,
            'account_id': 1,
            'contract_id': 1,
            'statement_period_id': 300,
            'correction_statement_period_id': 300,
            'correction_type': 'royalty_reversal',
            'mechanical_deduction_admin_fee_total': None,
            'mechanical_deduction_total': None,
            'currency_code': 'USD',
            'gross_revenue': '-900.00',
            'distribution_fee': '10.00',
            'net_revenue': '-890.00',
            'note': None,
        }
    ]

    res_post = ows_ledger_client.post_ledger_correction_bulk(body)
    assert res_post.status_code == 201
    body[0]['ledger_correction_id'] = 1
    assert res_post.json() == body


@pytest.mark.jira('ACC-7060')
def test_get_account_ledger_info(
    basic_headers, create_accounting_run, create_run_controller, create_account
):
    """GET /ledger-accounts/account/{account_id} ."""
    ows_ledger_client = ows_ledger_api_client(basic_headers)
    ows_royalties_client = ows_royalties_api_client(basic_headers)
    ows_abacus_client = ows_abacus_event_api_client(basic_headers)

    # defined in fixtures
    account_id = 1

    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract = ows_royalties_client.generate_contract_body(
        contract_name, 'distribution'
    )
    contract.update(account_id=account_id)
    response_post_contract = ows_royalties_client.post_contract(contract)
    assert response_post_contract.status_code == 201
    contract_id = response_post_contract.json()['contract_id']

    response_get_accounting_runs = ows_royalties_client.get_accounting_periods()
    assert response_get_accounting_runs.status_code == 200
    accounting_runs = response_get_accounting_runs.json()['items']
    open_period = next(
        (item for item in accounting_runs if item['closed_date'] is None), None
    )
    accounting_period_id = open_period['accounting_period_id']
    accounting_run_response = ows_royalties_client.get_accounting_period_runs(
        accounting_period_id
    )
    assert accounting_run_response.status_code == 200

    ledger_event = generate_ledger_event(
        accounting_period_id, target_type='accounting_period'
    )
    response_post_abacus_event = ows_abacus_client.post_abacus_event(ledger_event)
    assert response_post_abacus_event.status_code == 201
    abacus_event_id = response_post_abacus_event.json()['abacus_event_id']

    post_ledger_account_body = [
        generate_post_ledger_account_body(abacus_event_id, account_id, contract_id)
    ]

    response_post_ledger_account = ows_ledger_client.post_ledger_bulk(
        post_ledger_account_body
    )
    assert response_post_ledger_account.status_code == 201

    res_get = ows_ledger_client.get_account_ledger_info(account_id)
    assert res_get.status_code == 200
    assert 'items' in res_get.json()
    assert 'total_count' in res_get.json()
    response_item = res_get.json()['items'][0]
    assert response_item['amount'] == post_ledger_account_body[0]['currency_amount']
    assert (
        response_item['currency_code'] == post_ledger_account_body[0]['currency_code']
    )
    assert response_item['account_id'] == post_ledger_account_body[0]['account_id']
    assert response_item['contract_id'] == post_ledger_account_body[0]['contract_id']


@pytest.mark.jira('TAP-983')
def test_get_balances_by_contract_id_list(
    basic_headers, create_accounting_run, create_run_controller, create_account
):
    """GET /bulk/contracts/closed-balance/ ."""
    ows_ledger_client = ows_ledger_api_client(basic_headers)
    ows_royalties_client = ows_royalties_api_client(basic_headers)
    ows_abacus_client = ows_abacus_event_api_client(basic_headers)

    # defined in fixtures
    account_id = 1

    contract_name = 'orcd_autotest_{}'.format(generate_random_string(16))
    contract = ows_royalties_client.generate_contract_body(
        contract_name, 'distribution'
    )
    contract.update(account_id=account_id)
    response_post_contract = ows_royalties_client.post_contract(contract)
    assert response_post_contract.status_code == 201
    contract_id = response_post_contract.json()['contract_id']

    response_get_accounting_runs = ows_royalties_client.get_accounting_periods()
    assert response_get_accounting_runs.status_code == 200
    accounting_runs = response_get_accounting_runs.json()['items']
    open_period = next(
        (item for item in accounting_runs if item['closed_date'] is None), None
    )
    accounting_period_id = open_period['accounting_period_id']
    accounting_run_response = ows_royalties_client.get_accounting_period_runs(
        accounting_period_id
    )
    assert accounting_run_response.status_code == 200

    ledger_event = generate_ledger_event(
        accounting_period_id, target_type='accounting_period'
    )
    response_post_abacus_event = ows_abacus_client.post_abacus_event(ledger_event)
    assert response_post_abacus_event.status_code == 201
    abacus_event_id = response_post_abacus_event.json()['abacus_event_id']

    post_ledger_account_body = [
        generate_post_ledger_account_body(abacus_event_id, account_id, contract_id)
    ]

    response_post_ledger_account = ows_ledger_client.post_ledger_bulk(
        post_ledger_account_body
    )
    assert response_post_ledger_account.status_code == 201

    params = {'contract_ids': contract_id}
    res_get = ows_ledger_client.get_balances_by_contract_id_list(params)
    assert res_get.status_code == 200
    assert len(res_get.json()) == 1
    assert 'ledger_account_contract_id' in res_get.json()[0]
    assert res_get.json()[0]['account_id'] == account_id
    assert res_get.json()[0]['contract_id'] == contract_id
    assert (
        res_get.json()[0]['current_balance']
        == post_ledger_account_body[0]['currency_amount']
    )
    assert (
        res_get.json()[0]['currency_code']
        == post_ledger_account_body[0]['currency_code']
    )


@pytest.mark.jira('ACC-7901', 'ACC-7902', 'ACC-7903')
def test_ledger_account_contract(
    auth_headers: Dict[str, Any],
    create_event_fixtures: Any,
) -> None:
    """GET /ledger-account-contract/account/<account_id> with params ."""
    ows_ledger_client = ows_ledger_api_client(auth_headers)

    # defined in fixtures
    account_id = 1
    contract_id = 1

    payable_balance = '444.00'
    currency_code = 'USD'
    query = """
        INSERT INTO ledger_account_contract (
            ledger_account_contract_id,
            abacus_event_id,
            account_id,
            contract_id,
            currency_code,
            currency_amount,
            previous_balance,
            current_balance,
            note,
            created_by,
            created_at,
            last_modified_by,
            last_modified
        ) VALUES (
            1,
            1,
            {},
            1,
            '{}',
            123.00,
            321.00,
            {},
            null,
            'vz',
            '2022-10-27 03:02:36',
            'vz',
            '2022-10-27 03:02:41'
        ), (
            2,
            2,
            1,
            1,
            2,
            123.00,
            321.00,
            444.00,
            null,
            'vz',
            '2022-10-27 03:02:36',
            'vz',
            '2022-10-27 03:02:41'
        )
    """.format(account_id, currency_code, payable_balance)

    db.engine.execute(query)

    res_get = ows_ledger_client.get_ledger_entries_by_account_with_params(account_id)
    assert res_get.status_code == 200
    assert len(res_get.json()['items']) == 2
    assert res_get.json()['items'][0]['account_id'] == account_id
    assert res_get.json()['total_count'] == 2

    params = {'event_names': 'commit_royalties'}
    res_get = ows_ledger_client.get_ledger_entries_by_account_with_params(
        account_id, params
    )
    assert res_get.status_code == 200
    assert len(res_get.json()['items']) == 2
    assert res_get.json()['items'][0]['account_id'] == account_id
    assert res_get.json()['total_count'] == 2

    params = {'contract_ids': contract_id}
    res_get = ows_ledger_client.get_ledger_entries_by_account_with_params(
        account_id, params
    )
    assert res_get.status_code == 200
    assert len(res_get.json()['items']) == 2
    assert res_get.json()['items'][0]['account_id'] == account_id
    assert res_get.json()['items'][0]['contract_id'] == contract_id
    assert res_get.json()['total_count'] == 2

    params = {'statement_period_ids': 265}
    res_get = ows_ledger_client.get_ledger_entries_by_account_with_params(
        account_id, params
    )
    assert res_get.status_code == 200
    assert len(res_get.json()['items']) == 1
    assert res_get.json()['items'][0]['statement_period_id'] == 265
    assert res_get.json()['total_count'] == 1


@pytest.mark.jira('PLATFORM-4425')
def test_ledger_account_contract__unauthorized(
    unauthorized_headers: Dict[str, Any],
    create_event_fixtures: Any,
) -> None:
    """Test get_ledger_entries_by_account_with_params with an unauthorized account."""
    ows_ledger_client = ows_ledger_api_client(unauthorized_headers)
    res_get = ows_ledger_client.get_ledger_entries_by_account_with_params(1)
    assert res_get.status_code == 403, res_get.text
    assert res_get.json() == {'code': 'authorization_error', 'message': 'Unauthorized'}