import base64
import json
from fastapi import HTTPException
from .models import UserLogin, UserInDB, Session, UserCreate
from .utils import (
    verify_password,
    get_password_hash,
    create_access_token,
    decode_token,
)
from .database import users_collection, sessions_collection
import uuid
from datetime import datetime, timedelta

class AuthService:
    async def register(self, user: UserCreate):
        # Проверяем, существует ли пользователь
        if await users_collection.find_one({"username": user.username}):
            raise HTTPException(status_code=400, detail="Username already taken")

        # Хешируем пароль
        hashed_password = get_password_hash(user.password)
        
        # Создаём UUID для Minecraft
        user_uuid = str(uuid.uuid4())

        # Сохраняем в MongoDB
        new_user = UserInDB(
            username=user.username,
            email=user.email,
            hashed_password=hashed_password,
            uuid=user_uuid,
        )
        await users_collection.insert_one(new_user.dict())
        return {"status": "success", "uuid": user_uuid}

    async def login(self, credentials: UserLogin):
        # Ищем пользователя
        user = await users_collection.find_one({"username": credentials.username})
        if not user or not verify_password(credentials.password, user["hashed_password"]):
            raise HTTPException(status_code=401, detail="Invalid credentials")

        # Генерируем токены
        access_token = create_access_token({"sub": user["username"], "uuid": user["uuid"]})
        client_token = str(uuid.uuid4())

        # Сохраняем сессию
        session = Session(
            access_token=access_token,
            client_token=client_token,
            user_uuid=user["uuid"],
            expires_at=datetime.utcnow() + timedelta(minutes=1440),
        )
        await sessions_collection.insert_one(session.dict())

        return {
            "accessToken": access_token,
            "clientToken": client_token,
            "selectedProfile": {
                "id": user["uuid"],
                "name": user["username"],
            },
        }

    async def validate(self, access_token: str, client_token: str):
        print(f"Searching for access_toke and client_token: '{access_token}', '{client_token}")
        session = await sessions_collection.find_one({
            "access_token": access_token,
            "client_token": client_token,
        })
        print("Session from DB:", session)
        if not session or datetime.utcnow() > session["expires_at"]:
            return False
        return True

    async def refresh(self, access_token: str, client_token: str):
        if not await self.validate(access_token, client_token):
            return None

        # Обновляем токен
        new_access_token = create_access_token({"sub": "user", "uuid": "user_uuid"})
        await sessions_collection.update_one(
            {"access_token": access_token},
            {"$set": {"access_token": new_access_token}},
        )
        return {"accessToken": new_access_token, "clientToken": client_token}
    
    async def get_minecraft_profile(self, uuid: str):
        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=f"User not found (searched for UUID: {formatted_uuid})"
            )
        
        textures = {
            "timestamp": int(datetime.now().timestamp()),
            "profileId": formatted_uuid,
            "profileName": user["username"],
            "textures": {
                "SKIN": {"url": user.get("skin_url", "")},
                "CAPE": {"url": user.get("cloak_url", "")}
            } if user.get("skin_url") or user.get("cloak_url") else {}
        }
        
        textures_json = json.dumps(textures).encode()
        base64_textures = base64.b64encode(textures_json).decode()

        return {
            "id": formatted_uuid,
            "name": user["username"],
            "properties": [
                {
                    "name": "textures",
                    "value": base64_textures
                }
            ]
        }

    async def join_server(self, request_data: dict):
        access_token = request_data.get("accessToken")
        selected_profile = request_data.get("selectedProfile")
        server_id = request_data.get("serverId")

        if not all([access_token, selected_profile, server_id]):
            raise HTTPException(status_code=400, detail="Missing required parameters")

        decoded_token = decode_token(access_token)
        if not decoded_token:
            raise HTTPException(status_code=401, detail="Invalid access token")

        token_uuid = decoded_token.get("uuid", "").replace("-", "")
        if token_uuid != selected_profile:
            raise HTTPException(status_code=403, detail="Token doesn't match selected profile")

        return True

    async def has_joined(self, username: str, server_id: str):
        user = await users_collection.find_one({"username": username})
        if not user:
            raise HTTPException(status_code=404, detail="User not found")
        
        response_uuid = user["uuid"].replace("-", "")
        
        textures = {}
        if user.get("skin_url"):
            textures["SKIN"] = {"url": user["skin_url"]}
        if user.get("cloak_url"):
            textures["CAPE"] = {"url": user["cloak_url"]}
        
        textures_value = base64.b64encode(json.dumps({
            "timestamp": int(datetime.now().timestamp()),
            "profileId": response_uuid,
            "profileName": username,
            "textures": textures
        }).encode()).decode()

        return {
            "id": response_uuid,
            "name": username,
            "properties": [{
                "name": "textures",
                "value": textures_value
            }] if textures else []
        }