from fastapi import APIRouter, Depends, HTTPException, status, BackgroundTasks, Request
from pydantic import BaseModel
from sqlmodel import Session, select
import jwt
from datetime import datetime, timedelta, timezone
import bcrypt
import os
from typing import Optional
from db import get_session
from app.models.user import User
from app.models.security_models import RefreshToken, VerificationToken, AuditLog
from app.schemas.user import (
    UserSignUp, 
    UserSignIn, 
    TokenResponse, 
    UserResponse, 
    ForgotPasswordRequest, 
    ResetPasswordRequest,
    UserUpdate
)
from app.core.security import get_current_user_info
from email_validator import validate_email, EmailNotValidError
from app.core.config import settings

router = APIRouter(tags=["Authentication"])

def get_client_ip(request: Request) -> str:
    forwarded = request.headers.get("X-Forwarded-For")
    if forwarded:
        return forwarded.split(",")[0].strip()
    return request.client.host if request.client else "Unknown IP"

ERR_MOBILE_EXISTS = "A user with this mobile number already exists."
ERR_USER_NOT_FOUND = "User not found."
ERR_AUTH_REQUIRED = "Authentication is required. Please log in to continue."
ERR_INCORRECT_PASSWORD = "Incorrect current password."

def _detect_browser(user_agent: str) -> str:
    if "Firefox" in user_agent:
        return "Mozilla Firefox"
    if "Seamonkey" in user_agent:
        return "Seamonkey"
    if "Chrome" in user_agent and "Chromium" not in user_agent:
        if "Edg" in user_agent:
            return "Microsoft Edge"
        if "OPR" in user_agent or "Opera" in user_agent:
            return "Opera"
        return "Google Chrome"
    if "Chromium" in user_agent:
        return "Chromium"
    if "Safari" in user_agent and "Chrome" not in user_agent and "Chromium" not in user_agent:
        return "Apple Safari"
    if "MSIE" in user_agent or "Trident" in user_agent:
        return "Internet Explorer"
    return "Unknown Browser"

def _detect_device(user_agent: str) -> str:
    if "Mobi" in user_agent or "Android" in user_agent or "iPhone" in user_agent:
        if "iPhone" in user_agent:
            return "Apple iPhone"
        if "Android" in user_agent:
            return "Android Phone"
        return "Mobile Device"
    if "iPad" in user_agent or "Tablet" in user_agent:
        return "Tablet Device"
    return "Desktop/Laptop"

def parse_user_agent(user_agent: str) -> tuple[str, str]:
    if not user_agent or user_agent == "Unknown":
        return "Unknown Browser", "Unknown Device"
    return _detect_browser(user_agent), _detect_device(user_agent)

def validate_user_email(email: str):
    try:
        check_deliv = not settings.TESTING
        validate_email(email, check_deliverability=check_deliv)
    except EmailNotValidError as e:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=f"Email validation failed: {str(e)}"
        )

def store_refresh_token(session: Session, user_id: int, token: str, expires_at: datetime):
    db_token = RefreshToken(
        token=token,
        user_id=user_id,
        expires_at=expires_at,
        revoked=False
    )
    session.add(db_token)
    session.commit()

def log_event(session: Session, user_id: Optional[int], role: Optional[str], action: str, resource_type: str, resource_id: Optional[int] = None, success: bool = True):
    try:
        log_entry = AuditLog(
            user_id=user_id,
            role=role,
            action=action,
            resource_type=resource_type,
            resource_id=resource_id,
            success=success
        )
        session.add(log_entry)
        session.commit()
    except Exception as e:
        print(f"Error creating audit log: {e}")

# JWT configuration
JWT_SECRET = os.getenv("JWT_SECRET", "super_secret_insurance_border_key")
JWT_ALGORITHM = "HS256"

def hash_password(password: str) -> str:
    salt = bcrypt.gensalt()
    return bcrypt.hashpw(password.encode('utf-8'), salt).decode('utf-8')

def verify_password(plain_password: str, hashed_password: str) -> bool:
    try:
        return bcrypt.checkpw(plain_password.encode('utf-8'), hashed_password.encode('utf-8'))
    except Exception:
        return False

def create_access_token(user_id: int, role: str, email: str) -> str:
    now = datetime.now(timezone.utc)
    expire = now + timedelta(minutes=30)
    payload = {
        "sub": str(user_id),
        "role": role,
        "email": email,
        "type": "access",
        "iat": now.timestamp(),
        "exp": expire
    }
    return jwt.encode(payload, JWT_SECRET, algorithm=JWT_ALGORITHM)

def create_refresh_token(user_id: int, role: str) -> str:
    now = datetime.now(timezone.utc)
    expire = now + timedelta(days=7)
    payload = {
        "sub": str(user_id),
        "role": role,
        "type": "refresh",
        "iat": now.timestamp(),
        "exp": expire
    }
    return jwt.encode(payload, JWT_SECRET, algorithm=JWT_ALGORITHM)

@router.post("/register", response_model=TokenResponse, status_code=status.HTTP_201_CREATED)
def register(user_data: UserSignUp, background_tasks: BackgroundTasks, session: Session = Depends(get_session)):
    # Validate email format and MX records deliverability
    validate_user_email(user_data.email)

    # Check if email is already taken
    stmt = select(User).where(User.email == user_data.email)
    existing_user = session.exec(stmt).first()
    if existing_user:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="A user with this email address already exists."
        )
    
    # Check if mobile is already taken
    if user_data.mobile:
        stmt_mobile = select(User).where(User.mobile == user_data.mobile)
        existing_mobile = session.exec(stmt_mobile).first()
        if existing_mobile:
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail=ERR_MOBILE_EXISTS
            )
            
    # Hash password and create new User
    db_user = User(
        name=user_data.name,
        email=user_data.email,
        mobile=user_data.mobile,
        state=user_data.state,
        role=user_data.role or "customer",
        password_hash=hash_password(user_data.password)
    )
    
    session.add(db_user)
    session.commit()
    session.refresh(db_user)
    
    # Send welcome email asynchronously
    email_sent = False
    try:
        from app.core.email_service import send_welcome_email
        background_tasks.add_task(send_welcome_email, db_user.name, db_user.email)
        email_sent = True
    except Exception as e:
        print(f"Failed to enqueue welcome email: {e}")
    
    access_token = create_access_token(db_user.id, db_user.role, db_user.email)
    refresh_token = create_refresh_token(db_user.id, db_user.role)
    
    # Store refresh token
    expires_at = datetime.now(timezone.utc).replace(tzinfo=None) + timedelta(days=7)
    store_refresh_token(session, db_user.id, refresh_token, expires_at)
    
    log_event(session, db_user.id, db_user.role, "REGISTER", "users", db_user.id)
    
    user_resp = UserResponse.model_validate(db_user)
    user_resp.email_sent = email_sent
    
    return {
        "access_token": access_token,
        "refresh_token": refresh_token,
        "token_type": "bearer",
        "user": user_resp,
        "email_sent": email_sent
    }

def verify_user_lockout(db_user: User, session: Session):
    if db_user.lockout_until and db_user.lockout_until.replace(tzinfo=timezone.utc) > datetime.now(timezone.utc):
        lockout_mins = int((db_user.lockout_until.replace(tzinfo=timezone.utc) - datetime.now(timezone.utc)).total_seconds() / 60) + 1
        log_event(session, db_user.id, db_user.role, "LOGIN_LOCKOUT", "users", db_user.id, success=False)
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail=f"Account is temporarily locked due to multiple failed login attempts. Try again in {lockout_mins} minutes."
        )

def handle_failed_login(db_user: User, session: Session):
    db_user.failed_login_attempts += 1
    if db_user.failed_login_attempts >= 5:
        db_user.lockout_until = datetime.now(timezone.utc).replace(tzinfo=None) + timedelta(minutes=15)
        db_user.failed_login_attempts = 0
    session.add(db_user)
    session.commit()
    log_event(session, db_user.id, db_user.role, "LOGIN", "users", db_user.id, success=False)
    raise HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Incorrect credentials. Please try again."
    )

def enqueue_login_notification(db_user: User, request: Request, background_tasks: BackgroundTasks):
    try:
        from app.core.email_service import send_login_notification_email
        client_ip = get_client_ip(request)
        user_agent = request.headers.get("user-agent", "Unknown")
        browser, device = parse_user_agent(user_agent)
        background_tasks.add_task(
            send_login_notification_email,
            db_user.name,
            db_user.email,
            client_ip,
            browser,
            device
        )
    except Exception as e:
        print(f"Failed to enqueue login email: {e}")

@router.post("/login", response_model=TokenResponse)
def login(login_data: UserSignIn, request: Request, background_tasks: BackgroundTasks, session: Session = Depends(get_session)):
    # Find user by username, email, or mobile
    identifier = login_data.username or login_data.email or login_data.mobile
    if not identifier:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Username, email, or mobile number is required."
        )
        
    stmt = select(User).where((User.email == identifier) | (User.mobile == identifier))
    db_user = session.exec(stmt).first()
    
    # Verify user exists
    if not db_user:
        log_event(session, None, None, "LOGIN", "users", success=False)
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect credentials. Please try again."
        )
        
    # Check if locked out
    verify_user_lockout(db_user, session)
        
    # Verify password
    if not verify_password(login_data.password, db_user.password_hash):
        handle_failed_login(db_user, session)
        
    # Reset attempts on successful login
    db_user.failed_login_attempts = 0
    db_user.lockout_until = None
    session.add(db_user)
    session.commit()
    
    # Generate tokens
    access_token = create_access_token(db_user.id, db_user.role, db_user.email)
    refresh_token = create_refresh_token(db_user.id, db_user.role)
    
    # Store refresh token
    expires_at = datetime.now(timezone.utc).replace(tzinfo=None) + timedelta(days=7)
    store_refresh_token(session, db_user.id, refresh_token, expires_at)
    
    log_event(session, db_user.id, db_user.role, "LOGIN", "users", db_user.id)
    
    # Send successful login notification email asynchronously
    enqueue_login_notification(db_user, request, background_tasks)
        
    return {
        "access_token": access_token,
        "refresh_token": refresh_token,
        "token_type": "bearer",
        "user": db_user
    }

class LogoutRequest(BaseModel):
    refresh_token: str

@router.post("/logout")
def logout(req: LogoutRequest, session: Session = Depends(get_session)):
    stmt = select(RefreshToken).where(RefreshToken.token == req.refresh_token)
    db_token = session.exec(stmt).first()
    if db_token:
        db_token.revoked = True
        session.add(db_token)
        session.commit()
        log_event(session, db_token.user_id, None, "LOGOUT", "users", db_token.user_id)
    return {"message": "Logged out successfully"}

@router.post("/logout-all")
def logout_all(current_user: dict = Depends(get_current_user_info), session: Session = Depends(get_session)):
    user_id = current_user["user_id"]
    stmt = select(RefreshToken).where(RefreshToken.user_id == user_id, RefreshToken.revoked == False)
    db_tokens = session.exec(stmt).all()
    for db_token in db_tokens:
        db_token.revoked = True
        session.add(db_token)
    session.commit()
    log_event(session, user_id, current_user.get("role"), "LOGOUT_ALL", "users", user_id)
    return {"message": "Logged out of all devices successfully"}

class RefreshRequest(BaseModel):
    refresh_token: str

@router.post("/refresh-token", response_model=TokenResponse)
def refresh(req: RefreshRequest, session: Session = Depends(get_session)):
    try:
        payload = jwt.decode(req.refresh_token, JWT_SECRET, algorithms=[JWT_ALGORITHM])
        if payload.get("type") != "refresh":
            raise HTTPException(
                status_code=status.HTTP_401_UNAUTHORIZED,
                detail="Invalid token type."
            )
        user_id = payload.get("sub")
        if not user_id:
            raise HTTPException(
                status_code=status.HTTP_401_UNAUTHORIZED,
                detail="Invalid token content."
            )
    except jwt.ExpiredSignatureError:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Refresh token has expired. Please login again."
        )
    except jwt.InvalidTokenError:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid refresh token."
        )
        
    stmt_token = select(RefreshToken).where(RefreshToken.token == req.refresh_token)
    db_token = session.exec(stmt_token).first()
    if not db_token or db_token.revoked or db_token.expires_at.replace(tzinfo=timezone.utc) < datetime.now(timezone.utc):
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Refresh token is invalid, expired, or has been revoked."
        )
        
    user = session.get(User, int(user_id))
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail=ERR_USER_NOT_FOUND
        )
        
    # Check if password was changed since refresh token was issued
    iat = payload.get("iat")
    if iat and user.password_changed_at:
        if iat < user.password_changed_at.replace(tzinfo=timezone.utc).timestamp():
            db_token.revoked = True
            session.add(db_token)
            session.commit()
            raise HTTPException(
                status_code=status.HTTP_401_UNAUTHORIZED,
                detail="Token invalidated due to password change."
            )
            
    # Revoke old refresh token (rotation)
    db_token.revoked = True
    session.add(db_token)
    
    # Generate new tokens
    access_token = create_access_token(user.id, user.role, user.email)
    new_refresh_token = create_refresh_token(user.id, user.role)
    
    # Store new refresh token
    expires_at = datetime.now(timezone.utc).replace(tzinfo=None) + timedelta(days=7)
    store_refresh_token(session, user.id, new_refresh_token, expires_at)
    
    log_event(session, user.id, user.role, "TOKEN_REFRESH", "users", user.id)
    
    return {
        "access_token": access_token,
        "refresh_token": new_refresh_token,
        "token_type": "bearer",
        "user": user
    }

@router.post("/forgot-password")
def forgot_password(
    req: ForgotPasswordRequest,
    background_tasks: BackgroundTasks,
    session: Session = Depends(get_session)
):
    stmt = select(User).where(User.email == req.email)
    user = session.exec(stmt).first()
    if not user:
        log_event(session, None, None, "FORGOT_PASSWORD", "users", success=False)
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="No account found with this email address."
        )
    
    # Generate short-lived reset token (15 mins)
    token_data = {
        "sub": str(user.id),
        "email": user.email,
        "type": "reset",
        "exp": datetime.now(timezone.utc) + timedelta(minutes=15)
    }
    reset_token = jwt.encode(token_data, JWT_SECRET, algorithm=JWT_ALGORITHM)
    
    # Print the link to console for local testing
    frontend_url = settings.FRONTEND_URL.rstrip('/')
    reset_link = f"{frontend_url}/reset-password?token={reset_token}"
    print("\n" + "="*80)
    print(f" PASSWORD RESET REQUEST RECEIVED FOR: {user.email}")
    print(f" RESET LINK: {reset_link}")
    print("="*80 + "\n")
    
    # Attempt to send email
    try:
        from app.core.email_service import send_reset_password_email
        background_tasks.add_task(send_reset_password_email, user.name, user.email, reset_token)
    except Exception as e:
        print(f"Error enqueuing send_reset_password_email: {e}")
        
    log_event(session, user.id, user.role, "FORGOT_PASSWORD", "users", user.id)
    return {"message": "Password reset email sent."}

@router.post("/reset-password")
def reset_password(req: ResetPasswordRequest, session: Session = Depends(get_session)):
    try:
        payload = jwt.decode(req.token, JWT_SECRET, algorithms=[JWT_ALGORITHM])
        if payload.get("type") != "reset":
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail="Invalid token type."
            )
        user_id = payload.get("sub")
        if not user_id:
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail="Invalid token content."
            )
    except jwt.ExpiredSignatureError:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Password reset token has expired."
        )
    except jwt.InvalidTokenError:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Invalid password reset token."
        )
    
    user = session.get(User, int(user_id))
    if not user:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=ERR_USER_NOT_FOUND
        )
        
    user.password_hash = hash_password(req.new_password)
    user.password_changed_at = datetime.now(timezone.utc).replace(tzinfo=None)
    
    # Invalidate user authentication cache
    from app.core.middleware import invalidate_user_cache
    invalidate_user_cache(user.id)
    
    # Revoke all existing refresh tokens for this user
    stmt_revoke = select(RefreshToken).where(RefreshToken.user_id == user.id, RefreshToken.revoked == False)
    db_tokens = session.exec(stmt_revoke).all()
    for db_token in db_tokens:
        db_token.revoked = True
        session.add(db_token)
        
    session.add(user)
    session.commit()
    session.refresh(user)
    log_event(session, user.id, user.role, "RESET_PASSWORD", "users", user.id)
    return {"message": "Password has been reset successfully."}

@router.get("/me", response_model=UserResponse)
def get_me(current_user: dict = Depends(get_current_user_info), session: Session = Depends(get_session)):
    user = session.get(User, current_user["user_id"])
    if not user:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=ERR_USER_NOT_FOUND
        )
    return user

@router.put("/me", response_model=UserResponse)
def update_me(
    profile_data: UserUpdate,
    current_user: dict = Depends(get_current_user_info),
    session: Session = Depends(get_session)
):
    user = session.get(User, current_user["user_id"])
    if not user:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=ERR_USER_NOT_FOUND
        )
    
    if profile_data.name is not None:
        user.name = profile_data.name
    if profile_data.mobile is not None:
        mob = profile_data.mobile.strip() if isinstance(profile_data.mobile, str) else None
        if mob == "":
            mob = None
        if mob is not None and mob != user.mobile:
            stmt_mobile = select(User).where(User.mobile == mob)
            existing_mobile = session.exec(stmt_mobile).first()
            if existing_mobile and existing_mobile.id != user.id:
                raise HTTPException(
                    status_code=status.HTTP_400_BAD_REQUEST,
                    detail=ERR_MOBILE_EXISTS
                )
        user.mobile = mob
    if profile_data.country is not None:
        user.country = profile_data.country
    if profile_data.state is not None:
        user.state = profile_data.state
    if profile_data.city is not None:
        user.city = profile_data.city
    if profile_data.area_code is not None:
        user.area_code = profile_data.area_code
    if profile_data.avatar is not None:
        user.avatar = profile_data.avatar
        
    user.updated_at = datetime.now(timezone.utc).replace(tzinfo=None)
    session.add(user)
    session.commit()
    session.refresh(user)
    
    log_event(session, user.id, user.role, "PROFILE_UPDATE", "users", user.id)
    return user

@router.post("/signup", response_model=UserResponse, status_code=status.HTTP_201_CREATED)
def signup(user_data: UserSignUp, background_tasks: BackgroundTasks, session: Session = Depends(get_session)):
    # Validate email format and MX records deliverability
    validate_user_email(user_data.email)

    stmt = select(User).where(User.email == user_data.email)
    existing_user = session.exec(stmt).first()
    if existing_user:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="A user with this email address already exists."
        )
    
    if user_data.mobile:
        stmt_mobile = select(User).where(User.mobile == user_data.mobile)
        existing_mobile = session.exec(stmt_mobile).first()
        if existing_mobile:
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail=ERR_MOBILE_EXISTS
            )
            
    db_user = User(
        name=user_data.name,
        email=user_data.email,
        mobile=user_data.mobile,
        role=user_data.role or "customer",
        password_hash=hash_password(user_data.password)
    )
    session.add(db_user)
    session.commit()
    session.refresh(db_user)

    # Send welcome email asynchronously
    email_sent = False
    try:
        from app.core.email_service import send_welcome_email
        background_tasks.add_task(send_welcome_email, db_user.name, db_user.email)
        email_sent = True
    except Exception as e:
        print(f"Failed to enqueue welcome email: {e}")
        
    user_resp = UserResponse.model_validate(db_user)
    user_resp.email_sent = email_sent
    return user_resp

@router.post("/signin", response_model=TokenResponse)
def signin(login_data: UserSignIn, request: Request, background_tasks: BackgroundTasks, session: Session = Depends(get_session)):
    return login(login_data, request, background_tasks, session)


class ChangePasswordInitiateRequest(BaseModel):
    current_password: str
    new_password: str


class ChangePasswordVerifyRequest(BaseModel):
    current_password: str
    new_password: str
    code: str


@router.post("/change-password/initiate")
def initiate_change_password(
    req: ChangePasswordInitiateRequest,
    background_tasks: BackgroundTasks,
    current_user: dict = Depends(get_current_user_info),
    session: Session = Depends(get_session)
):
    user_id = current_user.get("user_id")
    if not user_id:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail=ERR_AUTH_REQUIRED
        )
    
    user = session.get(User, int(user_id))
    if not user:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=ERR_USER_NOT_FOUND
        )
        
    if not verify_password(req.current_password, user.password_hash):
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=ERR_INCORRECT_PASSWORD
        )
        
    if len(req.new_password) < 8:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="New password must be at least 8 characters long."
        )
        
    import random
    otp_code = "".join(random.choices("0123456789", k=6))
    
    # Clean up old tokens of type "password_change"
    stmt_del = select(VerificationToken).where(
        VerificationToken.user_id == user.id,
        VerificationToken.type == "password_change"
    )
    old_tokens = session.exec(stmt_del).all()
    for t in old_tokens:
        session.delete(t)
        
    # Store new OTP token
    token_record = VerificationToken(
        user_id=user.id,
        token=otp_code,
        type="password_change",
        expires_at=datetime.now(timezone.utc).replace(tzinfo=None) + timedelta(minutes=10)
    )
    session.add(token_record)
    session.commit()
    
    # Print the code to console for local testing
    print("\n" + "="*80)
    print(f" PASSWORD CHANGE VERIFICATION CODE FOR: {user.email}")
    print(f" CODE: {otp_code}")
    print("="*80 + "\n")
    
    # Try sending email
    try:
        from app.core.email_service import send_password_change_otp_email
        background_tasks.add_task(send_password_change_otp_email, user.name, user.email, otp_code)
    except Exception as e:
        print(f"Failed to enqueue password change email: {e}")
        
    return {"message": "Verification code sent successfully."}


@router.post("/change-password/verify")
def verify_change_password(
    req: ChangePasswordVerifyRequest,
    current_user: dict = Depends(get_current_user_info),
    session: Session = Depends(get_session)
):
    user_id = current_user.get("user_id")
    if not user_id:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail=ERR_AUTH_REQUIRED
        )
        
    user = session.get(User, int(user_id))
    if not user:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=ERR_USER_NOT_FOUND
        )
        
    if not verify_password(req.current_password, user.password_hash):
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=ERR_INCORRECT_PASSWORD
        )
        
    # Find verification token
    stmt = select(VerificationToken).where(
        VerificationToken.user_id == user.id,
        VerificationToken.token == req.code,
        VerificationToken.type == "password_change"
    )
    token_record = session.exec(stmt).first()
    
    if not token_record:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Invalid verification code. Please try again."
        )
        
    if token_record.expires_at < datetime.now(timezone.utc).replace(tzinfo=None):
        session.delete(token_record)
        session.commit()
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Verification code has expired. Please request a new one."
        )
        
    # Valid code, update password
    user.password_hash = hash_password(req.new_password)
    user.password_changed_at = datetime.now(timezone.utc).replace(tzinfo=None)
    
    # Invalidate user authentication cache
    from app.core.middleware import invalidate_user_cache
    invalidate_user_cache(user.id)
    
    # Revoke all existing refresh tokens
    stmt_revoke = select(RefreshToken).where(RefreshToken.user_id == user.id, RefreshToken.revoked == False)
    db_tokens = session.exec(stmt_revoke).all()
    for db_token in db_tokens:
        db_token.revoked = True
        session.add(db_token)
        
    # Delete the verification token
    session.delete(token_record)
    
    session.add(user)
    session.commit()
    session.refresh(user)
    
    log_event(session, user.id, user.role, "CHANGE_PASSWORD", "users", user.id)
    return {"message": "Password updated successfully."}


class ChangePasswordRequest(BaseModel):
    current_password: str
    new_password: str


@router.post("/change-password")
def change_password(
    req: ChangePasswordRequest,
    current_user: dict = Depends(get_current_user_info),
    session: Session = Depends(get_session)
):
    user_id = current_user.get("user_id")
    if not user_id:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail=ERR_AUTH_REQUIRED
        )
    
    user = session.get(User, int(user_id))
    if not user:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=ERR_USER_NOT_FOUND
        )
        
    if not verify_password(req.current_password, user.password_hash):
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=ERR_INCORRECT_PASSWORD
        )
        
    if len(req.new_password) < 8:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="New password must be at least 8 characters long."
        )
        
    user.password_hash = hash_password(req.new_password)
    user.password_changed_at = datetime.now(timezone.utc).replace(tzinfo=None)
    
    # Invalidate user authentication cache
    from app.core.middleware import invalidate_user_cache
    invalidate_user_cache(user.id)
    
    # Revoke all existing refresh tokens
    stmt_revoke = select(RefreshToken).where(RefreshToken.user_id == user.id, RefreshToken.revoked == False)
    db_tokens = session.exec(stmt_revoke).all()
    for db_token in db_tokens:
        db_token.revoked = True
        session.add(db_token)
        
    session.add(user)
    session.commit()
    session.refresh(user)
    
    log_event(session, user.id, user.role, "CHANGE_PASSWORD", "users", user.id)
    return {"message": "Password updated successfully."}


@router.get("/test-get-last-otp")
def test_get_last_otp(session: Session = Depends(get_session)):
    stmt = select(VerificationToken).where(VerificationToken.type == "password_change")
    tokens = session.exec(stmt).all()
    if not tokens:
        return {"otp": None}
    tokens.sort(key=lambda t: t.created_at, reverse=True)
    return {"otp": tokens[0].token}



