"""Tests for Payment Minimum handlers."""

from unittest.mock import call, patch

from flask import abort

from payment.blueprints.payment_minimum import (
    PaymentMinimumListSchema,
    PaymentMinimumPutSchema,
    PaymentMinimumSchema,
)
from payment.models.generic import Items
from tests.utils.factories import PaymentMinimumFactory


@patch('payment.blueprints.payment_minimum.logic.get_payment_minimum')
def test_get_payment_minimum_success(mock_logic, fixture_client, mocker):
    """Test GET /payment-minimums/<currency_code> returns 200."""
    mock_minimum = PaymentMinimumFactory.build(currency_code='USD')
    mock_logic.return_value = mock_minimum
    spy_serialization = mocker.spy(PaymentMinimumSchema, 'dump')

    resp = fixture_client.get('/payment-minimums/usd')

    assert resp.status_code == 200
    assert resp.json['currency_code'] == 'USD'
    assert spy_serialization.called
    assert mock_logic.call_args_list == [call('usd')]


@patch('payment.blueprints.payment_minimum.logic.get_payment_minimum')
def test_get_payment_minimum_not_found(mock_logic, fixture_client):
    """Test GET /payment-minimums/<currency_code> returns 404 when not found."""
    mock_logic.side_effect = lambda *args, **kwargs: abort(404)

    resp = fixture_client.get('/payment-minimums/aaa')

    assert resp.status_code == 404
    assert mock_logic.call_args_list == [call('aaa')]


@patch('payment.blueprints.payment_minimum.logic.list_payment_minimums')
def test_list_payment_minimums_success(mock_logic, fixture_client, mocker):
    """Test GET /payment-minimums returns 200 with list of minimums."""
    mock_minimums = PaymentMinimumFactory.build_batch(3)
    mock_logic.return_value = Items(items=mock_minimums, total_count=3)
    spy_serialization = mocker.spy(PaymentMinimumListSchema, 'dump')

    resp = fixture_client.get('/payment-minimums')

    assert resp.status_code == 200
    assert resp.json['total_count'] == 3
    assert len(resp.json['items']) == 3
    assert spy_serialization.called
    assert mock_logic.call_args_list == [call()]


@patch('payment.blueprints.payment_minimum.logic.bulk_update_payment_minimums')
def test_bulk_update_minimums_success(mock_logic, fixture_client, mocker):
    """Test PUT /payment-minimums returns 201 and passes minimums to logic."""
    mock_minimums = PaymentMinimumFactory.build_batch(2)
    mock_logic.return_value = mock_minimums
    spy_validation = mocker.spy(PaymentMinimumPutSchema, 'load')
    spy_serialization = mocker.spy(PaymentMinimumSchema, 'dump')
    payload = [
        {'payment_minimum_id': 1, 'check_amount': '100.00'},
        {'payment_minimum_id': 2, 'wire_transfer_amount': '200.00'},
    ]

    resp = fixture_client.put('/payment-minimums', json=payload)

    assert resp.status_code == 201
    assert isinstance(resp.json, list)
    assert spy_validation.called
    assert spy_serialization.called
    assert mock_logic.called


@patch('payment.blueprints.payment_minimum.logic.bulk_update_payment_minimums')
def test_bulk_update_minimums_invalid_params(mock_logic, fixture_client, mocker):
    """Test PUT /payment-minimums returns 400 when payment_minimum_id is missing."""
    spy_validation = mocker.spy(PaymentMinimumPutSchema, 'load')

    resp = fixture_client.put('/payment-minimums', json=[{}])

    assert resp.status_code == 400
    assert spy_validation.called
    assert not mock_logic.called


@patch('payment.blueprints.payment_minimum.logic.get_payment_minimums_by_currency')
def test_get_payment_minimums_by_currency_success(mock_logic, fixture_client):
    """Test GET /payment-minimums/by-currency/ returns 200 with grouped amounts."""
    expected = {
        'USD': {'Check': '100.00', 'Wire Transfer': '200.00', 'Western Union': None},
    }
    mock_logic.return_value = expected

    resp = fixture_client.get('/payment-minimums/by-currency/')

    assert resp.status_code == 200
    assert resp.json == expected
    assert mock_logic.call_args_list == [call()]