# modules/calendar/service.py
from sqlalchemy.orm import Session
from sqlalchemy import or_ # Import or_
from datetime import datetime
from modules.calendar.models import CalendarEvent
from core.exceptions import not_found_exception
from modules.calendar.schemas import CalendarEventCreate, CalendarEventUpdate # Import schemas

def create_calendar_event(db: Session, user_id: int, event_data: CalendarEventCreate):
    # Ensure tags is None if not provided or empty list, matching model
    tags_to_store = event_data.tags if event_data.tags else None
    event = CalendarEvent(
        **event_data.model_dump(exclude={'tags'}), # Use model_dump and exclude tags initially
        tags=tags_to_store, # Set tags separately
        user_id=user_id
    )
    db.add(event)
    db.commit()
    db.refresh(event)
    return event

def get_calendar_events(db: Session, user_id: int, start: datetime | None, end: datetime | None):
    """
    Retrieves calendar events for a user, optionally filtered by a date range.

    Args:
        db: The database session.
        user_id: The ID of the user whose events are to be retrieved.
        start: The start datetime of the filter range (inclusive).
        end: The end datetime of the filter range (exclusive).

    Returns:
        A list of CalendarEvent objects matching the criteria, ordered by start time.
    """
    print(f"Getting calendar events for user {user_id} in range [{start}, {end})")
    query = db.query(CalendarEvent).filter(CalendarEvent.user_id == user_id)

    # If start and end dates are provided, filter for events overlapping the range [start, end).
    if start and end:
        # An event overlaps the range [start, end) if:
        # 1. It has a duration (end is not None) AND its interval [event.start, event.end)
        #    intersects with [start, end). Intersection occurs if:
        #    event.start < end AND event.end > start
        # 2. It's a point event (end is None) AND its start time falls within the range:
        #    start <= event.start < end
        query = query.filter(
            or_(
                # Case 1: Event has duration and overlaps
                (CalendarEvent.end != None) & (CalendarEvent.start < end) & (CalendarEvent.end > start),
                # Case 2: Event is a point event within the range
                (CalendarEvent.end == None) & (CalendarEvent.start >= start) & (CalendarEvent.start < end)
            )
        )
    # If only start is provided, filter events starting on or after start
    elif start:
        # Includes events with duration starting >= start
        # Includes point events occurring >= start
        query = query.filter(CalendarEvent.start >= start)
    # If only end is provided, filter events ending before end, or point events occurring before end
    elif end:
        # Includes events with duration ending <= end (or starting before end if end is None)
        # Includes point events occurring < end
         query = query.filter(
            or_(
                # Event ends before the specified end time
                (CalendarEvent.end != None) & (CalendarEvent.end <= end),
                # Point event occurs before the specified end time
                (CalendarEvent.end == None) & (CalendarEvent.start < end)
            )
        )
        # Alternative interpretation for "ending before end": include events that *start* before end
        # query = query.filter(CalendarEvent.start < end)


    return query.order_by(CalendarEvent.start).all() # Order by start time

def get_calendar_event_by_id(db: Session, user_id: int, event_id: int):
    event = db.query(CalendarEvent).filter(
        CalendarEvent.id == event_id,
        CalendarEvent.user_id == user_id
    ).first()
    if not event:
        raise not_found_exception()
    return event

def update_calendar_event(db: Session, user_id: int, event_id: int, event_data: CalendarEventUpdate):
    event = get_calendar_event_by_id(db, user_id, event_id) # Reuse get_by_id for check
    # Use model_dump with exclude_unset=True to only update provided fields
    update_data = event_data.model_dump(exclude_unset=True)

    for key, value in update_data.items():
        # Ensure tags is handled correctly (set to None if empty list provided)
        if key == 'tags' and isinstance(value, list) and not value:
            setattr(event, key, None)
        else:
            setattr(event, key, value)

    db.commit()
    db.refresh(event)
    return event

def delete_calendar_event(db: Session, user_id: int, event_id: int):
    event = get_calendar_event_by_id(db, user_id, event_id) # Reuse get_by_id for check
    db.delete(event)
    db.commit()