"""Unit tests for WorksheetPaymentCustom logic."""

from decimal import Decimal
from unittest.mock import call, patch

import pytest

from payment.logic.worksheet_payment_custom import (
    create_worksheet_payment_custom,
    delete_worksheet_payment_custom,
    get_worksheet_payment_custom_by_id,
)
from payment.models import WorksheetPaymentCustom
from tests.utils.factories import WorksheetPaymentCustomFactory


@patch('payment.logic.worksheet_payment_custom.WorksheetPaymentCustom')
def test_create_worksheet_payment_custom_success(mock_worksheet_model):
    """Test success execution for create_worksheet_payment_custom."""
    worksheet = WorksheetPaymentCustomFactory.build()
    mock_worksheet_model.create.return_value = worksheet

    result = create_worksheet_payment_custom(
        account_id=1,
        contract_id=1,
        currency_code='USD',
        amount=Decimal('100.00'),
        withholding_tax_amount=Decimal('-10.00'),
        withholding_tax_rate=Decimal('5.00'),
        vat_amount=Decimal('20.00'),
        vat_rate=Decimal('10.00'),
        amount_after_withholding_and_vat=Decimal('110.00'),
        activity_statement_period_id=1,
        statement_period_id=1,
        payment_name='test custom payment',
    )

    assert mock_worksheet_model.create.call_args_list == [
        call(
            account_id=1,
            contract_id=1,
            currency_code='USD',
            amount=Decimal('100.00'),
            withholding_tax_amount=Decimal('-10.00'),
            withholding_tax_rate=Decimal('5.00'),
            vat_amount=Decimal('20.00'),
            vat_rate=Decimal('10.00'),
            amount_after_withholding_and_vat=Decimal('110.00'),
            activity_statement_period_id=1,
            statement_period_id=1,
            payment_name='test custom payment',
        )
    ]
    assert isinstance(result, WorksheetPaymentCustom)
    assert result.account_id == 1
    assert result.contract_id == 1


@patch('payment.logic.worksheet_payment_custom.WorksheetPaymentCustom')
def test_create_worksheet_payment_custom_with_null_values(mock_worksheet_model):
    """Test create_worksheet_payment_custom with null optional values."""
    worksheet = WorksheetPaymentCustomFactory.build(
        withholding_tax_amount=None,
        vat_amount=None,
        amount_after_withholding_and_vat=Decimal('100.00'),
    )
    mock_worksheet_model.create.return_value = worksheet

    result = create_worksheet_payment_custom(
        account_id=1,
        contract_id=1,
        currency_code='USD',
        amount=Decimal('100.00'),
        withholding_tax_amount=None,
        withholding_tax_rate=None,
        vat_amount=None,
        vat_rate=None,
        amount_after_withholding_and_vat=Decimal('100.00'),
        activity_statement_period_id=1,
        statement_period_id=1,
        payment_name='test custom payment',
    )

    assert mock_worksheet_model.create.call_args_list == [
        call(
            account_id=1,
            contract_id=1,
            currency_code='USD',
            amount=Decimal('100.00'),
            withholding_tax_amount=None,
            withholding_tax_rate=None,
            vat_amount=None,
            vat_rate=None,
            amount_after_withholding_and_vat=Decimal('100.00'),
            activity_statement_period_id=1,
            statement_period_id=1,
            payment_name='test custom payment',
        )
    ]
    assert isinstance(result, WorksheetPaymentCustom)
    assert result.withholding_tax_amount is None
    assert result.vat_amount is None
    assert result.amount_after_withholding_and_vat == Decimal('100.00')


@patch('payment.logic.worksheet_payment_custom.WorksheetPaymentCustom')
def test_create_worksheet_payment_custom_with_positive_wht(mock_worksheet_model):
    """Test create_worksheet_payment_custom with positive WHT (correction case)."""
    worksheet = WorksheetPaymentCustomFactory.build(
        withholding_tax_amount=Decimal('10.00'),
        amount_after_withholding_and_vat=Decimal('130.00'),
    )
    mock_worksheet_model.create.return_value = worksheet

    result = create_worksheet_payment_custom(
        account_id=1,
        contract_id=1,
        currency_code='USD',
        amount=Decimal('100.00'),
        withholding_tax_amount=Decimal('10.00'),  # Positive for correction
        vat_amount=Decimal('20.00'),
        withholding_tax_rate=Decimal('5.00'),
        vat_rate=Decimal('10.00'),
        amount_after_withholding_and_vat=Decimal('130.00'),
        activity_statement_period_id=1,
        statement_period_id=1,
        payment_name='test correction payment',
    )

    assert isinstance(result, WorksheetPaymentCustom)
    assert result.withholding_tax_amount == Decimal('10.00')
    assert mock_worksheet_model.create.called


@patch('payment.logic.worksheet_payment_custom.WorksheetPaymentCustom')
def test_create_worksheet_payment_custom_with_negative_vat(mock_worksheet_model):
    """Test create_worksheet_payment_custom with negative VAT (correction case)."""
    worksheet = WorksheetPaymentCustomFactory.build(
        vat_amount=Decimal('-20.00'),
        amount_after_withholding_and_vat=Decimal('70.00'),
    )
    mock_worksheet_model.create.return_value = worksheet

    result = create_worksheet_payment_custom(
        account_id=1,
        contract_id=1,
        currency_code='USD',
        amount=Decimal('100.00'),
        withholding_tax_amount=Decimal('-10.00'),
        vat_amount=Decimal('-20.00'),  # Negative for correction
        withholding_tax_rate=Decimal('5.00'),
        vat_rate=Decimal('10.00'),
        amount_after_withholding_and_vat=Decimal('70.00'),
        activity_statement_period_id=1,
        statement_period_id=1,
        payment_name='test correction payment',
    )

    assert isinstance(result, WorksheetPaymentCustom)
    assert result.vat_amount == Decimal('-20.00')
    assert mock_worksheet_model.create.called


def test_create_worksheet_payment_custom_integration(
    mock_accounts, mock_contracts, mock_statement_periods
):
    """Test create_worksheet_payment_custom integration without mocks."""
    result = create_worksheet_payment_custom(
        account_id=1,
        contract_id=1,
        currency_code='USD',
        amount=Decimal('100.00'),
        withholding_tax_amount=Decimal('-10.00'),
        vat_amount=Decimal('20.00'),
        withholding_tax_rate=Decimal('5.00'),
        vat_rate=Decimal('10.00'),
        amount_after_withholding_and_vat=Decimal('110.00'),
        activity_statement_period_id=1,
        statement_period_id=1,
        payment_name='test custom payment',
    )

    assert isinstance(result, WorksheetPaymentCustom)
    assert result.account_id == 1
    assert result.contract_id == 1
    assert result.currency_code == 'USD'
    assert result.amount == Decimal('100.00')
    assert result.withholding_tax_amount == Decimal('-10.00')
    assert result.vat_amount == Decimal('20.00')
    assert result.withholding_tax_rate == Decimal('5.00')
    assert result.vat_rate == Decimal('10.00')
    assert result.amount_after_withholding_and_vat == Decimal('110.00')
    assert result.activity_statement_period_id == 1
    assert result.statement_period_id == 1
    assert result.payment_name == 'test custom payment'


@patch('payment.logic.worksheet_payment_custom.WorksheetPaymentCustom')
def test_get_worksheet_payment_custom_by_id_success(mock_worksheet_model):
    """Test success execution for get_worksheet_payment_custom_by_id."""
    worksheet = WorksheetPaymentCustomFactory.build(worksheet_payment_custom_id=1)
    mock_worksheet_model.get_by_id_or_error.return_value = worksheet

    result = get_worksheet_payment_custom_by_id(worksheet_payment_custom_id=1)

    assert mock_worksheet_model.get_by_id_or_error.call_args_list == [call(1)]
    assert isinstance(result, WorksheetPaymentCustom)
    assert result.worksheet_payment_custom_id == 1


@patch('payment.logic.worksheet_payment_custom.WorksheetPaymentCustom')
def test_get_worksheet_payment_custom_by_id_not_found(mock_worksheet_model):
    """Test get_worksheet_payment_custom_by_id raises error when not found."""
    mock_worksheet_model.get_by_id_or_error.side_effect = Exception(
        'WorksheetPaymentCustom with id 999 not found'
    )

    with pytest.raises(Exception) as exc_info:
        get_worksheet_payment_custom_by_id(worksheet_payment_custom_id=999)

    assert 'WorksheetPaymentCustom with id 999 not found' in str(exc_info.value)
    assert mock_worksheet_model.get_by_id_or_error.call_args_list == [call(999)]


def test_get_worksheet_payment_custom_by_id_integration(
    mock_accounts, mock_contracts, mock_statement_periods
):
    """Test get_worksheet_payment_custom_by_id integration without mocks."""
    # Create a worksheet payment custom record
    created = create_worksheet_payment_custom(
        account_id=1,
        contract_id=1,
        currency_code='USD',
        amount=Decimal('100.00'),
        withholding_tax_amount=Decimal('-10.00'),
        vat_amount=Decimal('20.00'),
        withholding_tax_rate=Decimal('5.00'),
        vat_rate=Decimal('10.00'),
        amount_after_withholding_and_vat=Decimal('110.00'),
        activity_statement_period_id=1,
        statement_period_id=1,
        payment_name='test custom payment',
    )

    # Retrieve it by ID
    result = get_worksheet_payment_custom_by_id(created.worksheet_payment_custom_id)

    assert isinstance(result, WorksheetPaymentCustom)
    assert result.worksheet_payment_custom_id == created.worksheet_payment_custom_id
    assert result.account_id == 1
    assert result.contract_id == 1
    assert result.currency_code == 'USD'
    assert result.amount == Decimal('100.00')
    assert result.withholding_tax_amount == Decimal('-10.00')
    assert result.vat_amount == Decimal('20.00')
    assert result.withholding_tax_rate == Decimal('5.00')
    assert result.vat_rate == Decimal('10.00')
    assert result.amount_after_withholding_and_vat == Decimal('110.00')
    assert result.payment_name == 'test custom payment'


def test_get_worksheet_payment_custom_by_id_integration_not_found(
    mock_accounts, mock_contracts, mock_statement_periods
):
    """Test get_worksheet_payment_custom_by_id raises error when record doesn't exist."""
    with pytest.raises(Exception):
        get_worksheet_payment_custom_by_id(worksheet_payment_custom_id=99999)


@patch('payment.logic.worksheet_payment_custom.WorksheetPaymentCustom')
def test_delete_worksheet_payment_custom_success(mock_worksheet_model):
    """Test success execution for delete_worksheet_payment_custom."""
    delete_worksheet_payment_custom(worksheet_payment_custom_id=1)

    assert mock_worksheet_model.delete_by_id_or_error.call_args_list == [call(1)]


@patch('payment.logic.worksheet_payment_custom.WorksheetPaymentCustom')
def test_delete_worksheet_payment_custom_not_found(mock_worksheet_model):
    """Test delete_worksheet_payment_custom raises error when not found."""
    from werkzeug.exceptions import NotFound

    mock_worksheet_model.delete_by_id_or_error.side_effect = NotFound(
        'WorksheetPaymentCustom with id 999 not found'
    )

    with pytest.raises(NotFound):
        delete_worksheet_payment_custom(worksheet_payment_custom_id=999)

    assert mock_worksheet_model.delete_by_id_or_error.call_args_list == [call(999)]


@patch('payment.logic.worksheet_payment_custom.WorksheetPaymentCustom')
def test_delete_worksheet_payment_custom_already_sent(mock_worksheet_model):
    """Test delete_worksheet_payment_custom raises error when payment already sent."""
    from werkzeug.exceptions import BadRequest

    mock_worksheet_model.delete_by_id_or_error.side_effect = BadRequest(
        'Cannot delete worksheet payment custom that has already been sent.'
    )

    with pytest.raises(BadRequest) as exc_info:
        delete_worksheet_payment_custom(worksheet_payment_custom_id=1)

    assert 'already been sent' in str(exc_info.value.description)
    assert mock_worksheet_model.delete_by_id_or_error.call_args_list == [call(1)]


def test_delete_worksheet_payment_custom_integration(
    mock_accounts, mock_contracts, mock_statement_periods
):
    """Test delete_worksheet_payment_custom integration without mocks."""
    # Create a worksheet payment custom record
    created = create_worksheet_payment_custom(
        account_id=1,
        contract_id=1,
        currency_code='USD',
        amount=Decimal('100.00'),
        activity_statement_period_id=1,
        statement_period_id=1,
        payment_name='test payment',
        amount_after_withholding_and_vat=Decimal('100.00'),
        withholding_tax_amount=Decimal('-10.00'),
        vat_amount=Decimal('20.00'),
        withholding_tax_rate=Decimal('5.00'),
        vat_rate=Decimal('10.00'),
    )

    worksheet_id = created.worksheet_payment_custom_id

    # Delete it
    delete_worksheet_payment_custom(worksheet_payment_custom_id=worksheet_id)

    # Verify it's deleted (should raise error when trying to get)
    with pytest.raises(Exception):
        get_worksheet_payment_custom_by_id(worksheet_payment_custom_id=worksheet_id)


def test_delete_worksheet_payment_custom_integration_not_found(
    mock_accounts, mock_contracts, mock_statement_periods
):
    """Test delete_worksheet_payment_custom raises error when record doesn't exist."""
    with pytest.raises(Exception):
        delete_worksheet_payment_custom(worksheet_payment_custom_id=99999)