"""Tests for reference_payoneer_program logic."""

from unittest.mock import patch

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.logic import reference_payoneer_program as logic
from tests.utils.factories import ReferencePayoneerProgramFactory


@patch('abacus_account.logic.reference_payoneer_program.models')
def test_get_payoneer_programs(mock_models):
    """Test get_payoneer_programs."""
    payoneer_programs = [
        ReferencePayoneerProgramFactory.create(),
        ReferencePayoneerProgramFactory.create()
    ]
    mock_query = mock_models.ReferencePayoneerProgram.query
    mock_query.all.return_value = payoneer_programs
    mock_query.count.return_value = len(payoneer_programs)

    res = logic.get_payoneer_programs()
    assert res.status == 200
    assert len(res.message['items']) == 2
    assert res.message['total_count'] == 2


@patch('abacus_account.logic.reference_payoneer_program.models')
def test_get_payoneer_program(mock_models):
    """Test get_payoneer_program."""
    payoneer_program = ReferencePayoneerProgramFactory.create()

    mock_models.ReferencePayoneerProgram.\
        get_payoneer_program_by_params.return_value = payoneer_program

    res = logic.get_payoneer_program(
        payment_entity_id=1,
        currency_code='USD',
        agreement_type_id=1
    )
    assert res.status == 200

    assert res.message == {
        '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,
    }
    mock_models.ReferencePayoneerProgram.get_payoneer_program_by_params \
        .assert_called_once_with(
            currency_code='USD',
            agreement_type_id=1,
            payment_entity_id=1,
            reference_payment_type_id=None
        )


@patch('abacus_account.logic.reference_payoneer_program.models')
def test_get_payoneer_program_with_payment_type(mock_models):
    """Test get_payoneer_program."""
    payoneer_program = ReferencePayoneerProgramFactory.create()

    mock_models.ReferencePayoneerProgram.\
        get_payoneer_program_by_params.return_value = payoneer_program

    res = logic.get_payoneer_program(
        payment_entity_id=1,
        currency_code='USD',
        agreement_type_id=1,
        reference_payment_type_id=2
    )
    assert res.status == 200

    assert res.message == {
        '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,
    }
    mock_models.ReferencePayoneerProgram.get_payoneer_program_by_params \
        .assert_called_once_with(
            currency_code='USD',
            agreement_type_id=1,
            payment_entity_id=1,
            reference_payment_type_id=2
        )


_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']


def _make_program(mock_query, from_type_id, to_type_id):
    """Set up mock programs for move type tests."""
    from_program = ReferencePayoneerProgramFactory.build(
        payoneer_program_id=100,
        reference_payment_type_id=from_type_id,
    )
    to_program = ReferencePayoneerProgramFactory.build(
        payoneer_program_id=200,
        reference_payment_type_id=to_type_id,
    )
    mock_query.get.side_effect = lambda pid: {
        100: from_program,
        200: to_program,
    }.get(pid)
    return from_program, to_program


@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'),
    ],
)
@patch('abacus_account.logic.reference_payoneer_program.models')
def test_get_payoneer_program_move_type(
    mock_models, from_type, to_type, expected_move_type
):
    """Test move type resolution for all supported transitions."""
    mock_query = mock_models.ReferencePayoneerProgram.query
    _make_program(mock_query, from_type, to_type)

    res = logic.get_payoneer_program_move_type(
        from_program_id=100, to_program_id=200
    )
    assert res.status == 200
    assert res.message == {'move_type': expected_move_type}


def test_get_payoneer_program_move_type_same_program():
    """Test move type returns 400 when from and to program are the same."""
    res = logic.get_payoneer_program_move_type(
        from_program_id=100, to_program_id=100
    )
    assert res.status == 400


@patch('abacus_account.logic.reference_payoneer_program.models')
def test_get_payoneer_program_move_type_from_not_found(mock_models):
    """Test move type when from_program_id does not exist."""
    mock_models.ReferencePayoneerProgram.query.get.return_value = None

    res = logic.get_payoneer_program_move_type(
        from_program_id=999, to_program_id=200
    )
    assert res.status == 404


@patch('abacus_account.logic.reference_payoneer_program.models')
def test_get_payoneer_program_move_type_to_not_found(mock_models):
    """Test move type when to_program_id does not exist."""
    from_program = ReferencePayoneerProgramFactory.build(
        payoneer_program_id=100,
        reference_payment_type_id=_PAYONEER,
    )
    mock_models.ReferencePayoneerProgram.query.get.side_effect = \
        lambda pid: from_program if pid == 100 else None

    res = logic.get_payoneer_program_move_type(
        from_program_id=100, to_program_id=999
    )
    assert res.status == 404