"""Integration tests suite/payoneer."""

from abacus_common_logic.connectors.database import db
import pytest

from abacus_account.constants.constants import (
    BULK_PAYOUTS_PAYONEER_PAYMENT_TYPES,
    MOVE_TYPE_ADOPT_AND_RELEASE,
    MOVE_TYPE_RELEASE_AND_WARN,
)
from tests.integration.conftest import ows_abacus_account_api_client


@pytest.mark.jira('ACC-4773')
def test_get_payoneer_programs(
    auth_headers: dict[str, str], clean_db: None, insert_payoneer_program: None
) -> None:
    """GET /payoneer-program and /payoneer-program/<id> ."""
    ows_account_client = ows_abacus_account_api_client(auth_headers)

    payload_data = {
        'payoneer_program_id': 1,
        'funding_currency': 'USD',
        'payoneer_program_name': 'test',
        'reference_payment_type_id': 5,
    }

    response_get = ows_account_client.get_payoneer_programs()
    assert response_get.status_code == 200
    response_get_body = response_get.json()['items'][0]
    assert response_get_body == payload_data

    response_get = ows_account_client.get_payoneer_program_by_id(
        payload_data['payoneer_program_id']
    )
    assert response_get.status_code == 200
    assert response_get.json() == payload_data


@pytest.mark.jira('ACC-4324')
def test_get_payment_entity_payoneer_program_by_payment_entity_id(
    basic_headers: dict[str, str], clean_db: None, insert_payoneer_program: None
) -> None:
    """GET /payment-entity/{payment_entity_id}/payment-entity-payoneer-program ."""
    ows_account_client = ows_abacus_account_api_client(
        basic_headers
    )

    payload_data = {
        'payment_entity_payoneer_program_id': 1,
        'payoneer_program_id': 1,
        'reference_payment_entity_id': 2,
        'payment_currency': 'USD',
        'agreement_type_id': 1
    }
    query = """
        INSERT INTO payment_entity_payoneer_program (
            payment_entity_payoneer_program_id,
            payoneer_program_id,
            reference_payment_entity_id,
            payment_currency,
            agreement_type_id
        ) VALUES (
            {payment_entity_payoneer_program_id},
            '{payoneer_program_id}',
            '{reference_payment_entity_id}',
            '{payment_currency}',
            '{agreement_type_id}'
        )
    """
    db.engine.execute(query.format(**payload_data))

    response_get = ows_account_client\
        .get_payment_entity_payoneer_program_by_payment_entity_id(
            payload_data['reference_payment_entity_id']
        )
    assert response_get.status_code == 200
    response_body = response_get.json()['items'][0]
    assert response_body['payment_entity_payoneer_program_id'] == \
           payload_data['payment_entity_payoneer_program_id']
    assert response_body['payoneer_program_id'] == \
           payload_data['payoneer_program_id']
    assert response_body['reference_payment_entity_id'] == \
           payload_data['reference_payment_entity_id']
    assert response_body['payment_currency'] == payload_data['payment_currency']
    assert response_body['agreement_type_id'] == payload_data['agreement_type_id']


@pytest.mark.jira('ACC-4324')
def test_get_payment_entity_payoneer_programs(basic_headers):
    """GET /payment_entity_payoneer_programs ."""
    ows_account_client = ows_abacus_account_api_client(
        basic_headers
    )
    res_get = ows_account_client.get_payment_entity_payoneer_programs()

    expected_payment_entity = {
        'reference_payment_entity_id': 2,
        'agreement_type': 'AWAL Core',
        'reference_agreement_type_id': '1',
        'payoneer_program_id': 1,
        'payment_currency': 'USD',
        'payment_service': 'other',
        'reference_payment_type_id': 5,
    }
    assert res_get.status_code == 200
    assert res_get.json()['items'][1] == expected_payment_entity


def test_get_payoneer_program_move_type(
    basic_headers: dict[str, str], clean_db: None
) -> None:
    """GET /payoneer-program-move-type resolves move type for program transitions."""
    _payoneer = BULK_PAYOUTS_PAYONEER_PAYMENT_TYPES['payoneer']
    _wl = BULK_PAYOUTS_PAYONEER_PAYMENT_TYPES['payoneer_whitelabel']
    _preexisting = BULK_PAYOUTS_PAYONEER_PAYMENT_TYPES['preexisting_payoneer_account']

    # Insert reference_payment_type and payoneer programs
    con = db.engine.connect()
    con.execute(
        'INSERT IGNORE INTO reference_payment_type '
        '(reference_payment_type_id, payment_type, '
        'payment_service, is_internal, notes) '
        f"VALUES ({_payoneer}, 'bulk_payouts', 'payoneer', 0, NULL), "
        f"({_wl}, 'bulk_payouts', 'payoneer', 0, NULL), "
        f"({_preexisting}, 'bulk_payouts', 'payoneer', 0, NULL)"
    )
    con.execute(
        'INSERT INTO reference_payoneer_program '
        '(payoneer_program_id, payoneer_program_name, '
        'funding_currency, reference_payment_type_id) '
        f"VALUES (100, 'Program A', 'USD', {_payoneer}), "
        f"(101, 'Program A2', 'EUR', {_payoneer}), "
        f"(200, 'Program B', 'USD', {_wl}), "
        f"(300, 'Program C', 'USD', {_preexisting})"
    )

    ows_account_client = ows_abacus_account_api_client(basic_headers)

    # 400: same program transition
    res = ows_account_client.get_payoneer_program_move_type(100, 100)
    assert res.status_code == 400

    # ADOPT_AND_RELEASE: Payoneer -> Payoneer (different programs, same type)
    res = ows_account_client.get_payoneer_program_move_type(100, 101)
    assert res.status_code == 200
    assert res.json() == {'move_type': MOVE_TYPE_ADOPT_AND_RELEASE}

    # RELEASE_AND_WARN: Payoneer -> WL
    res = ows_account_client.get_payoneer_program_move_type(100, 200)
    assert res.status_code == 200
    assert res.json() == {'move_type': MOVE_TYPE_RELEASE_AND_WARN}

    # RELEASE_AND_WARN: Any -> Preexisting
    res = ows_account_client.get_payoneer_program_move_type(100, 300)
    assert res.status_code == 200
    assert res.json() == {'move_type': MOVE_TYPE_RELEASE_AND_WARN}

    # RELEASE_AND_WARN: Preexisting -> Payoneer
    res = ows_account_client.get_payoneer_program_move_type(300, 100)
    assert res.status_code == 200
    assert res.json() == {'move_type': MOVE_TYPE_RELEASE_AND_WARN}

    # 404: non-existent program
    res = ows_account_client.get_payoneer_program_move_type(999, 100)
    assert res.status_code == 404

    # 400: missing params
    res = ows_account_client.get_payoneer_program_move_type(None, None)
    assert res.status_code == 400