backend/app/routes/user_routes.py

from fastapi import APIRouter, Depends, HTTPException
from fastapi.exceptions import HTTPException
from app.services.db_manager import DatabaseManager
from sqlalchemy.exc import SQLAlchemyError
from instance.configdb import get_database_manager
from pydantic import BaseModel
from typing import Optional
from uuid import UUID
import logging

logger = logging.getLogger(__name__)
router = APIRouter()

router = APIRouter()

# Модели запросов и ответов
class CreateUserRequest(BaseModel):
    telegram_id: str
    referrer_id: Optional[str] = None

class UserResponse(BaseModel):
    id: UUID
    telegram_id: str
    username: Optional[str]
    balance: float
    referrer_id: Optional[str]
    created_at: str
    updated_at: str


@router.post("/user/create", response_model=UserResponse, summary="Создать пользователя")
async def create_user(
    request: CreateUserRequest,
    db_manager: DatabaseManager = Depends(get_database_manager)
):
    """
    Создание пользователя через Telegram ID.
    """
    try:
        user = await db_manager.create_user(request.telegram_id,request.referrer_id)
        if user == "ERROR":
            raise HTTPException(status_code=500, detail="Failed to create user")

        return UserResponse(
            id=user.id,
            telegram_id=user.telegram_id,
            username=user.username,
            balance=user.balance,
            referrer_id=user.referrer_id if user.referrer_id is not None else None,
            created_at=user.created_at.isoformat(),
            updated_at=user.updated_at.isoformat()
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))



@router.get("/user/{telegram_id}", response_model=UserResponse, summary="Получить информацию о пользователе")
async def get_user(
    telegram_id: str,
    db_manager: DatabaseManager = Depends(get_database_manager)
):
    """
    Получение информации о пользователе.
    """
    try:
        logger.info(f"Получение пользователя с telegram_id: {telegram_id}")
        user = await db_manager.get_user_by_telegram_id(telegram_id)
        if not user:
            logger.warning(f"Пользователь с telegram_id {telegram_id} не найден.")
            raise HTTPException(status_code=404, detail="User not found")

        logger.info(f"Пользователь найден: ID={user.id}, Username={user.username}")

        return UserResponse(
            id=user.id,
            telegram_id=user.telegram_id,
            username=user.username,
            balance=user.balance,
            referrer_id=user.referrer_id if user.referrer_id is not None else None,
            created_at=user.created_at.isoformat(),
            updated_at=user.updated_at.isoformat()
        )
        logger.debug(f"Формирование ответа для пользователя: {user_response}")

        return user_response

    except HTTPException as http_ex:  # Позволяет обработать HTTPException отдельно
        raise http_ex

    except SQLAlchemyError as e:
        logger.error(f"Ошибка базы данных при получении пользователя с telegram_id {telegram_id}: {e}")
        raise HTTPException(status_code=500, detail="Database error")

    except Exception as e:
        logger.exception(f"Неожиданная ошибка при получении пользователя с telegram_id {telegram_id}: {e}")
        raise HTTPException(status_code=500, detail=str(e))



@router.post("/user/{telegram_id}/balance/{amount}", summary="Обновить баланс")
async def update_balance(
    telegram_id: str, 
    amount: float, 
    db_manager: DatabaseManager = Depends(get_database_manager)
):
    """
    Обновляет баланс пользователя.
    """
    logger.info(f"Получен запрос на обновление баланса: telegram_id={telegram_id}, amount={amount}")
    try:
        result = await db_manager.update_balance(telegram_id, amount)
        if result == "ERROR":
            logger.error(f"Ошибка обновления баланса для пользователя {telegram_id}")
            raise HTTPException(status_code=500, detail="Failed to update balance")
        
        logger.info(f"Баланс пользователя {telegram_id} успешно обновлен на {amount}")
        return {"message": "Balance updated successfully"}
    except HTTPException as http_ex:
        logger.warning(f"HTTP ошибка: {http_ex.detail}")
        raise http_ex
    except SQLAlchemyError as db_ex:
        logger.error(f"Ошибка базы данных при обновлении баланса пользователя {telegram_id}: {db_ex}")
        raise HTTPException(status_code=500, detail="Database error")
    except Exception as e:
        logger.exception(f"Неожиданная ошибка при обновлении баланса пользователя {telegram_id}: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@router.get("/user/{user_id}/transactions", summary="Последние транзакции пользователя")
async def last_transactions(
    user_id: UUID, 
    db_manager: DatabaseManager = Depends(get_database_manager)
):
    """
    Возвращает список последних транзакций пользователя.
    """
    logger.info(f"Получен запрос на транзакции для пользователя: {user_id}")
    try:
        logger.debug(f"Вызов метода get_transaction с user_id={user_id}")
        transactions = await db_manager.get_transaction(user_id)
        
        if transactions == "ERROR":
            logger.error(f"Ошибка при получении транзакций для пользователя: {user_id}")
            raise HTTPException(status_code=500, detail="Failed to fetch transactions")
        
        logger.debug(f"Транзакции для {user_id}: {transactions}")
        response = [
            {
                "id": tx.id,
                "amount": tx.amount,
                "created_at": tx.created_at.isoformat(),
                "transaction_type": tx.transaction_type,
            } for tx in transactions
        ]
        logger.info(f"Формирование ответа для пользователя {user_id}: {response}")
        return response

    except HTTPException as http_ex:
        logger.warning(f"HTTP ошибка для {user_id}: {http_ex.detail}")
        raise http_ex

    except SQLAlchemyError as db_ex:
        logger.error(f"Ошибка базы данных для {user_id}: {db_ex}")
        raise HTTPException(status_code=500, detail="Database error")
    
    except Exception as e:
        logger.exception(f"Неожиданная ошибка для {user_id}: {e}")
        raise HTTPException(status_code=500, detail=str(e))