#!/usr/bin/env python3
"""
Script to fix missing roles for existing users
This script will assign default roles to users who don't have any roles assigned
"""

import asyncio
import sys
import os
from bson import ObjectId

# Add the app directory to the path
sys.path.append('/app')

from shared.database import connect_to_mongo, close_mongo_connection
from app.models.role import Role
from app.models.user_role import UserRole
from app.models.user_profile import UserProfile

async def create_default_roles():
    """Create default roles if they don't exist"""
    try:
        # Check if default roles exist
        default_role = await Role.find_one({"name": "user"})
        if not default_role:
            # Create default user role
            default_role = Role(
                name="user",
                display_name="User",
                description="Default user role",
                role_type="system",
                is_system_role=True,
                is_active=True,
                priority=1
            )
            await default_role.save()
            print(f"Created default role: {default_role.name}")
        else:
            print(f"Default role already exists: {default_role.name}")
            
        # Create admin role if it doesn't exist
        admin_role = await Role.find_one({"name": "admin"})
        if not admin_role:
            admin_role = Role(
                name="admin",
                display_name="Administrator",
                description="Administrator role",
                role_type="system",
                is_system_role=True,
                is_active=True,
                priority=10
            )
            await admin_role.save()
            print(f"Created admin role: {admin_role.name}")
        else:
            print(f"Admin role already exists: {admin_role.name}")
            
        return default_role, admin_role
        
    except Exception as e:
        print(f"Error creating default roles: {e}")
        raise

async def assign_roles_to_users():
    """Assign default roles to users who don't have roles"""
    try:
        # Connect to database
        await connect_to_mongo()
        
        # Initialize models
        from shared.database import init_database
        await init_database([UserProfile, Role, UserRole])
        
        # Create default roles
        default_role, admin_role = await create_default_roles()
        
        # Get all user profiles
        user_profiles = await UserProfile.find_all().to_list()
        print(f"Found {len(user_profiles)} user profiles")
        
        users_without_roles = 0
        users_with_roles = 0
        
        for profile in user_profiles:
            # Check if user has any roles
            user_roles = await UserRole.get_user_roles(profile.user_id, active_only=True)
            
            if not user_roles:
                # User has no roles, assign default role
                user_role = UserRole(
                    user_id=profile.user_id,
                    role_name=default_role.name,
                    assigned_by=None,  # System assignment
                    reason="Default role assignment",
                    is_active=True
                )
                await user_role.save()
                print(f"Assigned default role to user: {profile.email}")
                users_without_roles += 1
            else:
                print(f"User {profile.email} already has roles: {[ur.role_name for ur in user_roles]}")
                users_with_roles += 1
        
        print(f"\nSummary:")
        print(f"Users without roles (fixed): {users_without_roles}")
        print(f"Users with existing roles: {users_with_roles}")
        print(f"Total users processed: {len(user_profiles)}")
        
    except Exception as e:
        print(f"Error assigning roles: {e}")
        raise
    finally:
        await close_mongo_connection()

async def main():
    """Main function"""
    print("Starting role assignment fix...")
    await assign_roles_to_users()
    print("Role assignment fix completed!")

if __name__ == "__main__":
    asyncio.run(main())