from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy.orm import Session
from typing import Dict, Any
from decimal import Decimal
import uuid
from datetime import datetime

from app.db.session import get_db
from app.db.models import UserBalance, BalanceTransaction, Tenant
from app.api.deps import get_current_user
from pydantic import BaseModel

router = APIRouter()

class PaymentGatewayCreate(BaseModel):
    gateway_type: str  # "yookassa", "stripe", "paypal", "sberbank"
    amount: Decimal
    currency: str = "RUB"
    description: str
    return_url: str = None
    success_url: str = None
    failure_url: str = None

class PaymentGatewayResponse(BaseModel):
    payment_id: str
    gateway_type: str
    status: str  # "pending", "processing", "completed", "failed", "cancelled"
    payment_url: str = None
    amount: Decimal
    currency: str
    description: str
    created_at: datetime
    expires_at: datetime = None

class PaymentWebhook(BaseModel):
    payment_id: str
    gateway_type: str
    status: str
    amount: Decimal
    currency: str
    gateway_transaction_id: str
    metadata: Dict[str, Any] = {}

# Конфигурация платежных шлюзов
PAYMENT_GATEWAYS = {
    "yookassa": {
        "name": "ЮKassa",
        "logo": "https://yookassa.ru/logo.png",
        "supported_currencies": ["RUB"],
        "min_amount": Decimal("1.00"),
        "max_amount": Decimal("600000.00"),
        "fee_percent": Decimal("2.9"),
        "fee_fixed": Decimal("0"),
        "processing_time": "Мгновенно",
        "description": "Принимайте платежи картами, электронными деньгами и через интернет-банки"
    }
}

@router.get("/gateways")
def get_payment_gateways():
    """Получить список доступных платежных шлюзов"""
    return {
        "gateways": PAYMENT_GATEWAYS,
        "default_currency": "RUB",
        "supported_currencies": ["RUB", "USD", "EUR"]
    }

@router.post("/create-payment", response_model=PaymentGatewayResponse)
def create_payment(
    data: PaymentGatewayCreate,
    db: Session = Depends(get_db),
    current_user = Depends(get_current_user)
):
    """Создать платеж через выбранный шлюз"""
    
    if data.gateway_type not in PAYMENT_GATEWAYS:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Неподдерживаемый платежный шлюз"
        )
    
    gateway_config = PAYMENT_GATEWAYS[data.gateway_type]
    
    # Проверяем минимальную и максимальную суммы
    if data.amount < gateway_config["min_amount"]:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=f"Минимальная сумма для {gateway_config['name']}: {gateway_config['min_amount']} {data.currency}"
        )
    
    if data.amount > gateway_config["max_amount"]:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=f"Максимальная сумма для {gateway_config['name']}: {gateway_config['max_amount']} {data.currency}"
        )
    
    # Генерируем уникальный ID платежа
    payment_id = str(uuid.uuid4())
    
    # Интеграция с ЮKassa API
    if data.gateway_type == "yookassa":
        # В реальном проекте здесь будет создание платежа через ЮKassa API
        # Пример для демо:
        payment_url = f"https://yoomoney.ru/checkout/payments/v2/show?orderId={payment_id}"
    else:
        payment_url = None
    
    # Сохраняем информацию о платеже в базе данных
    # В реальном проекте создайте таблицу payments для хранения этой информации
    
    return PaymentGatewayResponse(
        payment_id=payment_id,
        gateway_type=data.gateway_type,
        status="pending",
        payment_url=payment_url,
        amount=data.amount,
        currency=data.currency,
        description=data.description,
        created_at=datetime.utcnow(),
        expires_at=datetime.utcnow().replace(hour=23, minute=59, second=59)
    )

@router.post("/webhook/{gateway_type}")
def payment_webhook(
    gateway_type: str,
    webhook_data: PaymentWebhook,
    db: Session = Depends(get_db)
):
    """Обработка webhook от платежного шлюза"""
    
    # В реальном проекте здесь будет:
    # 1. Проверка подписи webhook
    # 2. Валидация данных
    # 3. Обновление статуса платежа
    # 4. Пополнение баланса пользователя при успешной оплате
    
    if webhook_data.status == "completed":
        # Находим пользователя по payment_id и пополняем баланс
        # В реальном проекте это будет более сложная логика
        
        # Пример пополнения баланса:
        # balance = db.query(UserBalance).filter(...).first()
        # balance.balance += webhook_data.amount
        
        pass
    
    return {"status": "ok", "message": "Webhook processed"}

@router.get("/payment/{payment_id}")
def get_payment_status(
    payment_id: str,
    db: Session = Depends(get_db),
    current_user = Depends(get_current_user)
):
    """Получить статус платежа"""
    
    # В реальном проекте здесь будет запрос к API платежного шлюза
    # для получения актуального статуса платежа
    
    return {
        "payment_id": payment_id,
        "status": "completed",  # pending, processing, completed, failed, cancelled
        "amount": "1000.00",
        "currency": "RUB",
        "gateway_type": "yookassa",
        "created_at": datetime.utcnow().isoformat(),
        "completed_at": datetime.utcnow().isoformat()
    }