"""
CRUD operations for tasks
"""
from datetime import datetime
from typing import List, Optional

from sqlalchemy import or_
from sqlalchemy.orm import Session

from app.crud.base import CRUDBase
from app.models.task import Task, TaskPriority, TaskStatus
from app.schemas.task import TaskCreate, TaskUpdate


class CRUDTask(CRUDBase[Task, TaskCreate, TaskUpdate]):
    """
    CRUD operations for Task model
    """
    def create_with_owner(
        self, db: Session, *, obj_in: TaskCreate, owner_id: int
    ) -> Task:
        """
        Create a new task with owner
        """
        db_obj = Task(
            title=obj_in.title,
            description=obj_in.description,
            status=obj_in.status,
            priority=obj_in.priority,
            due_date=obj_in.due_date,
            owner_id=owner_id,
            created_at=datetime.utcnow(),
            updated_at=datetime.utcnow(),
            is_deleted=False,
        )
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj

    def get_multi_by_owner(
        self, db: Session, *, owner_id: int, skip: int = 0, limit: int = 100
    ) -> List[Task]:
        """
        Get multiple tasks by owner with pagination
        """
        return (
            db.query(self.model)
            .filter(Task.owner_id == owner_id, not Task.is_deleted)
            .offset(skip)
            .limit(limit)
            .all()
        )
    
    def get_multi_by_owner_and_status(
        self, db: Session, *, owner_id: int, status: TaskStatus, 
        skip: int = 0, limit: int = 100
    ) -> List[Task]:
        """
        Get multiple tasks by owner and status with pagination
        """
        return (
            db.query(self.model)
            .filter(
                Task.owner_id == owner_id,
                Task.status == status,
                not Task.is_deleted
            )
            .offset(skip)
            .limit(limit)
            .all()
        )
    
    def get_multi_by_owner_and_priority(
        self, db: Session, *, owner_id: int, priority: TaskPriority, 
        skip: int = 0, limit: int = 100
    ) -> List[Task]:
        """
        Get multiple tasks by owner and priority with pagination
        """
        return (
            db.query(self.model)
            .filter(
                Task.owner_id == owner_id,
                Task.priority == priority,
                not Task.is_deleted
            )
            .offset(skip)
            .limit(limit)
            .all()
        )
    
    def get_multi_by_owner_and_search(
        self, db: Session, *, owner_id: int, search: str, 
        skip: int = 0, limit: int = 100
    ) -> List[Task]:
        """
        Get multiple tasks by owner and search term with pagination
        """
        search_pattern = f"%{search}%"
        return (
            db.query(self.model)
            .filter(
                Task.owner_id == owner_id,
                or_(
                    Task.title.ilike(search_pattern),
                    Task.description.ilike(search_pattern)
                ),
                not Task.is_deleted
            )
            .offset(skip)
            .limit(limit)
            .all()
        )
    
    def get_multi_by_owner_and_due_date_range(
        self, db: Session, *, owner_id: int, start_date: datetime, end_date: datetime, 
        skip: int = 0, limit: int = 100
    ) -> List[Task]:
        """
        Get multiple tasks by owner and due date range with pagination
        """
        return (
            db.query(self.model)
            .filter(
                Task.owner_id == owner_id,
                Task.due_date >= start_date,
                Task.due_date <= end_date,
                not Task.is_deleted
            )
            .offset(skip)
            .limit(limit)
            .all()
        )
    
    def get_by_id_and_owner(
        self, db: Session, *, id: int, owner_id: int
    ) -> Optional[Task]:
        """
        Get a task by ID and owner
        """
        return (
            db.query(self.model)
            .filter(
                Task.id == id,
                Task.owner_id == owner_id,
                not Task.is_deleted
            )
            .first()
        )
    
    def update_status(
        self, db: Session, *, db_obj: Task, status: TaskStatus
    ) -> Task:
        """
        Update a task status
        """
        db_obj.status = status
        db_obj.updated_at = datetime.utcnow()
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj
    
    def soft_delete(
        self, db: Session, *, db_obj: Task
    ) -> Task:
        """
        Mark a task as deleted (soft delete)
        """
        db_obj.is_deleted = True
        db_obj.updated_at = datetime.utcnow()
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj


task = CRUDTask(Task)