import uuid
import logging
from yookassa import Configuration, Payment
from yookassa.domain.request.payment_request_builder import PaymentRequestBuilder

from typing import Optional, Dict, Any, List

from config.settings import Settings


class YooKassaService:

    def __init__(self,
                 shop_id: Optional[str],
                 secret_key: Optional[str],
                 configured_return_url: Optional[str],
                 bot_username_for_default: Optional[str] = None,
                 settings_obj: Optional[Settings] = None):
        self.settings = settings_obj

        if not shop_id or not secret_key:
            logging.warning(
                "YooKassa SHOP_ID or SECRET_KEY not configured. Payment functionality will be disabled."
            )
            self.configured = False
        else:
            Configuration.account_id = shop_id
            Configuration.secret_key = secret_key
            self.configured = True
            logging.info(f"YooKassa configured for shop_id: {shop_id}")

        if configured_return_url:
            self.return_url = configured_return_url
        elif bot_username_for_default:
            self.return_url = f"https://t.me/{bot_username_for_default}"
            logging.info(
                f"YOOKASSA_RETURN_URL not set, using dynamic default: {self.return_url}"
            )
        else:
            self.return_url = "https://example.com/payment_error_no_return_url"
            logging.warning(
                f"YOOKASSA_RETURN_URL not set AND bot username not provided. Using placeholder: {self.return_url}"
            )
        logging.info(
            f"YooKassa Service effective return_url: {self.return_url}")

    async def create_payment(
            self, amount: float, currency: str, description: str,
            metadata: Dict[str, Any]) -> Optional[Dict[str, Any]]:
        if not self.configured:
            logging.error("YooKassa is not configured. Cannot create payment.")
            return None

        if not self.settings:
            logging.error(
                "YooKassaService: Settings object not available for receipt creation."
            )
            return {
                "error": True,
                "internal_message": "Service settings not initialized."
            }

        if not self.settings.YOOKASSA_DEFAULT_RECEIPT_EMAIL:
            logging.error(
                "CRITICAL: YOOKASSA_DEFAULT_RECEIPT_EMAIL is not configured. YooKassa payment will fail due to missing receipt customer contact."
            )
            return {
                "error":
                True,
                "internal_message":
                "YooKassa receipt email not configured by admin."
            }

        try:
            builder = PaymentRequestBuilder()
            builder.set_amount({
                "value": str(round(amount, 2)),
                "currency": currency.upper()
            })
            builder.set_capture(True)
            builder.set_confirmation({
                "type": "redirect",
                "return_url": self.return_url
            })
            builder.set_description(description)
            builder.set_metadata(metadata)

            receipt_items: List[Dict[str, Any]] = [{
                "description":
                description,
                "quantity":
                "1.00",
                "amount": {
                    "value": str(round(amount, 2)),
                    "currency": currency.upper()
                },
                "vat_code":
                str(self.settings.YOOKASSA_VAT_CODE),
                "payment_mode":
                self.settings.YOOKASSA_PAYMENT_MODE,
                "payment_subject":
                self.settings.YOOKASSA_PAYMENT_SUBJECT
            }]

            receipt_customer: Dict[str, str] = {}
            if self.settings.YOOKASSA_DEFAULT_RECEIPT_EMAIL:
                receipt_customer[
                    "email"] = self.settings.YOOKASSA_DEFAULT_RECEIPT_EMAIL

            if not receipt_customer:
                logging.error(
                    "YooKassa: No customer contact (email/phone) for receipt.")
                return {
                    "error": True,
                    "internal_message": "Receipt customer contact missing."
                }

            receipt_payload: Dict[str, Any] = {
                "customer": receipt_customer,
                "items": receipt_items
            }

            builder.set_receipt(receipt_payload)

            idempotence_key = str(uuid.uuid4())
            payment_request = builder.build()

            logging.info(
                f"Creating YooKassa payment (IDK: {idempotence_key}) with receipt. Email: {self.settings.YOOKASSA_DEFAULT_RECEIPT_EMAIL}"
            )

            res = Payment.create(payment_request, idempotence_key)
            logging.info(
                f"YooKassa Payment.create response: ID={res.id}, Status={res.status}"
            )

            return {
                "id":
                res.id,
                "confirmation_url":
                res.confirmation.confirmation_url
                if res.confirmation else None,
                "status":
                res.status,
                "metadata":
                res.metadata,
                "amount_value":
                float(res.amount.value),
                "amount_currency":
                res.amount.currency,
                "idempotence_key":
                idempotence_key,
                "paid":
                res.paid,
                "refundable":
                res.refundable,
                "created_at":
                res.created_at.isoformat() if hasattr(
                    res.created_at, 'isoformat') else str(res.created_at)
            }
        except Exception as e:
            logging.error(f"YooKassa payment creation failed: {e}",
                          exc_info=True)
            return None

    async def get_payment_info(self,
                               payment_id: str) -> Optional[Dict[str, Any]]:
        if not self.configured:
            logging.error(
                "YooKassa is not configured. Cannot get payment info.")
            return None
        try:
            payment_info = Payment.find_one(payment_id)
            if payment_info:
                return {
                    "id": payment_info.id,
                    "status": payment_info.status,
                    "paid": payment_info.paid,
                    "amount_value": float(payment_info.amount.value),
                    "amount_currency": payment_info.amount.currency,
                    "metadata": payment_info.metadata,
                    "description": payment_info.description,
                }
            return None
        except Exception as e:
            logging.error(
                f"YooKassa get payment info for {payment_id} failed: {e}")
            return None