from sqlalchemy.orm import Session
from fastapi import HTTPException
import logging
from typing import Optional, Dict, Any

from models.database_models import User
from models.api_models import UserRegister, UserLogin
from middleware.auth import AuthManager

logger = logging.getLogger(__name__)


class AuthService:
    """Service class for authentication operations following the application's service pattern"""

    def __init__(self):
        self.auth_manager = AuthManager()

    def register_user(self, db: Session, user_data: UserRegister) -> User:
        """
        Register a new user

        Args:
            db: Database session
            user_data: User registration data

        Returns:
            Created user object

        Raises:
            HTTPException: If email or username already exists
        """
        # Check if email already exists
        existing_email = db.query(User).filter(User.email == user_data.email).first()
        if existing_email:
            raise HTTPException(status_code=400, detail="Email already registered")

        # Check if username already exists
        existing_username = db.query(User).filter(User.username == user_data.username).first()
        if existing_username:
            raise HTTPException(status_code=400, detail="Username already taken")

        # Hash password and create user
        hashed_password = self.auth_manager.hash_password(user_data.password)
        new_user = User(
            email=user_data.email,
            username=user_data.username,
            hashed_password=hashed_password,
            role="user",
            is_active=True
        )

        db.add(new_user)
        db.commit()
        db.refresh(new_user)

        logger.info(f"New user registered: {new_user.username}")
        return new_user

    def login_user(self, db: Session, user_credentials: UserLogin) -> Dict[str, Any]:
        """
        Login user and return JWT token with user data

        Args:
            db: Database session
            user_credentials: User login credentials

        Returns:
            Dictionary containing access token data and user object

        Raises:
            HTTPException: If authentication fails
        """
        user = self.auth_manager.authenticate_user(db, user_credentials.username, user_credentials.password)
        if not user:
            raise HTTPException(status_code=401, detail="Incorrect username or password")

        # Create access token
        token_data = self.auth_manager.create_access_token(user)

        logger.info(f"User logged in: {user.username}")

        return {
            "token_data": token_data,
            "user": user
        }

    def get_user_by_email(self, db: Session, email: str) -> Optional[User]:
        """Get user by email"""
        return db.query(User).filter(User.email == email).first()

    def get_user_by_username(self, db: Session, username: str) -> Optional[User]:
        """Get user by username"""
        return db.query(User).filter(User.username == username).first()

    def email_exists(self, db: Session, email: str) -> bool:
        """Check if email already exists"""
        return db.query(User).filter(User.email == email).first() is not None

    def username_exists(self, db: Session, username: str) -> bool:
        """Check if username already exists"""
        return db.query(User).filter(User.username == username).first() is not None

    def authenticate_user(self, db: Session, username: str, password: str) -> Optional[User]:
        """Authenticate user with username/password"""
        return self.auth_manager.authenticate_user(db, username, password)

    def create_access_token(self, user: User) -> Dict[str, Any]:
        """Create access token for user"""
        return self.auth_manager.create_access_token(user)

    def hash_password(self, password: str) -> str:
        """Hash password"""
        return self.auth_manager.hash_password(password)


# Create service instance following the same pattern as admin_service
auth_service = AuthService()