const TOKEN = 'eyJ0eXAiOiJKV1QiL.......';
axios.get(
    'http://localhost:8000/users/me', {
    headers: {
        'Authorization': `Bearer ${TOKEN}`,
    },
})
.then((response) => console.log(response))
.catch((error) => console.log(error));

import uuid
from typing import Optional,AsyncGenerator

from fastapi import Depends, Request
from fastapi_users import schemas
from fastapi_users import BaseUserManager, FastAPIUsers, UUIDIDMixin
# from fastapi_users.db import SQLAlchemyBaseUserTableUUID, SQLAlchemyUserDatabase
from fastapi_users_db_sqlmodel import SQLModelBaseUserDB, SQLModelUserDatabaseAsync
# from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
from sqlalchemy.orm import DeclarativeBase
from core.globals import async_db
from apps.afkarena.models import Users as User
from apps.afkarena.utils import send_email

from fastapi_users.authentication import (
    AuthenticationBackend,
    BearerTransport,
    JWTStrategy,
)

SECRET = "CXgyOLiY-OzbkCwdjOp53g"


class Base():
    pass

class UserManager(UUIDIDMixin, BaseUserManager[User, id]):
    reset_password_token_secret = SECRET
    verification_token_secret = SECRET

    async def on_after_register(self, user: User, request: Optional[Request] = None):
        # await send_email(user.email, "Welcome to AFK Arena", "Welcome to AFK Arena, your account has been created. please verify your email.")
        print(f"User {user.id} has registered.")

    async def on_after_forgot_password(
        self, user: User, token: str, request: Optional[Request] = None
    ):
        print(f"User {user.id} has forgot their password. Reset token: {token}")

    async def on_after_request_verify(
        self, user: User, token: str, request: Optional[Request] = None
    ):
        print(f"Verification requested for user {user.id}. Verification token: {token}")


bearer_transport = BearerTransport(tokenUrl="auth/jwt/login")


async def create_db_and_tables():

    # await async_db.run_sync(Base.metadata.create_all(bind = async_db))
    # await async_db.async_commit()
    pass

def get_jwt_strategy() -> JWTStrategy:
    return JWTStrategy(secret=SECRET, lifetime_seconds=3600)

async def get_user_manager():
    user_db = SQLModelUserDatabaseAsync(async_db, User)
    yield UserManager(user_db)


auth_backend = AuthenticationBackend(
    name="jwt",
    transport=bearer_transport,
    get_strategy=get_jwt_strategy,
)

fastapi_users = FastAPIUsers[User, int](get_user_manager, [auth_backend])

current_active_user = fastapi_users.current_user(active=True)

#schemas
class UserRead(schemas.BaseUser[int]):
    pass


class UserCreate(schemas.BaseUserCreate):
    name: str


class UserUpdate(schemas.BaseUserUpdate):
    pass

class Users(SQLModelBaseUserDB, table=True):
    __tablename__ = "user"
    __table_args__ = {'extend_existing': True}
    id: Optional[int] = Field(default=None, primary_key=True, nullable=False, title="ID")
    name: Optional[str] = Field(default=None, max_length=50, index=True, title="Name")
    is_artist: bool = Field(default=False, title="Is Artist",index=True,)
    avatar: Optional[str] = Field(default=None, max_length=255, title="Avatar")

    # Relationships
    artworks: List["Artwork"] = Relationship(back_populates="user")

    created_at: datetime = Field(default_factory=datetime.utcnow, title="Created At")
    updated_at: Optional[datetime] = Field(default=None, title="Updated At")
    last_login: Optional[datetime] = Field(default=None, title="Last Login")