"""Functional tests for Reference Payoneer Program."""

from unittest.mock import patch

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 abacus_account.models.reference_payoneer_program import ReferencePayoneerProgram
from tests.utils.factories import PaymentEntityPayoneerProgramFactory
from tests.utils.factories import ReferencePayoneerProgramFactory


def test_list_payoneer_programs(fixture_client):
    """Test that we can get a list of all payoneer programs."""
    payoneer_programs = ReferencePayoneerProgramFactory.create_batch(2)

    response = fixture_client.get('/payoneer-program')
    res_json = response.json

    assert response.status_code == 200
    assert res_json['total_count'] == 2
    assert res_json['items'][0] == {
        'payoneer_program_id': payoneer_programs[0].payoneer_program_id,
        'payoneer_program_name': payoneer_programs[0].payoneer_program_name,
        'funding_currency': payoneer_programs[0].funding_currency,
        'reference_payment_type_id': payoneer_programs[0].reference_payment_type_id,
    }
    assert res_json['items'][1] == {
        'payoneer_program_id': payoneer_programs[1].payoneer_program_id,
        'payoneer_program_name': payoneer_programs[1].payoneer_program_name,
        'funding_currency': payoneer_programs[1].funding_currency,
        'reference_payment_type_id': payoneer_programs[1].reference_payment_type_id,
    }


def test_get_payoneer_program(fixture_client):
    """Test that we can get a payoneer program by payoneer_program_id."""
    test_program_id = 5
    payoneer_program = ReferencePayoneerProgramFactory(
        payoneer_program_id=test_program_id
    )

    response = fixture_client.get(f'/payoneer-program/{test_program_id}')
    res_json = response.json

    assert response.status_code == 200
    assert res_json == {
        'payoneer_program_id': payoneer_program.payoneer_program_id,
        'payoneer_program_name': payoneer_program.payoneer_program_name,
        'funding_currency': payoneer_program.funding_currency,
        'reference_payment_type_id': payoneer_program.reference_payment_type_id,
    }


@patch('abacus_account.blueprints.reference_payoneer_program.authorize_resource')
def test_get_payoneer_program_with_invalid_profile(
    mock_authorize_resource,
    fixture_client
) -> None:
    """Get /payoneer-program/:id with invalid profile."""
    test_program_id = 5
    payoneer_program = ReferencePayoneerProgramFactory(
        payoneer_program_id=test_program_id
    )
    mock_authorize_resource.return_value = True

    response = fixture_client.get(
        f'/payoneer-program/{test_program_id}',
        headers={
            'Content-Type': 'application/json',
            'Orchard-Identity-Id': 'd5ca8ac3-7e51-4793-8775-50d11282504c',
            'Orchard-Profile-Id': '35109',
            'Orchard-Profile-Type': 'NotProfile',
            'Orchard-Roles': 'administrator',
            'Orchard-Requestor-Service': 'graphql-abacus'
        }
    )
    res_json = response.json

    assert response.status_code == 200
    assert res_json == {
        'payoneer_program_id': payoneer_program.payoneer_program_id,
        'payoneer_program_name': payoneer_program.payoneer_program_name,
        'funding_currency': payoneer_program.funding_currency,
        'reference_payment_type_id': payoneer_program.reference_payment_type_id,
    }


# --- Payoneer Program Move Type Tests ---

_PAYONEER = BULK_PAYOUTS_PAYONEER_PAYMENT_TYPES['payoneer']
_WL = BULK_PAYOUTS_PAYONEER_PAYMENT_TYPES['payoneer_whitelabel']
_PREEXISTING = BULK_PAYOUTS_PAYONEER_PAYMENT_TYPES['preexisting_payoneer_account']
_WIRE = BULK_PAYOUTS_PAYONEER_PAYMENT_TYPES['payoneer_wire']


@pytest.fixture
def move_type_payment_types():
    """Create reference_payment_type records needed for move type tests."""
    values = ', '.join(
        f"({t}, 'bulk_payouts', 'payoneer', 0, NULL)"
        for t in (_PAYONEER, _WL, _PREEXISTING, _WIRE)
    )
    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 {values}'
    )


@pytest.mark.parametrize(
    'from_type,to_type,expected_move_type',
    [
        pytest.param(_PAYONEER, _PAYONEER, MOVE_TYPE_ADOPT_AND_RELEASE,
                     id='payoneer->payoneer'),
        pytest.param(_WL, _WL, MOVE_TYPE_ADOPT_AND_RELEASE,
                     id='wl->wl'),
        pytest.param(_WL, _WIRE, MOVE_TYPE_ADOPT_AND_RELEASE,
                     id='wl->wire'),
        pytest.param(_WIRE, _WL, MOVE_TYPE_ADOPT_AND_RELEASE,
                     id='wire->wl'),
        pytest.param(_WIRE, _WIRE, MOVE_TYPE_ADOPT_AND_RELEASE,
                     id='wire->wire'),
        pytest.param(_PAYONEER, _PREEXISTING, MOVE_TYPE_RELEASE_AND_WARN,
                     id='payoneer->preexisting'),
        pytest.param(_WL, _PREEXISTING, MOVE_TYPE_RELEASE_AND_WARN,
                     id='wl->preexisting'),
        pytest.param(_PREEXISTING, _PREEXISTING, MOVE_TYPE_RELEASE_AND_WARN,
                     id='preexisting->preexisting'),
        pytest.param(_WIRE, _PREEXISTING, MOVE_TYPE_RELEASE_AND_WARN,
                     id='wire->preexisting'),
        pytest.param(_WIRE, _PAYONEER, MOVE_TYPE_RELEASE_AND_WARN,
                     id='wire->payoneer'),
        pytest.param(_WL, _PAYONEER, MOVE_TYPE_RELEASE_AND_WARN,
                     id='wl->payoneer'),
        pytest.param(_PAYONEER, _WL, MOVE_TYPE_RELEASE_AND_WARN,
                     id='payoneer->wl'),
        pytest.param(_PAYONEER, _WIRE, MOVE_TYPE_RELEASE_AND_WARN,
                     id='payoneer->wire'),
        pytest.param(_PREEXISTING, _PAYONEER, MOVE_TYPE_RELEASE_AND_WARN,
                     id='preexisting->payoneer'),
        pytest.param(_PREEXISTING, _WL, MOVE_TYPE_RELEASE_AND_WARN,
                     id='preexisting->wl'),
        pytest.param(_PREEXISTING, _WIRE, MOVE_TYPE_RELEASE_AND_WARN,
                     id='preexisting->wire'),
    ],
)
def test_get_payoneer_program_move_type(
    fixture_client, move_type_payment_types, from_type, to_type, expected_move_type
):
    """Test move type resolution for all supported transition pairs."""
    from_program = ReferencePayoneerProgramFactory.create(
        payoneer_program_id=100,
        reference_payment_type_id=from_type,
    )
    to_program = ReferencePayoneerProgramFactory.create(
        payoneer_program_id=200,
        reference_payment_type_id=to_type,
    )

    response = fixture_client.get(
        f'/payoneer-program-move-type'
        f'?from_program_id={from_program.payoneer_program_id}'
        f'&to_program_id={to_program.payoneer_program_id}'
    )
    assert response.status_code == 200
    assert response.json == {'move_type': expected_move_type}


def test_get_payoneer_program_move_type_same_program(
    fixture_client, move_type_payment_types
):
    """Test move type returns 400 when from and to program are the same."""
    program = ReferencePayoneerProgramFactory.create(
        payoneer_program_id=100,
        reference_payment_type_id=_PAYONEER,
    )
    response = fixture_client.get(
        f'/payoneer-program-move-type'
        f'?from_program_id={program.payoneer_program_id}'
        f'&to_program_id={program.payoneer_program_id}'
    )
    assert response.status_code == 400


def test_get_payoneer_program_move_type_missing_params(fixture_client):
    """Test move type returns 400 when query params are missing."""
    response = fixture_client.get('/payoneer-program-move-type')
    assert response.status_code == 400


def test_get_payoneer_program_move_type_from_not_found(
    fixture_client, move_type_payment_types
):
    """Test move type returns 404 when from_program_id does not exist."""
    to_program = ReferencePayoneerProgramFactory.create(
        payoneer_program_id=200,
        reference_payment_type_id=_PAYONEER,
    )
    response = fixture_client.get(
        f'/payoneer-program-move-type'
        f'?from_program_id=999&to_program_id={to_program.payoneer_program_id}'
    )
    assert response.status_code == 404


def test_get_payoneer_program_move_type_to_not_found(
    fixture_client, move_type_payment_types
):
    """Test move type returns 404 when to_program_id does not exist."""
    from_program = ReferencePayoneerProgramFactory.create(
        payoneer_program_id=100,
        reference_payment_type_id=_PAYONEER,
    )
    response = fixture_client.get(
        f'/payoneer-program-move-type'
        f'?from_program_id={from_program.payoneer_program_id}&to_program_id=999'
    )
    assert response.status_code == 404


def test_get_payoneer_program_error(fixture_client):
    """Test that we get a 404 for a program ID that does not exist."""
    ReferencePayoneerProgramFactory.create()
    response = fixture_client.get('/payoneer-program/1234567')
    assert response.status_code == 404


def test_get_payoneer_program_not_found(fixture_client):
    """Test that we get a 404 for non-existing program ID for a given params."""
    ReferencePayoneerProgramFactory.create()
    response = fixture_client.get(
        '/payoneer-program/payment-entity/1/currency/usd/agreement-type/1')

    assert response.status_code == 404


def test_get_payoneer_program_missing_params(fixture_client):
    """Test that we get a 400 for non-existing params."""
    response = fixture_client.get(
        '/payoneer-program/payment-entity/0/currency/usd/agreement-type/0')

    assert response.status_code == 400


def test_get_payoneer_program_by_specified_params(fixture_client):
    """Test that we can get a payoneer program by given params."""
    currency = 'usd'
    agreement_type_id = 1

    payment_entity_id = 1

    payoneer_program = ReferencePayoneerProgramFactory(
        payoneer_program_id=1
    )
    PaymentEntityPayoneerProgramFactory.create()
    response = fixture_client.get(
        f'/payoneer-program/payment-entity/{payment_entity_id}'
        f'/currency/{currency}/agreement-type/{agreement_type_id}'
    )
    res_json = response.json

    assert response.status_code == 200
    assert res_json == {
        'payoneer_program_id': payoneer_program.payoneer_program_id,
        'payoneer_program_name': payoneer_program.payoneer_program_name,
        'funding_currency': payoneer_program.funding_currency,
        'reference_payment_type_id': payoneer_program.reference_payment_type_id,
    }


def test_get_payoneer_program_by_specified_params_with_payment_type(fixture_client):
    """Test that we can get a payoneer program by given params."""
    currency = 'usd'
    agreement_type_id = 1

    payment_entity_id = 1

    payoneer_program = ReferencePayoneerProgramFactory(
        payoneer_program_id=1
    )
    PaymentEntityPayoneerProgramFactory.create()
    response = fixture_client.get(
        f'/payoneer-program/payment-entity/{payment_entity_id}'
        f'/currency/{currency}/agreement-type/{agreement_type_id}'
        f'/payment-type/{payoneer_program.reference_payment_type_id}'
    )
    res_json = response.json

    assert response.status_code == 200
    assert res_json == {
        'payoneer_program_id': payoneer_program.payoneer_program_id,
        'payoneer_program_name': payoneer_program.payoneer_program_name,
        'funding_currency': payoneer_program.funding_currency,
        'reference_payment_type_id': payoneer_program.reference_payment_type_id,
    }


def test_get_payoneer_program_by_specified_params_with_payment_type_not_found(
    fixture_client
):
    """Test that we can get a payoneer program by given params."""
    currency = 'usd'
    agreement_type_id = 1
    payment_entity_id = 1
    reference_payment_type_id = 999

    ReferencePayoneerProgramFactory(
        payoneer_program_id=1,
    )
    PaymentEntityPayoneerProgramFactory.create()
    response = fixture_client.get(
        f'/payoneer-program/payment-entity/{payment_entity_id}'
        f'/currency/{currency}/agreement-type/{agreement_type_id}'
        f'/payment-type/{reference_payment_type_id}'
    )

    assert not ReferencePayoneerProgram.query.filter_by(
        reference_payment_type_id=reference_payment_type_id
    ).count()
    assert response.status_code == 404