"""Report Payment Logic Unit Tests."""

from unittest.mock import call, MagicMock, patch

import pytest  # added for new negative test

from payment.constants.constants import REPORT_TYPE
from payment.logic import report_payment as logic
from tests.utils.factories import ReportPaymentFactory


@patch('payment.logic.report_payment.ReportPayment')
def test_create_or_update_report_payment_create(mock_model) -> None:
    """Test for creation."""
    mock_model.get_by_target_and_type.return_value = None
    mock_report = ReportPaymentFactory.build()
    mock_created_report = ReportPaymentFactory.create()
    mock_model.create.return_value = mock_created_report
    result = logic.create_or_update_report_payment(
        target_type=mock_report.target_type,
        target_id=mock_report.target_id,
        report_type=mock_report.report_type,
        report_export_url=mock_report.report_export_url,
    )
    assert mock_model.get_by_target_and_type.call_args_list == [
        call(
            target_type=mock_report.target_type,
            target_id=mock_report.target_id,
            report_type=mock_report.report_type,
        )
    ]
    assert mock_model.create.call_args_list == [
        call(
            target_type=mock_report.target_type,
            target_id=mock_report.target_id,
            report_type=mock_report.report_type,
            report_export_url=mock_report.report_export_url,
        )
    ]
    assert result == mock_created_report


@patch('payment.logic.report_payment.ReportPayment')
def test_create_or_update_report_payment_update(mock_model, faker) -> None:
    """Test for update."""
    new_url = faker.url()
    mock_existing_report = ReportPaymentFactory.create()
    mock_model.get_by_target_and_type.return_value = mock_existing_report
    result = logic.create_or_update_report_payment(
        target_type=mock_existing_report.target_type,
        target_id=mock_existing_report.target_id,
        report_type=mock_existing_report.report_type,
        report_export_url=new_url,
    )
    assert mock_model.get_by_target_and_type.call_args_list == [
        call(
            target_type=mock_existing_report.target_type,
            target_id=mock_existing_report.target_id,
            report_type=mock_existing_report.report_type,
        )
    ]
    assert mock_model.commit_changes.called
    assert not mock_model.create.called
    assert result == mock_existing_report
    assert result.report_export_url == new_url


@patch('payment.logic.report_payment.ReportPayment')
def test_get_reports_by_target(mock_model, faker) -> None:
    """Test for get_reports_by_target."""
    mock_reports = [
        ReportPaymentFactory.create(report_type=REPORT_TYPE.APPROVAL),
    ]
    mock_model.get_all_by_target.return_value = mock_reports
    target_type = faker.word()
    target_id = faker.pyint()

    result = logic.get_reports_by_target(
        target_type=target_type,
        target_id=target_id,
    )

    assert mock_model.get_all_by_target.call_args_list == [
        call(
            target_type=target_type,
            target_id=target_id,
        )
    ]
    assert result == mock_reports


@patch('payment.logic.report_payment.ReportPayment')
def test_get_download_success(mock_model, faker) -> None:
    """Test for get_download."""
    mock_report = MagicMock()
    mock_report.report_payment_id = faker.pyint()
    mock_report.create_presigned_url.return_value = faker.url()
    mock_model.get_by_id_or_error.return_value = mock_report

    result = logic.get_download(report_payment_id=mock_report.report_payment_id)

    assert mock_model.get_by_id_or_error.call_args_list == [
        call(mock_report.report_payment_id)
    ]
    assert mock_report.create_presigned_url.called
    assert result == {'download_url': mock_report.create_presigned_url.return_value}


@patch('payment.logic.report_payment.ReportPayment')
def test_get_download_failure_not_found(mock_model, faker) -> None:
    """Test get_download propagates error when object not found."""
    report_payment_id = faker.pyint()
    mock_model.get_by_id_or_error.side_effect = Exception('Not found')

    with pytest.raises(Exception, match='Not found') as exc:
        logic.get_download(report_payment_id=report_payment_id)

    assert mock_model.get_by_id_or_error.call_args_list == [call(report_payment_id)]


@patch('payment.logic.report_payment.ReportPayment')
def test_get_report_payment_success(mock_model, faker) -> None:
    """Test for get_report_payment."""
    mock_report = ReportPaymentFactory.create()
    mock_model.get_by_id_or_error.return_value = mock_report

    result = logic.get_report_payment(report_payment_id=mock_report.report_payment_id)

    assert mock_model.get_by_id_or_error.call_args_list == [
        call(mock_report.report_payment_id)
    ]
    assert result == mock_report


@patch('payment.logic.report_payment.ReportPayment')
def test_get_report_payment_failure_not_found(mock_model, faker) -> None:
    """Test get_report_payment propagates error when object not found."""
    report_payment_id = faker.pyint()
    mock_model.get_by_id_or_error.side_effect = Exception('Not found')

    with pytest.raises(Exception, match='Not found') as exc:
        logic.get_report_payment(report_payment_id=report_payment_id)

    assert mock_model.get_by_id_or_error.call_args_list == [call(report_payment_id)]