import asyncio
import uuid
import os
import sys
from datetime import datetime, timezone
from sqlalchemy import select
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker

# Add project root to sys.path
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from app.models.access_models import RoleMaster, RoleModulePermission
from dotenv import load_dotenv

load_dotenv()

DATABASE_URL = os.environ.get("DATABASE_URL")
if not DATABASE_URL:
    raise ValueError("DATABASE_URL environment variable is not set in backend/.env")

engine = create_async_engine(DATABASE_URL)
Session = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)

OPERATOR_ROLES = [
    ("YARD_SUPERVISOR", "Yard Supervisor", "Oversees Yard operations, Chassis Inward, Station Scanning & Reports"),
    ("PRODUCTION_SUPERVISOR", "Production Supervisor", "Shopfloor station scanning, timers & chassis flow control"),
]

async def seed_operator_roles():
    async with Session() as db:
        for code, name, desc in OPERATOR_ROLES:
            role = (await db.execute(
                select(RoleMaster).where(RoleMaster.role_code == code)
            )).scalar_one_or_none()

            if not role:
                role = RoleMaster(
                    role_id=uuid.uuid4(),
                    role_code=code,
                    role_name=name,
                    description=desc,
                    is_system_role=False,
                    is_active=True,
                    created_at=datetime.now(timezone.utc),
                )
                db.add(role)
                print(f"Created role: {code} ({name})")
            else:
                print(f"Role already exists: {code}")

            # Ensure default permissions
            default_modules = [("YARD", True)] if code == "YARD_SUPERVISOR" else [("PRODUCTION", False), ("STATION", False), ("YARD", False)]
            for mod_code, can_app in default_modules:
                perm = (await db.execute(
                    select(RoleModulePermission).where(
                        RoleModulePermission.role_code == code,
                        RoleModulePermission.module_code == mod_code
                    )
                )).scalar_one_or_none()

                if not perm:
                    db.add(RoleModulePermission(
                        id=uuid.uuid4(),
                        role_code=code,
                        module_code=mod_code,
                        can_view=True,
                        can_create=True,
                        can_edit=True,
                        can_delete=False,
                        can_approve=can_app,
                    ))
                    print(f"Assigned {mod_code} module permission to: {code}")

        await db.commit()
        print("Operator roles seed completed successfully.")

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