# app/modules/payments/routes/api/store.py
"""
Store payment configuration and processing endpoints.

Store Context: Uses token_store_id from JWT token (authenticated store API pattern).
The get_current_store_api dependency guarantees token_store_id is present.

Provides:
- Payment gateway configuration
- Stripe connect/disconnect
- Payment methods listing
- Transaction history
- Payment balance
- Refund processing
"""

import logging

from fastapi import APIRouter, Depends
from sqlalchemy.orm import Session

from app.api.deps import get_current_store_api, require_module_access
from app.core.database import get_db
from app.modules.enums import FrontendType
from app.modules.payments.schemas import (
    PaymentBalanceResponse,
    PaymentConfigResponse,
    PaymentConfigUpdate,
    PaymentConfigUpdateResponse,
    PaymentMethodsResponse,
    StripeConnectRequest,
    StripeConnectResponse,
    StripeDisconnectResponse,
    TransactionsResponse,
)
from app.modules.payments.schemas import (
    PaymentRefundRequest as RefundRequest,
)
from app.modules.payments.schemas import (
    PaymentRefundResponse as RefundResponse,
)
from app.modules.tenancy.schemas.auth import UserContext
from app.modules.tenancy.services.store_service import store_service

router = APIRouter(
    prefix="/payments",
    dependencies=[Depends(require_module_access("payments", FrontendType.STORE))],
)
logger = logging.getLogger(__name__)


@router.get("/config", response_model=PaymentConfigResponse)
def get_payment_configuration(
    current_user: UserContext = Depends(get_current_store_api),
    db: Session = Depends(get_db),
):
    """
    Get store payment configuration.

    TODO: Implement in Slice 5
    - Get payment gateway settings (Stripe, PayPal, etc.)
    - Get accepted payment methods
    - Get currency settings
    - Return masked/secure information only
    """
    store = store_service.get_store_by_id(db, current_user.token_store_id)  # noqa: F841
    return PaymentConfigResponse(
        payment_gateway=None,
        accepted_methods=[],
        currency="EUR",
        stripe_connected=False,
        message="Payment configuration coming in Slice 5",
    )


@router.put("/config", response_model=PaymentConfigUpdateResponse)
def update_payment_configuration(
    payment_config: PaymentConfigUpdate,
    current_user: UserContext = Depends(get_current_store_api),
    db: Session = Depends(get_db),
):
    """
    Update store payment configuration.

    TODO: Implement in Slice 5
    - Update payment gateway settings
    - Connect/disconnect Stripe account
    - Update accepted payment methods
    - Validate configuration before saving
    """
    store = store_service.get_store_by_id(db, current_user.token_store_id)  # noqa: F841
    return PaymentConfigUpdateResponse(
        message="Payment configuration update coming in Slice 5"
    )


@router.post("/stripe/connect", response_model=StripeConnectResponse)
def connect_stripe_account(
    stripe_data: StripeConnectRequest,
    current_user: UserContext = Depends(get_current_store_api),
    db: Session = Depends(get_db),
):
    """
    Connect Stripe account for payment processing.

    TODO: Implement in Slice 5
    - Handle Stripe OAuth flow
    - Store Stripe account ID securely
    - Verify Stripe account is active
    - Enable payment processing
    """
    store = store_service.get_store_by_id(db, current_user.token_store_id)  # noqa: F841
    return StripeConnectResponse(message="Stripe connection coming in Slice 5")


@router.delete("/stripe/disconnect", response_model=StripeDisconnectResponse)
def disconnect_stripe_account(
    current_user: UserContext = Depends(get_current_store_api),
    db: Session = Depends(get_db),
):
    """
    Disconnect Stripe account.

    TODO: Implement in Slice 5
    - Remove Stripe account connection
    - Disable payment processing
    - Warn about pending payments
    """
    store = store_service.get_store_by_id(db, current_user.token_store_id)  # noqa: F841
    return StripeDisconnectResponse(message="Stripe disconnection coming in Slice 5")


@router.get("/methods", response_model=PaymentMethodsResponse)
def get_payment_methods(
    current_user: UserContext = Depends(get_current_store_api),
    db: Session = Depends(get_db),
):
    """
    Get accepted payment methods for store.

    TODO: Implement in Slice 5
    - Return list of enabled payment methods
    - Include: credit card, PayPal, bank transfer, etc.
    """
    store = store_service.get_store_by_id(db, current_user.token_store_id)  # noqa: F841
    return PaymentMethodsResponse(
        methods=[],
        message="Payment methods coming in Slice 5",
    )


@router.get("/transactions", response_model=TransactionsResponse)
def get_payment_transactions(
    current_user: UserContext = Depends(get_current_store_api),
    db: Session = Depends(get_db),
):
    """
    Get payment transaction history.

    TODO: Implement in Slice 5
    - Get all payment transactions for store
    - Filter by date range, status, etc.
    - Include payment details
    - Support pagination
    """
    store = store_service.get_store_by_id(db, current_user.token_store_id)  # noqa: F841
    return TransactionsResponse(
        transactions=[],
        total=0,
        message="Payment transactions coming in Slice 5",
    )


@router.get("/balance", response_model=PaymentBalanceResponse)
def get_payment_balance(
    current_user: UserContext = Depends(get_current_store_api),
    db: Session = Depends(get_db),
):
    """
    Get store payment balance and payout information.

    TODO: Implement in Slice 5
    - Get available balance
    - Get pending balance
    - Get next payout date
    - Get payout history
    """
    store = store_service.get_store_by_id(db, current_user.token_store_id)  # noqa: F841
    return PaymentBalanceResponse(
        available_balance=0.0,
        pending_balance=0.0,
        currency="EUR",
        next_payout_date=None,
        message="Payment balance coming in Slice 5",
    )


@router.post("/refund/{payment_id}", response_model=RefundResponse)
def refund_payment(
    payment_id: int,
    refund_data: RefundRequest,
    current_user: UserContext = Depends(get_current_store_api),
    db: Session = Depends(get_db),
):
    """
    Process payment refund.

    TODO: Implement in Slice 5
    - Verify payment belongs to store
    - Process refund through payment gateway
    - Update order status
    - Send refund notification to customer
    """
    store = store_service.get_store_by_id(db, current_user.token_store_id)  # noqa: F841
    return RefundResponse(message="Payment refund coming in Slice 5")