from sqlalchemy import Select, Delete, desc, func

from src.workorder.model import MasterWorkOrder
from .model import ScopeEquipment
from src.scope.service import get_by_scope_name as get_scope_by_name_service
from .schema import ScopeEquipmentCreate, ScopeEquipmentUpdate
from typing import Optional, Union
from sqlalchemy.orm import selectinload
from src.database.service import CommonParameters, search_filter_sort_paginate

from src.database.core import DbSession
from src.auth.service import CurrentUser


async def get(*, db_session: DbSession, scope_equipment_id: str) -> Optional[ScopeEquipment]:
    """Returns a document based on the given document id."""
    query = Select(ScopeEquipment).filter(
        ScopeEquipment.id == scope_equipment_id)
    result = await db_session.execute(query)
    return result.scalars().one_or_none()


async def get_all(*, db_session: DbSession, common, scope_name: str = None, exclude: bool = False):
    """Returns all documents."""
    query = Select(ScopeEquipment).options(selectinload(
        ScopeEquipment.scope), selectinload(ScopeEquipment.master_equipment))


    query = query.order_by(desc(ScopeEquipment.created_at))

    if scope_name:
        scope = await get_scope_by_name_service(db_session=db_session, scope_name=scope_name)
        query = query.filter(ScopeEquipment.scope_id == scope.id) if not exclude else query.filter(
            ScopeEquipment.scope_id != scope.id)

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


async def create(*, db_session: DbSession, scope_equipment_in: ScopeEquipmentCreate):
    """Creates a new document."""
    scope_equipment = ScopeEquipment(**scope_equipment_in.model_dump())
    db_session.add(scope_equipment)
    await db_session.commit()
    return scope_equipment


async def update(*, db_session: DbSession, scope_equipment: ScopeEquipment, scope_equipment_in: ScopeEquipmentUpdate):
    """Updates a document."""
    data = scope_equipment_in.model_dump()

    update_data = scope_equipment_in.model_dump(exclude_defaults=True)

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

    await db_session.commit()

    return scope_equipment


async def delete(*, db_session: DbSession, scope_equipment_id: str):
    """Deletes a document."""
    query = Delete(ScopeEquipment).where(
        ScopeEquipment.id == scope_equipment_id)
    await db_session.execute(query)
    await db_session.commit()


async def get_by_scope_name(*, db_session: DbSession, scope_name: Union[str, list]) -> Optional[ScopeEquipment]:
    """Returns a document based on the given document id."""
    scope = await get_scope_by_name_service(db_session=db_session, scope_name=scope_name)

    query = Select(ScopeEquipment)

    if scope:
        query = query.filter(ScopeEquipment.scope_id == scope.id)

    result = await db_session.execute(query)
    return result.scalars().all()


async def get_exculed_scope_name(*, db_session: DbSession, scope_name: Union[str, list]) -> Optional[ScopeEquipment]:
    scope = await get_scope_by_name_service(db_session=db_session, scope_name=scope_name)

    query = Select(ScopeEquipment)

    if scope:
        query = query.filter(ScopeEquipment.scope_id != scope.id)

    else:
        query = query.filter(ScopeEquipment.scope_id != None)

    result = await db_session.execute(query)
    return result.scalars().all()