from datetime import datetime
from typing import Any, Dict, List, Optional, Union

from sqlalchemy import asc, desc
from sqlalchemy.orm import Session

from app.models.note import Note
from app.schemas.note import NoteCreate, NoteUpdate


def get(db: Session, note_id: int) -> Optional[Note]:
    return db.query(Note).filter(Note.id == note_id).first()


def get_multi_by_owner(
    db: Session, owner_id: int, skip: int = 0, limit: int = 100
) -> List[Note]:
    return (
        db.query(Note)
        .filter(Note.owner_id == owner_id)
        .offset(skip)
        .limit(limit)
        .all()
    )


def get_multi_by_owner_sorted(
    db: Session, owner_id: int, skip: int = 0, limit: int = 100, sort_by: str = "created_at", sort_order: str = "desc"
) -> List[Note]:
    """Get notes sorted by specified field."""
    query = db.query(Note).filter(Note.owner_id == owner_id)

    # Determine sort field
    if sort_by == "title":
        sort_field = Note.title
    elif sort_by == "updated_at":
        sort_field = Note.updated_at
    else:  # Default to created_at
        sort_field = Note.created_at

    # Apply sort order
    if sort_order == "asc":
        query = query.order_by(asc(sort_field))
    else:  # Default to desc
        query = query.order_by(desc(sort_field))

    return query.offset(skip).limit(limit).all()


def get_multi_by_collection(
    db: Session, owner_id: int, collection_id: int, skip: int = 0, limit: int = 100
) -> List[Note]:
    return (
        db.query(Note)
        .filter(Note.owner_id == owner_id, Note.collection_id == collection_id)
        .offset(skip)
        .limit(limit)
        .all()
    )


def search_notes(
    db: Session, owner_id: int, search_term: str, skip: int = 0, limit: int = 100
) -> List[Note]:
    """Search notes by title or content."""
    search_pattern = f"%{search_term}%"
    return (
        db.query(Note)
        .filter(
            Note.owner_id == owner_id,
            (Note.title.ilike(search_pattern) | Note.content.ilike(search_pattern))
        )
        .offset(skip)
        .limit(limit)
        .all()
    )


def get_archived_notes(
    db: Session, owner_id: int, skip: int = 0, limit: int = 100
) -> List[Note]:
    """Get archived notes."""
    return (
        db.query(Note)
        .filter(Note.owner_id == owner_id, Note.is_archived)
        .offset(skip)
        .limit(limit)
        .all()
    )


def get_notes_created_between(
    db: Session, owner_id: int, start_date: datetime, end_date: datetime, skip: int = 0, limit: int = 100
) -> List[Note]:
    """Get notes created between specified dates."""
    return (
        db.query(Note)
        .filter(
            Note.owner_id == owner_id,
            Note.created_at >= start_date,
            Note.created_at <= end_date
        )
        .offset(skip)
        .limit(limit)
        .all()
    )


def create(db: Session, *, obj_in: NoteCreate, owner_id: int) -> Note:
    db_obj = Note(
        **obj_in.model_dump(),
        owner_id=owner_id,
    )
    db.add(db_obj)
    db.commit()
    db.refresh(db_obj)
    return db_obj


def update(
    db: Session, *, db_obj: Note, obj_in: Union[NoteUpdate, Dict[str, Any]]
) -> Note:
    if isinstance(obj_in, dict):
        update_data = obj_in
    else:
        update_data = obj_in.model_dump(exclude_unset=True)
    for field in update_data:
        if field in update_data:
            setattr(db_obj, field, update_data[field])
    db.add(db_obj)
    db.commit()
    db.refresh(db_obj)
    return db_obj


def remove(db: Session, *, note_id: int, owner_id: int) -> Optional[Note]:
    obj = db.query(Note).filter(Note.id == note_id, Note.owner_id == owner_id).first()
    if obj:
        db.delete(obj)
        db.commit()
    return obj