"""Integration tests suite."""
import ast

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

from tests.integration.conftest import ows_abacus_account_api_client, QA_BASE_URL


@pytest.mark.jira('ACC-4084', 'PLATFORM-4339')
def test_post_get_payment_term(basic_headers, clean_db):
    """Test POST and GET payment terms endpoints."""
    account_id = 123455
    ows_account_client = ows_abacus_account_api_client(basic_headers)
    post_account = {
        'account_name': 'Test Account',
        'account_id': account_id,
    }

    response_post = ows_account_client.post_account(post_account)
    assert response_post.status_code == 201

    post_payment_term_body = {
        'account_id': account_id,
        'currency_code': 'USD',
        'payment_entity_id': 2,
        'payment_schedule': None,
        'payment_minimum': None
    }

    response_post_payment_term = ows_account_client.post_account_payment_term(
        post_payment_term_body
    )
    assert response_post_payment_term.status_code == 201
    payment_term_id = response_post_payment_term.json()['account_payment_term_id']
    expected_item = dict(**post_payment_term_body,
                         account_payment_term_id=payment_term_id,
                         agreement_type_id=None)
    assert expected_item == response_post_payment_term.json()

    response_get_payment_term = \
        ows_account_client.get_account_payment_term_by_id(
            payment_term_id
        )
    assert response_get_payment_term.status_code == 200
    assert response_get_payment_term.json() == expected_item


@pytest.mark.jira('ACC-4084', 'PLATFORM-4339')
def test_put_payment_term(basic_headers, clean_db):
    """Test PUT payment term endpoint."""
    account_id = 123455
    ows_account_client = ows_abacus_account_api_client(basic_headers)
    post_account = {
        'account_name': 'Test Account',
        'account_id': account_id,
    }

    response_post = ows_account_client.post_account(post_account)
    assert response_post.status_code == 201
    ows_abacus_account_client = ows_abacus_account_api_client(basic_headers)

    post_payment_term_body = {
        'account_id': account_id,
        'currency_code': 'USD',
        'payment_schedule': None,
        'payment_entity_id': 2,
        'payment_minimum': None
    }

    put_payment_term_body = {
        'currency_code': 'EUR',
        'payment_schedule': '30_days_after_month_end',
        'payment_minimum': None,
        'payment_entity_id': 2,
        'agreement_type_id': 1
    }

    response_post_payment_term = ows_abacus_account_client.post_account_payment_term(
        post_payment_term_body
    )
    assert response_post_payment_term.status_code == 201
    payment_term_id = response_post_payment_term.json()['account_payment_term_id']

    response_put_payment_term = \
        ows_abacus_account_client.put_account_payment_term_by_id(
            payment_term_id, put_payment_term_body
        )
    assert response_put_payment_term.status_code == 200
    expected_item = dict(
        **put_payment_term_body,
        account_id=account_id
    )
    expected_item.update(
        account_payment_term_id=payment_term_id
    )

    response_get_payment_term = \
        ows_abacus_account_client.get_account_payment_term_by_id(
            payment_term_id
        )
    assert response_get_payment_term.status_code == 200
    assert response_get_payment_term.json() == expected_item


@pytest.mark.jira('ACC-4084', 'PLATFORM-4339')
def test_get_payment_terms_by_account_id(basic_headers, clean_db):
    """Test GET payment terms by account id."""
    account_id = 123455
    ows_account_client = ows_abacus_account_api_client(basic_headers)
    post_account = {
        'account_name': 'Test Account',
        'account_id': account_id,
    }

    response_post = ows_account_client.post_account(post_account)
    assert response_post.status_code == 201

    ows_abacus_account_client = ows_abacus_account_api_client(basic_headers)

    post_payment_term_body = {
        'account_id': account_id,
        'currency_code': 'USD',
        'payment_entity_id': 2,
        'payment_schedule': None,
        'payment_minimum': None
    }

    response_post_payment_term = ows_abacus_account_client.post_account_payment_term(
        post_payment_term_body
    )
    assert response_post_payment_term.status_code == 201
    payment_term_id = response_post_payment_term.json()['account_payment_term_id']
    expected_item = dict(**post_payment_term_body,
                         account_payment_term_id=payment_term_id,
                         agreement_type_id=None
                         )
    assert expected_item == response_post_payment_term.json()

    response_get_by_acc_id = ows_abacus_account_client.get_payment_term_by_account_id(
        account_id
    )
    assert response_get_by_acc_id.status_code == 200
    assert response_get_by_acc_id.json() == expected_item


@pytest.mark.jira('PLATFORM-4339')
def test_get_payment_terms_by_account_id_unauthorized(unauthorized_headers, clean_db):
    """Test GET payment terms by account id with unauthorized headers."""
    account_id = 123455
    ows_account_client = ows_abacus_account_api_client(unauthorized_headers)
    response_get_by_acc_id = ows_account_client.get_payment_term_by_account_id(
        account_id
    )
    assert response_get_by_acc_id.status_code == 403
    expected = {
        'code': 'authorization_error',
        'message': 'Unauthorized'
    }
    assert response_get_by_acc_id.json() == expected


@pytest.mark.jira('ACC-4084')
def test_post_account_payment_term_template(basic_headers, clean_db):
    """Test POST /account-payment-term-template/{template_id}/account-payment-term."""
    account_id = 123123
    ows_account_client = ows_abacus_account_api_client(basic_headers)
    post_account = {
        'account_name': 'Test Account',
        'account_id': account_id,
    }

    response_post = ows_account_client.post_account(post_account)
    assert response_post.status_code == 201

    payload_data = {
        'template_name': 'Template 1',
        'currency_code': 'GBP',
        'payment_terms':
            '{"payment_minimum": 100, '
            '"payment_schedule": "45_days_after_month_end", '
            '"agreement_type_id": 1}'
    }

    query = """INSERT INTO account_payment_term_template
    (template_name, currency_code, payment_terms) VALUES
    ('{template_name}', '{currency_code}', '{payment_terms}')"""
    db.engine.execute(query.format(**payload_data))

    payload = {
        'account_id': account_id
    }

    response_post = ows_account_client.post_account_payment_term_template(
        1, payload)
    assert response_post.status_code == 201
    payment_terms = ast.literal_eval(payload_data['payment_terms'])
    assert response_post.json()['payment_minimum'] == format(
        payment_terms['payment_minimum'], '.2f'
    )
    assert response_post.json()['payment_schedule'] \
           == payment_terms['payment_schedule']
    assert response_post.json()['account_id'] == account_id
    assert response_post.json()['currency_code'] \
           == payload_data['currency_code']
    assert response_post.json()['agreement_type_id'] \
           == payment_terms['agreement_type_id']


@pytest.mark.jira('ACC-4084')
def test_get_account_payment_terms_snapshot(
        basic_headers, clean_db):
    """POST /account-payment-terms/snapshot ."""
    account_id = 11
    ows_account_client = ows_abacus_account_api_client(basic_headers)
    post_account = {
        'account_name': 'Test account 11',
        'account_id': account_id,
    }
    response_post_account = ows_account_client.post_account(post_account)
    assert response_post_account.status_code == 201

    post_payment_term_body = {
        'account_id': account_id,
        'currency_code': 'USD',
        'payment_schedule': '30_days_after_month_end',
        'payment_minimum': '555.00',
        'payment_entity_id': 2
    }

    response_post_payment_term = ows_account_client.post_account_payment_term(
        post_payment_term_body
    )
    assert response_post_payment_term.status_code == 201

    data = 'account_payment_term_id\taccount_id\tcurrency_code\t' \
           'payment_minimum\tpayment_entity_id\tpayment_schedule\tagreement_type_id\n' \
           '1\t11\tUSD\t555.00\t2\t30_days_after_month_end\tNone\n'

    response_get = ows_account_client.get_payment_terms_snapshot([])
    assert response_get.status_code == 200
    assert response_get.text == data


@pytest.mark.jira('ACC-4084')
def test_create_payment_terms_based_on_currency_code(basic_headers, clean_db):
    """Create payment terms based on currency code."""
    ows_account_client = ows_abacus_account_api_client(basic_headers)
    account_id = 11

    payload_data = {
        'template_name': 'Template 1',
        'currency_code': 'CAD',
        'payment_terms':
            '{"payment_minimum": 100, '
            '"payment_schedule": "45_days_after_month_end", '
            '"signing_entity_id": 2, '
            '"agreement_type_id": 1}'
    }

    query = """INSERT INTO account_payment_term_template
    (template_name, currency_code, payment_terms) VALUES
    ('{template_name}', '{currency_code}', '{payment_terms}')"""
    db.engine.execute(query.format(**payload_data))

    post_account = {
        'account_id': account_id,
        'account_name': 'Test account 11',
        'currency_code': 'CAD',
        'country_of_tax_residence': 'CAN'
    }
    response_post_account = ows_account_client.post_account(post_account)
    assert response_post_account.status_code == 201
    assert response_post_account.json()['account_name'] == post_account['account_name']
    assert response_post_account.json()['account_id'] == post_account['account_id']


@pytest.mark.jira('PLATFORM-4339')
def test_get_payment_term_dataloaded(basic_headers, clean_db):
    """Test POST /account/account-payment-term/dataloader."""
    account_id = 123455
    ows_account_client = ows_abacus_account_api_client(basic_headers)
    post_account = {
        'account_name': 'Test Account',
        'account_id': account_id,
    }

    # Create the account
    response_post = ows_account_client.post_account(post_account)
    assert response_post.status_code == 201

    post_payment_term_body = {
        'account_id': account_id,
        'currency_code': 'USD',
        'payment_schedule': None,
        'payment_entity_id': 2,
        'payment_minimum': None
    }

    # Create the acccount payment term
    response_post_payment_term = ows_account_client.post_account_payment_term(
        post_payment_term_body
    )
    assert response_post_payment_term.status_code == 201
    payment_term_id = response_post_payment_term.json()['account_payment_term_id']
    expected_item = dict(**post_payment_term_body,
                         account_payment_term_id=payment_term_id,
                         agreement_type_id=None
                         )
    assert expected_item == response_post_payment_term.json()

    # Test the dataloder endpoint
    response_get_dataloaded = requests.post(
        f'{QA_BASE_URL}/account/account-payment-term/dataloader',
        headers=basic_headers,
        json=[account_id]
    )
    assert response_get_dataloaded.status_code == 200
    assert response_get_dataloaded.json() == [{'data': expected_item}]


@pytest.mark.jira('PLATFORM-4339')
def test_get_payment_term_dataloaded_unauthorized(unauthorized_headers, clean_db):
    """Test POST /account/account-payment-term/dataloader with unauthorized headers."""
    response_get_dataloaded = requests.post(
        f'{QA_BASE_URL}/account/account-payment-term/dataloader',
        headers=unauthorized_headers,
        json=[99999999]
    )
    assert response_get_dataloaded.status_code == 403
    expected = {
        'code': 'authorization_error',
        'message': 'Unauthorized'
    }
    assert response_get_dataloaded.json() == expected