from datetime import datetime, timedelta, timezone
from types import SimpleNamespace
from uuid import uuid4

import pytest
from pytest_mock.plugin import MockerFixture

from lnbits.core.crud import (
    create_account,
    create_payment,
    create_wallet,
    get_payment,
    get_payments,
    update_payment,
)
from lnbits.core.models import (
    Account,
    CreateInvoice,
    CreatePayment,
    PaymentState,
    Wallet,
)
from lnbits.core.services.payments import (
    calculate_fiat_amounts,
    cancel_hold_invoice,
    check_payment_status,
    check_pending_payments,
    check_time_limit_between_transactions,
    check_transaction_status,
    check_wallet_limits,
    create_payment_request,
    get_payments_daily_stats,
    settle_hold_invoice,
    update_pending_payment,
    update_pending_payments,
    update_wallet_balance,
)
from lnbits.db import Filters
from lnbits.exceptions import InvoiceError, PaymentError
from lnbits.settings import Settings
from lnbits.wallets.base import (
    InvoiceResponse,
    PaymentFailedStatus,
    PaymentPendingStatus,
    PaymentSuccessStatus,
)


@pytest.mark.anyio
async def test_create_payment_request_routes_by_invoice_type(mocker: MockerFixture):
    wallet_payment = SimpleNamespace(checking_id="wallet")
    fiat_payment = SimpleNamespace(checking_id="fiat")
    wallet_mock = mocker.patch(
        "lnbits.core.services.payments.create_wallet_invoice",
        mocker.AsyncMock(return_value=wallet_payment),
    )
    fiat_mock = mocker.patch(
        "lnbits.core.services.payments.create_fiat_invoice",
        mocker.AsyncMock(return_value=fiat_payment),
    )

    assert (
        await create_payment_request("wallet-1", CreateInvoice(amount=1))
        == wallet_payment
    )
    assert (
        await create_payment_request(
            "wallet-1",
            CreateInvoice(amount=1, fiat_provider="stripe"),
        )
        == fiat_payment
    )
    wallet_mock.assert_awaited_once()
    fiat_mock.assert_awaited_once()


@pytest.mark.anyio
async def test_update_pending_payment_and_bulk_pending_updates(mocker: MockerFixture):
    wallet = await _create_wallet()
    failed_id = await _create_payment(wallet)
    success_id = await _create_payment(wallet)
    failed_payment = await get_payment(failed_id)
    success_payment = await get_payment(success_id)

    mocker.patch(
        "lnbits.core.services.payments.check_payment_status",
        mocker.AsyncMock(side_effect=[PaymentFailedStatus(), PaymentSuccessStatus()]),
    )

    await update_pending_payment(failed_payment)
    await update_pending_payment(success_payment)

    assert (await get_payment(failed_id)).status == PaymentState.FAILED
    assert (await get_payment(success_id)).status == PaymentState.SUCCESS

    bulk_wallet = await _create_wallet()
    bulk_failed_id = await _create_payment(bulk_wallet)
    bulk_success_id = await _create_payment(bulk_wallet)
    mocker.patch(
        "lnbits.core.services.payments.check_payment_status",
        mocker.AsyncMock(side_effect=[PaymentFailedStatus(), PaymentSuccessStatus()]),
    )

    await update_pending_payments(bulk_wallet.id)

    bulk_statuses = {
        (await get_payment(bulk_failed_id)).status,
        (await get_payment(bulk_success_id)).status,
    }
    assert bulk_statuses == {PaymentState.FAILED, PaymentState.SUCCESS}


@pytest.mark.anyio
async def test_check_pending_payments_skips_voidwallet_and_updates_recent_items(
    mocker: MockerFixture,
):
    class VoidWallet:
        pass

    class FakeWalletSource:
        pass

    mocker.patch(
        "lnbits.core.services.payments.get_funding_source",
        return_value=VoidWallet(),
    )
    sleep_mock = mocker.patch(
        "lnbits.core.services.payments.asyncio.sleep", mocker.AsyncMock()
    )

    await check_pending_payments()
    sleep_mock.assert_not_awaited()

    existing_pending = await get_payments(pending=True, exclude_uncheckable=True)
    wallet = await _create_wallet()
    checking_id = await _create_payment(wallet)
    mocker.patch(
        "lnbits.core.services.payments.get_funding_source",
        return_value=FakeWalletSource(),
    )
    mocker.patch(
        "lnbits.core.services.payments.check_payment_status",
        mocker.AsyncMock(return_value=PaymentSuccessStatus()),
    )

    try:
        await check_pending_payments()
    finally:
        for payment in existing_pending:
            payment.status = PaymentState.PENDING
            await update_payment(payment)

    assert (await get_payment(checking_id)).status == PaymentState.SUCCESS
    assert sleep_mock.await_count >= 1


@pytest.mark.anyio
async def test_update_wallet_balance_validates_credit_and_debit(
    settings: Settings, mocker: MockerFixture
):
    wallet = await _create_wallet()
    wallet.balance_msat = 20_000

    with pytest.raises(ValueError, match="Amount cannot be 0."):
        await update_wallet_balance(wallet, 0)

    with pytest.raises(ValueError, match="can not go into negative balance"):
        await update_wallet_balance(wallet, -30)

    payment_secret = (uuid4().hex * 2)[:64]
    payment_hash = (uuid4().hex * 2)[:64]
    mocker.patch(
        "lnbits.core.services.payments.random_secret_and_hash",
        return_value=(payment_secret, payment_hash),
    )
    mocker.patch(
        "lnbits.core.services.payments.fake_privkey",
        return_value="privkey",
    )
    mocker.patch(
        "lnbits.core.services.payments.bolt11_encode",
        return_value="encoded-bolt11",
    )

    await update_wallet_balance(wallet, -10)

    debit_payment = await get_payment("internal_" + payment_hash)
    assert debit_payment is not None
    assert debit_payment.amount == -10_000
    assert debit_payment.status == PaymentState.SUCCESS

    original_max_balance = settings.lnbits_wallet_limit_max_balance
    try:
        settings.lnbits_wallet_limit_max_balance = 21
        with pytest.raises(ValueError, match="amount exceeds maximum balance"):
            await update_wallet_balance(wallet, 5)

        settings.lnbits_wallet_limit_max_balance = 0
        queue_mock = mocker.patch(
            "lnbits.tasks.internal_invoice_queue_put",
            mocker.AsyncMock(),
        )

        await update_wallet_balance(wallet, 5)
    finally:
        settings.lnbits_wallet_limit_max_balance = original_max_balance

    credit_payments = [
        payment
        for payment in await get_payments(wallet_id=wallet.id, incoming=True)
        if payment.memo == "Admin credit"
    ]
    assert credit_payments
    assert credit_payments[0].status == PaymentState.SUCCESS
    queue_mock.assert_awaited_once_with(credit_payments[0].checking_id)


@pytest.mark.anyio
async def test_check_wallet_limits_and_time_limit(
    settings: Settings, mocker: MockerFixture
):
    time_limit_mock = mocker.patch(
        "lnbits.core.services.payments.check_time_limit_between_transactions",
        mocker.AsyncMock(),
    )
    daily_limit_mock = mocker.patch(
        "lnbits.core.services.payments.check_wallet_daily_withdraw_limit",
        mocker.AsyncMock(),
    )

    await check_wallet_limits("wallet-1", 1_000)

    time_limit_mock.assert_awaited_once_with("wallet-1", None)
    daily_limit_mock.assert_awaited_once_with("wallet-1", 1_000, None)

    wallet = await _create_wallet()
    await _create_payment(wallet, amount_msat=-2_000)
    original_limit = settings.lnbits_wallet_limit_secs_between_trans
    try:
        settings.lnbits_wallet_limit_secs_between_trans = 30
        with pytest.raises(PaymentError) as exc_info:
            await check_time_limit_between_transactions(wallet.id)
        assert "30 seconds between payments" in exc_info.value.message

        other_wallet = await _create_wallet()
        assert await check_time_limit_between_transactions(other_wallet.id) is None
    finally:
        settings.lnbits_wallet_limit_secs_between_trans = original_limit


@pytest.mark.anyio
async def test_calculate_fiat_amounts_handles_conversion_and_errors(
    mocker: MockerFixture,
):
    wallet = await _create_wallet()
    wallet.currency = "EUR"
    mocker.patch(
        "lnbits.core.services.payments.fiat_amount_as_satoshis",
        mocker.AsyncMock(return_value=200),
    )
    sat_to_fiat_mock = mocker.patch(
        "lnbits.core.services.payments.satoshis_amount_as_fiat",
        mocker.AsyncMock(return_value=1.5),
    )

    amount_sat, fiat_amounts = await calculate_fiat_amounts(2.0, wallet, "USD")

    assert amount_sat == 200
    assert fiat_amounts["fiat_currency"] == "USD"
    assert fiat_amounts["wallet_fiat_currency"] == "EUR"
    assert fiat_amounts["wallet_fiat_amount"] == 1.5

    sat_to_fiat_mock.side_effect = Exception("boom")
    amount_sat, fiat_amounts = await calculate_fiat_amounts(10, wallet, "sat", extra={})

    assert amount_sat == 10
    assert fiat_amounts == {}


@pytest.mark.anyio
async def test_check_transaction_status_and_payment_status(mocker: MockerFixture):
    wallet = await _create_wallet()
    missing_hash = uuid4().hex
    assert (await check_transaction_status(wallet.id, missing_hash)).pending is True

    success_hash = uuid4().hex
    success_id = await _create_payment(
        wallet,
        status=PaymentState.SUCCESS,
        payment_hash=success_hash,
        fee=-123,
    )
    success_status = await check_transaction_status(wallet.id, success_hash)
    assert success_status.success is True
    assert success_status.fee_msat == -123

    pending_hash = uuid4().hex
    await _create_payment(wallet, payment_hash=pending_hash)
    mocker.patch(
        "lnbits.core.services.payments.check_payment_status",
        mocker.AsyncMock(return_value=PaymentFailedStatus()),
    )
    assert (await check_transaction_status(wallet.id, pending_hash)).failed is True

    internal_success = await get_payment(success_id)
    internal_success.checking_id = "internal_" + internal_success.payment_hash
    internal_success.status = PaymentState.SUCCESS.value
    assert (await check_payment_status(internal_success)).success is True

    internal_failed = await get_payment(success_id)
    internal_failed.checking_id = "internal_" + internal_failed.payment_hash
    internal_failed.status = PaymentState.FAILED.value
    assert (await check_payment_status(internal_failed)).failed is True

    internal_fiat = await get_payment(success_id)
    internal_fiat.checking_id = "fiat_" + internal_fiat.payment_hash
    internal_fiat.status = PaymentState.PENDING.value
    internal_fiat.fiat_provider = "stripe"
    mocker.patch(
        "lnbits.core.services.payments.check_fiat_status",
        mocker.AsyncMock(return_value=SimpleNamespace(paid=True)),
    )
    assert (await check_payment_status(internal_fiat)).success is True

    outgoing = await get_payment(success_id)
    outgoing.checking_id = "external-out"
    outgoing.amount = -2_000
    incoming = await get_payment(success_id)
    incoming.checking_id = "external-in"
    incoming.amount = 2_000
    funding_source = SimpleNamespace(
        get_payment_status=mocker.AsyncMock(return_value=PaymentSuccessStatus()),
        get_invoice_status=mocker.AsyncMock(return_value=PaymentPendingStatus()),
    )
    mocker.patch(
        "lnbits.core.services.payments.get_funding_source",
        return_value=funding_source,
    )

    assert (await check_payment_status(outgoing)).success is True
    assert (await check_payment_status(incoming)).pending is True


@pytest.mark.anyio
async def test_get_payments_daily_stats_fills_missing_dates():
    wallet = await _create_wallet()
    user_id = wallet.user
    now = datetime.now(timezone.utc).replace(hour=12, minute=0, second=0, microsecond=0)
    await _create_payment(
        wallet,
        amount_msat=2_000,
        status=PaymentState.SUCCESS,
        time=now - timedelta(days=2),
    )
    await _create_payment(
        wallet,
        amount_msat=-500,
        status=PaymentState.SUCCESS,
        fee=100,
        time=now,
    )

    stats = await get_payments_daily_stats(Filters(), user_id=user_id)

    assert [point.date.date() for point in stats[-3:]] == [
        (now - timedelta(days=2)).date(),
        (now - timedelta(days=1)).date(),
        now.date(),
    ]
    assert [point.balance for point in stats[-3:]] == [2, 2, 1]
    assert stats[-1].fee == 0


@pytest.mark.anyio
async def test_settle_and_cancel_hold_invoice_persist_status(mocker: MockerFixture):
    wallet = await _create_wallet()
    checking_id = await _create_payment(wallet, payment_hash="33" * 32)
    payment = await get_payment(checking_id)
    funding_source = SimpleNamespace(
        settle_hold_invoice=mocker.AsyncMock(
            return_value=InvoiceResponse(ok=True, checking_id="settled")
        ),
        cancel_hold_invoice=mocker.AsyncMock(
            return_value=InvoiceResponse(ok=True, checking_id="cancelled")
        ),
    )
    mocker.patch(
        "lnbits.core.services.payments.get_funding_source",
        return_value=funding_source,
    )
    mocker.patch(
        "lnbits.core.services.payments.verify_preimage",
        return_value=False,
    )

    with pytest.raises(InvoiceError, match="Invalid preimage."):
        await settle_hold_invoice(payment, "00" * 32)

    mocker.patch(
        "lnbits.core.services.payments.verify_preimage",
        return_value=True,
    )

    assert (await settle_hold_invoice(payment, "11" * 32)).ok is True
    assert (await cancel_hold_invoice(payment)).ok is True

    stored = await get_payment(checking_id)
    assert stored.preimage == "11" * 32
    assert stored.extra["hold_invoice_settled"] is True
    assert stored.extra["hold_invoice_cancelled"] is True
    assert stored.status == PaymentState.FAILED


def _account() -> Account:
    account_id = uuid4().hex
    return Account(id=account_id, username=f"user_{account_id[:8]}")


async def _create_wallet() -> Wallet:
    account = _account()
    await create_account(account)
    return await create_wallet(
        user_id=account.id, wallet_name=f"wallet_{account.id[:8]}"
    )


async def _create_payment(
    wallet: Wallet,
    *,
    amount_msat: int = 2_000,
    status: PaymentState = PaymentState.PENDING,
    checking_id: str | None = None,
    payment_hash: str | None = None,
    fee: int = 0,
    time: datetime | None = None,
) -> str:
    checking_id = checking_id or f"checking_{uuid4().hex[:8]}"
    payment_hash = payment_hash or uuid4().hex
    payment = await create_payment(
        checking_id=checking_id,
        data=CreatePayment(
            wallet_id=wallet.id,
            payment_hash=payment_hash,
            bolt11=f"bolt11-{checking_id}",
            amount_msat=amount_msat,
            memo="memo",
            fee=fee,
        ),
        status=status,
    )
    if time:
        payment.time = time
        payment.created_at = time
        payment.updated_at = time
        await update_payment(payment)
    return checking_id