from fastapi import APIRouter, Depends, HTTPException, status, Body
from sqlalchemy.orm import Session
from typing import Dict
from .. import crud, schemas, auth
from ..database import get_db
from ..models import User

router = APIRouter(prefix="/auth", tags=["auth"])

@router.post("/register", response_model=schemas.SuccessResponse)
def register(user: schemas.UserCreate, db: Session = Depends(get_db)):
    # Check if user already exists
    db_user = crud.get_user_by_email(db, email=user.email)
    if db_user:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Email already registered"
        )
    
    # Create user
    crud.create_user(db=db, user=user)
    
    return schemas.SuccessResponse(
        message="User registered successfully",
        data={"email": user.email}
    )

@router.post("/login", response_model=schemas.SuccessResponse)
def login(credentials: schemas.UserLogin, db: Session = Depends(get_db)):
    # Authenticate user
    user = crud.authenticate_user(db, credentials.email, credentials.password)
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect email or password"
        )
    
    # Create tokens
    access_token, refresh_token = auth.create_tokens(user.email)
    
    return schemas.SuccessResponse(
        message="Login successful",
        data={
            "access_token": access_token,
            "refresh_token": refresh_token,
            "token_type": "bearer",
            "user": {
                "email": user.email,
                "id": user.id,
                "created_at": user.created_at.isoformat() if user.created_at else None
            }
        }
    )

@router.post("/logout", response_model=schemas.SuccessResponse)
def logout():
    # In a real app, you might want to blacklist the token
    return schemas.SuccessResponse(message="Logout successful")

@router.get("/me", response_model=schemas.SuccessResponse)
def get_current_user(
    current_user: User = Depends(auth.get_current_user)
):
    return schemas.SuccessResponse(
        data={
            "email": current_user.email,
            "id": current_user.id,
            "created_at": current_user.created_at.isoformat() if current_user.created_at else None,
            "is_active": current_user.is_active,
            "is_developer": current_user.is_developer
        }
    )

@router.put("/me/developer-status", response_model=schemas.SuccessResponse)
def update_developer_status(
    is_developer: bool = Body(..., embed=True),
    current_user: User = Depends(auth.get_current_user),
    db: Session = Depends(get_db)
):
    """
    Update developer status for current user
    """
    current_user.is_developer = is_developer
    db.commit()
    
    return schemas.SuccessResponse(
        message=f"Developer status updated to: {is_developer}",
        data={"is_developer": is_developer}
    )

@router.post("/refresh", response_model=schemas.Token)
def refresh_token(
    current_user: User = Depends(auth.get_current_user)
):
    """
    Refresh access token using refresh token
    """
    # Create new access token for the current user
    access_token, refresh_token = auth.create_tokens(current_user.email)
    
    return schemas.Token(
        access_token=access_token,
        refresh_token=refresh_token,
        token_type="bearer"
    )