from fastapi import APIRouter, HTTPException, Body, Response
from app.models.user import UserCreate, UserLogin, VerifyCode
from app.models.request import ValidateRequest
from app.services.auth import AuthService
from app.db.database import users_collection, sessions_collection
from datetime import datetime
import json
from fastapi import HTTPException
from datetime import datetime, timedelta
from app.models.server.event import PlayerEvent, OnlinePlayersUpdate
from app.models.server.playtime import PlayerSession, PlayerPlaytime
from app.services.coins import CoinsService

coins_service = CoinsService()

router = APIRouter(
    tags=["Users"]
)

@router.post("/auth/register")
async def register(user: UserCreate):
    """Регистрация нового пользователя"""
    return await AuthService().register(user)

@router.post("/auth/authenticate")
async def authenticate(credentials: UserLogin):
    """Аутентификация пользователя"""
    return await AuthService().login(credentials)

@router.post("/auth/validate")
async def validate_token(request: ValidateRequest):
    is_valid = await AuthService().validate(request.accessToken, request.clientToken)
    return {"valid": is_valid}

@router.post("/auth/refresh")
async def refresh_token(access_token: str, client_token: str):
    result = await AuthService().refresh(access_token, client_token)
    if not result:
        raise HTTPException(status_code=401, detail="Invalid tokens")
    return result

@router.get("/sessionserver/session/minecraft/profile/{uuid}")
async def get_minecraft_profile(uuid: str, unsigned: bool = False):
    return await AuthService().get_minecraft_profile(uuid)
    
@router.post("/sessionserver/session/minecraft/join")
async def join_server(request_data: dict = Body(...)):
    try:
        await AuthService().join_server(request_data)
        return Response(status_code=204)
    except Exception as e:
        print("Error in join_server:", str(e))
        raise

@router.get("/sessionserver/session/minecraft/hasJoined")
async def has_joined(username: str, serverId: str):
    return await AuthService().has_joined(username, serverId)

@router.get("/users/{username}/coins")
async def get_user_coins(username: str):
    coins_data = await coins_service.get_player_coins(username)
    if not coins_data:
        raise HTTPException(status_code=404, detail="User not found")
    return coins_data

@router.get("/users")
async def get_users():
    """Получение списка всех пользователей"""
    users = await users_collection.find().to_list(1000)
    
    # Исключаем чувствительные данные перед отправкой
    safe_users = []
    for user in users:
        safe_users.append({
            "username": user["username"],
            "uuid": user["uuid"],
            "skin_url": user.get("skin_url"),
            "cloak_url": user.get("cloak_url"),
            "coins": user.get("coins", 0),
            "total_time_played": user.get("total_time_played", 0),
            "is_active": user.get("is_active", True)
        })
    
    return {"users": safe_users, "count": len(safe_users)}

@router.get("/users/{uuid}")
async def get_user_by_uuid(uuid: str):
    """Получение пользователя по UUID"""
    user = await users_collection.find_one({"uuid": uuid})
    if not user:
        # Пробуем разные форматы UUID
        if '-' in uuid:
            user = await users_collection.find_one({"uuid": uuid.replace('-', '')})
        else:
            formatted_uuid = f"{uuid[:8]}-{uuid[8:12]}-{uuid[12:16]}-{uuid[16:20]}-{uuid[20:]}"
            user = await users_collection.find_one({"uuid": formatted_uuid})
            
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    
    # Исключаем чувствительные данные
    safe_user = {
        "username": user["username"],
        "uuid": user["uuid"],
        "skin_url": user.get("skin_url"),
        "cloak_url": user.get("cloak_url"),
        "coins": user.get("coins", 0),
        "total_time_played": user.get("total_time_played", 0),
        "is_active": user.get("is_active", True),
        "created_at": user.get("created_at")
    }
    
    if "total_time_played" in safe_user:
        total_time = safe_user["total_time_played"]
        hours, remainder = divmod(total_time, 3600)
        minutes, seconds = divmod(remainder, 60)
        safe_user["total_time_formatted"] = f"{hours}ч {minutes}м {seconds}с"
    
    return safe_user

@router.post("/auth/verify_code")
async def verify_code(verify_code: VerifyCode):
    return await AuthService().verify_code(verify_code.username, verify_code.code, verify_code.telegram_chat_id)

@router.post("/auth/generate_code")
async def generate_code(username: str):
    return await AuthService().generate_code(username)