from datetime import datetime, timedelta, timezone
from typing import Optional
import secrets
from uuid import UUID
from sqlalchemy.ext.asyncio import AsyncSession
from core.config import get_settings
from core.exceptions import ConflictError, UnauthorizedError, NotFoundError
from core.security import (
    hash_password,
    verify_password,
    create_access_token,
    create_refresh_token,
    decode_token,
    hash_token,
)
from core.event_bus import get_event_bus, UserRegisteredEvent
from modules.identity.models import User, Session
from modules.identity.repository import UserRepository, SessionRepository
from modules.identity.schemas import (
    UserRegisterRequest,
    UserLoginRequest,
    TelegramAuthRequest,
    TokenResponse,
)
from modules.identity.telegram_verifier import verify_telegram_authorization


class AuthService:
    def __init__(self, db: AsyncSession):
        self.db = db
        self.user_repo = UserRepository(db)
        self.session_repo = SessionRepository(db)
        self.settings = get_settings()

    async def register(self, req: UserRegisterRequest) -> tuple[User, TokenResponse]:
        # Check duplicate email
        existing = await self.user_repo.get_by_email(req.email)
        if existing:
            raise ConflictError("A user with this email address already exists")

        # Hash password with Argon2id
        hashed_pw = hash_password(req.password)

        user = User(
            email=req.email.lower().strip(),
            password_hash=hashed_pw,
            full_name=req.full_name.strip(),
            status="active",
            is_superuser=False,
        )
        await self.user_repo.create(user)

        # Auto-provision primary workspace for new user
        from modules.tenants.service import TenantService
        from modules.tenants.schemas import TenantCreateRequest
        tenant_service = TenantService(self.db)
        slug_base = req.email.split("@")[0].lower()
        clean_slug = "".join(c for c in slug_base if c.isalnum() or c == "-") or f"org-{user.id.hex[:6]}"
        unique_slug = f"{clean_slug}-{secrets.token_hex(3)}"
        await tenant_service.create_tenant(
            owner_user_id=user.id,
            req=TenantCreateRequest(name=f"{user.full_name}'s Workspace", slug=unique_slug),
        )

        # Issue tokens
        token_resp = await self._create_user_session(user)

        # Dispatch event
        await get_event_bus().publish(
            UserRegisteredEvent(
                user_id=user.id,
                email=user.email,
                full_name=user.full_name,
            )
        )

        return user, token_resp

    async def login(
        self,
        req: UserLoginRequest,
        user_agent: Optional[str] = None,
        ip_address: Optional[str] = None,
    ) -> tuple[User, TokenResponse]:
        user = await self.user_repo.get_by_email(req.email)
        if not user or not verify_password(req.password, user.password_hash):
            raise UnauthorizedError("Invalid email or password")

        if user.status != "active":
            raise UnauthorizedError("User account is inactive or suspended")

        token_resp = await self._create_user_session(user, user_agent, ip_address)
        return user, token_resp

    async def authenticate_telegram(
        self,
        req: TelegramAuthRequest,
        user_agent: Optional[str] = None,
        ip_address: Optional[str] = None,
    ) -> tuple[User, TokenResponse]:
        auth_dict = req.model_dump()
        bot_token = self.settings.TELEGRAM_BOT_TOKEN
        valid, reason = verify_telegram_authorization(
            auth_dict,
            bot_token,
            max_age_seconds=self.settings.TELEGRAM_AUTH_MAX_AGE_SECONDS,
        )
        if not valid:
            raise UnauthorizedError(f"Telegram verification failed: {reason}")

        # Check existing user with this telegram_user_id
        user = await self.user_repo.get_by_telegram_user_id(req.id)
        if not user:
            # Check if user with synthetic email exists
            synthetic_email = f"telegram_{req.id}@telegram.local"
            user = await self.user_repo.get_by_email(synthetic_email)
            if user:
                user.telegram_user_id = req.id
                user.telegram_username = req.username
                user.avatar_url = req.photo_url

        if not user:
            # Register new user via Telegram
            full_name = f"{req.first_name} {req.last_name or ''}".strip()
            synthetic_email = f"telegram_{req.id}@telegram.local"
            random_secret = secrets.token_urlsafe(32)
            hashed_pw = hash_password(random_secret)

            user = User(
                email=synthetic_email,
                password_hash=hashed_pw,
                full_name=full_name or f"Telegram User {req.id}",
                status="active",
                is_superuser=False,
                telegram_user_id=req.id,
                telegram_username=req.username,
                avatar_url=req.photo_url,
            )
            await self.user_repo.create(user)
            await get_event_bus().publish(
                UserRegisteredEvent(
                    user_id=user.id,
                    email=user.email,
                    full_name=user.full_name,
                )
            )
        else:
            # Synchronize profile metadata
            if req.username and user.telegram_username != req.username:
                user.telegram_username = req.username
            if req.photo_url and user.avatar_url != req.photo_url:
                user.avatar_url = req.photo_url

        if user.status != "active":
            raise UnauthorizedError("User account is inactive or suspended")

        token_resp = await self._create_user_session(user, user_agent, ip_address)
        return user, token_resp

    async def link_telegram_account(
        self,
        user_id: UUID,
        req: TelegramAuthRequest,
    ) -> User:
        auth_dict = req.model_dump()
        bot_token = self.settings.TELEGRAM_BOT_TOKEN
        valid, reason = verify_telegram_authorization(
            auth_dict,
            bot_token,
            max_age_seconds=self.settings.TELEGRAM_AUTH_MAX_AGE_SECONDS,
        )
        if not valid:
            raise UnauthorizedError(f"Telegram verification failed: {reason}")

        existing = await self.user_repo.get_by_telegram_user_id(req.id)
        if existing and existing.id != user_id:
            raise ConflictError("This Telegram account is already linked to another user.")

        user = await self.get_user_by_id(user_id)
        user.telegram_user_id = req.id
        user.telegram_username = req.username
        user.avatar_url = req.photo_url
        return user

    async def refresh_token(
        self,
        raw_refresh_token: str,
        user_agent: Optional[str] = None,
        ip_address: Optional[str] = None,
    ) -> TokenResponse:
        payload = decode_token(raw_refresh_token, expected_type="refresh")
        user_id_str = payload.get("sub")
        if not user_id_str:
            raise UnauthorizedError("Invalid token payload")

        user_id = UUID(user_id_str)
        token_hash = hash_token(raw_refresh_token)

        session = await self.session_repo.get_active_by_hash(token_hash)
        if not session:
            raise UnauthorizedError("Session has expired or was revoked")

        # Revoke old session (Refresh Token Rotation)
        await self.session_repo.revoke_by_hash(token_hash)

        user = await self.user_repo.get_by_id(user_id)
        if not user or user.status != "active":
            raise UnauthorizedError("User not found or inactive")

        # Create new session
        return await self._create_user_session(user, user_agent, ip_address)

    async def logout(self, raw_refresh_token: str) -> None:
        token_hash = hash_token(raw_refresh_token)
        await self.session_repo.revoke_by_hash(token_hash)

    async def get_user_by_id(self, user_id: UUID) -> User:
        user = await self.user_repo.get_by_id(user_id)
        if not user:
            raise NotFoundError("User not found")
        return user

    async def delete_user(self, user_id: UUID) -> None:
        user = await self.user_repo.get_by_id(user_id)
        if user:
            await self.session_repo.delete_all_for_user(user_id)
            await self.user_repo.delete(user)
            await self.db.commit()

    async def _create_user_session(
        self,
        user: User,
        user_agent: Optional[str] = None,
        ip_address: Optional[str] = None,
    ) -> TokenResponse:
        sub = str(user.id)
        access_token = create_access_token({"sub": sub, "email": user.email, "is_superuser": user.is_superuser})
        refresh_token = create_refresh_token({"sub": sub})

        # Persist session
        refresh_token_hash = hash_token(refresh_token)
        expires_at = datetime.now(timezone.utc) + timedelta(days=self.settings.JWT_REFRESH_TOKEN_EXPIRE_DAYS)

        session = Session(
            user_id=user.id,
            refresh_token_hash=refresh_token_hash,
            user_agent=user_agent,
            ip_address=ip_address,
            expires_at=expires_at,
            revoked=False,
        )
        await self.session_repo.create(session)

        return TokenResponse(
            access_token=access_token,
            refresh_token=refresh_token,
            token_type="bearer",
            expires_in=self.settings.JWT_ACCESS_TOKEN_EXPIRE_MINUTES * 60,
        )
