from datetime import datetime, timezone
from typing import Optional
from uuid import UUID
from sqlalchemy import select, update
from sqlalchemy.ext.asyncio import AsyncSession
from modules.identity.models import User, Session


class UserRepository:
    def __init__(self, db: AsyncSession):
        self.db = db

    async def get_by_id(self, user_id: UUID) -> Optional[User]:
        stmt = select(User).where(User.id == user_id)
        result = await self.db.execute(stmt)
        return result.scalar_one_or_none()

    async def get_by_email(self, email: str) -> Optional[User]:
        stmt = select(User).where(User.email == email.lower().strip())
        result = await self.db.execute(stmt)
        return result.scalar_one_or_none()

    async def get_by_telegram_user_id(self, telegram_user_id: int) -> Optional[User]:
        stmt = select(User).where(User.telegram_user_id == telegram_user_id)
        result = await self.db.execute(stmt)
        return result.scalar_one_or_none()

    async def create(self, user: User) -> User:
        self.db.add(user)
        await self.db.flush()
        return user

    async def delete(self, user: User) -> None:
        await self.db.delete(user)
        await self.db.flush()


class SessionRepository:
    def __init__(self, db: AsyncSession):
        self.db = db

    async def create(self, session: Session) -> Session:
        self.db.add(session)
        await self.db.flush()
        return session

    async def get_active_by_hash(self, token_hash: str) -> Optional[Session]:
        stmt = select(Session).where(
            Session.refresh_token_hash == token_hash,
            Session.revoked == False,
            Session.expires_at > datetime.now(timezone.utc),
        )
        result = await self.db.execute(stmt)
        return result.scalar_one_or_none()

    async def revoke_by_hash(self, token_hash: str) -> None:
        stmt = (
            update(Session)
            .where(Session.refresh_token_hash == token_hash)
            .values(revoked=True)
        )
        await self.db.execute(stmt)
        await self.db.flush()

    async def delete_all_for_user(self, user_id: UUID) -> None:
        from sqlalchemy import delete
        stmt = delete(Session).where(Session.user_id == user_id)
        await self.db.execute(stmt)
        await self.db.flush()
