import random
from typing import Optional

from fastapi import HTTPException, status
from sqlalchemy import Delete, Select, and_
from sqlalchemy.orm import selectinload

from src.auth.service import CurrentUser
from src.database.core import DbSession
from src.database.service import CommonParameters, search_filter_sort_paginate
from src.overhaul_activity.model import OverhaulActivity
from src.standard_scope.model import MasterEquipment
from src.standard_scope.service import get_equipment_level_by_no
from src.workscope_group.model import MasterActivity
from src.workscope_group_maintenance_type.model import WorkscopeOHType
from src.overhaul_scope.model import MaintenanceType

from .model import EquipmentWorkscopeGroup
from .schema import ScopeEquipmentJobCreate

# async def get(*, db_session: DbSession, scope_equipment_activity_id: str) -> Optional[ScopeEquipmentActivity]:
#     """Returns a document based on the given document id."""
#     result = await db_session.get(ScopeEquipmentActivity, scope_equipment_activity_id)
#     return result


# async def get_all(db_session: DbSession, assetnum: Optional[str], common):
#     # Example usage
#     if not assetnum:
#         raise ValueError("assetnum parameter is required")

#     # First get the parent equipment
#     equipment_stmt = Select(MasterEquipment).where(MasterEquipment.assetnum == assetnum)
#     equipment: MasterEquipment = await db_session.scalar(equipment_stmt)

#     if not equipment:
#         raise ValueError(f"No equipment found with assetnum: {assetnum}")

#     # Build query for parts
#     stmt = (
#         Select(ScopeEquipmentJob)
#         .where(ScopeEquipmentJob.assetnum == assetnum)
#         .options(
#             selectinload(ScopeEquipmentJob.job),
#             selectinload(ScopeEquipmentJob.overhaul_jobs)
#             .selectinload(OverhaulJob.overhaul_activity)
#             .selectinload(OverhaulActivity.overhaul_scope),
#         )
#     )

#     results = await search_filter_sort_paginate(model=stmt, **common)

#     return results

async def get_all(*, common, location_tag: str, scope: Optional[str] = None):
    """Returns all documents."""
    query = (
        Select(EquipmentWorkscopeGroup)
        .where(EquipmentWorkscopeGroup.location_tag == location_tag).filter(EquipmentWorkscopeGroup.workscope_group_id.is_not(None))
    )

    if scope:
        query = (
            query
            .join(EquipmentWorkscopeGroup.workscope_group)
            .join(MasterActivity.oh_types)
            .join(WorkscopeOHType.oh_type)
            .filter(MaintenanceType.name == scope)
        )

    results = await search_filter_sort_paginate(model=query, **common)
    return results


async def create(
    *, db_session: DbSession, assetnum, scope_job_in: ScopeEquipmentJobCreate
):
    scope_jobs = []

    if not assetnum:
        raise ValueError("assetnum parameter is required")

    # First get the parent equipment
    equipment_stmt = Select(MasterEquipment).where(MasterEquipment.assetnum == assetnum)
    equipment: MasterEquipment = await db_session.scalar(equipment_stmt)

    if not equipment:
        raise ValueError(f"No equipment found with assetnum: {assetnum}")

    for job_id in scope_job_in.job_ids:
        scope_equipment_job = ScopeEquipmentJob(assetnum=assetnum, job_id=job_id)
        scope_jobs.append(scope_equipment_job)

    db_session.add_all(scope_jobs)
    await db_session.commit()
    return


# async def update(*, db_session: DbSession, activity: ScopeEquipmentActivity, scope_equipment_activty_in: ScopeEquipmentActivityUpdate):
#     """Updates a document."""
#     data = scope_equipment_activty_in.model_dump()

#     update_data = scope_equipment_activty_in.model_dump(exclude_defaults=True)

#     for field in data:
#         if field in update_data:
#             setattr(activity, field, update_data[field])

#     await db_session.commit()

#     return activity


async def delete(
    *,
    db_session: DbSession,
    scope_job_id: int,
) -> bool:
    """
    Deletes a scope job and returns success status.

    Args:
        db_session: Database session
        scope_job_id: ID of the scope job to delete
        user_id: ID of user performing the deletion

    Returns:
        bool: True if deletion was successful, False otherwise

    Raises:
        NotFoundException: If scope job doesn't exist
        AuthorizationError: If user lacks delete permission
    """
    try:
        # Check if job exists
        scope_job = await db_session.get(ScopeEquipmentJob, scope_job_id)
        if not scope_job:
            raise HTTPException(
                status_code=status.HTTP_404_NOT_FOUND,
                detail="A data with this id does not exist.",
            )

        # Perform deletion
        await db_session.delete(scope_job)
        await db_session.commit()

        return True

    except Exception as e:
        await db_session.rollback()
        raise