from sqlalchemy.orm import Session
from typing import Optional, List
from .models import Jobtype, Jobstatus, Jobpriority, Tag


# Jobtype repository functions
def get_jobtype_by_id(db: Session, entity_id: str) -> Optional[Jobtype]:
    """Get Jobtype by ID."""
    return db.query(Jobtype).filter(Jobtype.id == entity_id).first()


def list_jobtypes(db: Session, limit: int = 20, offset: int = 0, **filters) -> List[Jobtype]:
    """List Jobtypes."""
    q = db.query(Jobtype)
    if filters.get("is_active") is not None:
        q = q.filter(Jobtype.is_active == filters["is_active"])
    if filters.get("search"):
        search_term = f"%{filters['search']}%"
        q = q.filter(Jobtype.name.ilike(search_term))
    return q.order_by(Jobtype.created_at.desc()).limit(limit).offset(offset).all()


def count_jobtypes(db: Session, **filters) -> int:
    """Count Jobtypes."""
    q = db.query(Jobtype.id)
    if filters.get("is_active") is not None:
        q = q.filter(Jobtype.is_active == filters["is_active"])
    if filters.get("search"):
        search_term = f"%{filters['search']}%"
        q = q.filter(Jobtype.name.ilike(search_term))
    return q.count()


def create_jobtype(db: Session, data: dict) -> Jobtype:
    """Create Jobtype."""
    obj = Jobtype(**data)
    db.add(obj)
    db.flush()
    return obj


def update_jobtype(db: Session, entity_id: str, data: dict) -> Optional[Jobtype]:
    """Update Jobtype."""
    obj = db.query(Jobtype).filter(Jobtype.id == entity_id).first()
    if not obj:
        return None
    for key, value in data.items():
        setattr(obj, key, value)
    db.flush()
    return obj


def delete_jobtype(db: Session, entity_id: str) -> bool:
    """Delete Jobtype."""
    obj = db.query(Jobtype).filter(Jobtype.id == entity_id).first()
    if not obj:
        return False
    db.delete(obj)
    db.flush()
    return True


# Jobstatus repository functions
def get_by_id(db: Session, entity_id: str) -> Optional[Jobstatus]:
    """Get Jobstatus by ID."""
    return db.query(Jobstatus).filter(Jobstatus.id == entity_id).first()


def list_all(db: Session, limit: int = 20, offset: int = 0, **filters) -> List[Jobstatus]:
    """List Jobstatuses."""
    q = db.query(Jobstatus)
    if filters.get("is_active") is not None:
        q = q.filter(Jobstatus.is_active == filters["is_active"])
    if filters.get("search"):
        search_term = f"%{filters['search']}%"
        q = q.filter(Jobstatus.name.ilike(search_term))
    return q.order_by(Jobstatus.created_at.desc()).limit(limit).offset(offset).all()


def count_all(db: Session, **filters) -> int:
    """Count Jobstatuses."""
    q = db.query(Jobstatus.id)
    if filters.get("is_active") is not None:
        q = q.filter(Jobstatus.is_active == filters["is_active"])
    if filters.get("search"):
        search_term = f"%{filters['search']}%"
        q = q.filter(Jobstatus.name.ilike(search_term))
    return q.count()


def create(db: Session, data: dict) -> Jobstatus:
    """Create Jobstatus."""
    obj = Jobstatus(**data)
    db.add(obj)
    db.flush()
    return obj


def update(db: Session, entity_id: str, data: dict) -> Optional[Jobstatus]:
    """Update Jobstatus."""
    obj = db.query(Jobstatus).filter(Jobstatus.id == entity_id).first()
    if not obj:
        return None
    for key, value in data.items():
        setattr(obj, key, value)
    db.flush()
    return obj


def delete(db: Session, entity_id: str) -> bool:
    """Delete Jobstatus."""
    obj = db.query(Jobstatus).filter(Jobstatus.id == entity_id).first()
    if not obj:
        return False
    db.delete(obj)
    db.flush()
    return True


# Jobpriority repository functions
def get_jobpriority_by_id(db: Session, entity_id: str) -> Optional[Jobpriority]:
    """Get Jobpriority by ID."""
    return db.query(Jobpriority).filter(Jobpriority.id == entity_id).first()


def list_jobpriorities(db: Session, limit: int = 20, offset: int = 0, **filters) -> List[Jobpriority]:
    """List Jobpriorities."""
    q = db.query(Jobpriority)
    if filters.get("is_active") is not None:
        q = q.filter(Jobpriority.is_active == filters["is_active"])
    if filters.get("search"):
        search_term = f"%{filters['search']}%"
        q = q.filter(Jobpriority.name.ilike(search_term))
    return q.order_by(Jobpriority.created_at.desc()).limit(limit).offset(offset).all()


def count_jobpriorities(db: Session, **filters) -> int:
    """Count Jobpriorities."""
    q = db.query(Jobpriority.id)
    if filters.get("is_active") is not None:
        q = q.filter(Jobpriority.is_active == filters["is_active"])
    if filters.get("search"):
        search_term = f"%{filters['search']}%"
        q = q.filter(Jobpriority.name.ilike(search_term))
    return q.count()


def create_jobpriority(db: Session, data: dict) -> Jobpriority:
    """Create Jobpriority."""
    obj = Jobpriority(**data)
    db.add(obj)
    db.flush()
    return obj


def update_jobpriority(db: Session, entity_id: str, data: dict) -> Optional[Jobpriority]:
    """Update Jobpriority."""
    obj = db.query(Jobpriority).filter(Jobpriority.id == entity_id).first()
    if not obj:
        return None
    for key, value in data.items():
        setattr(obj, key, value)
    db.flush()
    return obj


def delete_jobpriority(db: Session, entity_id: str) -> bool:
    """Delete Jobpriority."""
    obj = db.query(Jobpriority).filter(Jobpriority.id == entity_id).first()
    if not obj:
        return False
    db.delete(obj)
    db.flush()
    return True


# Tag repository functions
def get_tag_by_id(db: Session, entity_id: str) -> Optional[Tag]:
    """Get Tag by ID."""
    return db.query(Tag).filter(Tag.id == entity_id).first()


def list_tags(db: Session, limit: int = 20, offset: int = 0, **filters) -> List[Tag]:
    """List Tags."""
    q = db.query(Tag)
    if filters.get("is_active") is not None:
        q = q.filter(Tag.is_active == filters["is_active"])
    if filters.get("search"):
        search_term = f"%{filters['search']}%"
        q = q.filter(Tag.name.ilike(search_term))
    return q.order_by(Tag.created_at.desc()).limit(limit).offset(offset).all()


def count_tags(db: Session, **filters) -> int:
    """Count Tags."""
    q = db.query(Tag.id)
    if filters.get("is_active") is not None:
        q = q.filter(Tag.is_active == filters["is_active"])
    if filters.get("search"):
        search_term = f"%{filters['search']}%"
        q = q.filter(Tag.name.ilike(search_term))
    return q.count()


def create_tag(db: Session, data: dict) -> Tag:
    """Create Tag."""
    obj = Tag(**data)
    db.add(obj)
    db.flush()
    return obj


def update_tag(db: Session, entity_id: str, data: dict) -> Optional[Tag]:
    """Update Tag."""
    obj = db.query(Tag).filter(Tag.id == entity_id).first()
    if not obj:
        return None
    for key, value in data.items():
        setattr(obj, key, value)
    db.flush()
    return obj


def delete_tag(db: Session, entity_id: str) -> bool:
    """Delete Tag."""
    obj = db.query(Tag).filter(Tag.id == entity_id).first()
    if not obj:
        return False
    db.delete(obj)
    db.flush()
    return True