"""
Event Service - Manages celestial events
"""
import logging
from typing import List, Optional
from datetime import datetime, timedelta
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, delete, func, desc
from sqlalchemy.orm import selectinload
from app.models.db.celestial_event import CelestialEvent
from app.models.schemas.social import CelestialEventCreate, CelestialEventResponse
from app.models.db.celestial_body import CelestialBody

logger = logging.getLogger(__name__)

class EventService:
    async def create_event(self, event_data: CelestialEventCreate, db: AsyncSession) -> CelestialEvent:
        """Create a new celestial event"""
        event = CelestialEvent(**event_data.dict())
        db.add(event)
        await db.commit()
        await db.refresh(event)
        logger.info(f"Created celestial event: {event.title} for {event.body_id}")
        return event

    async def get_event(self, event_id: int, db: AsyncSession) -> Optional[CelestialEvent]:
        """Get a specific celestial event by ID"""
        result = await db.execute(select(CelestialEvent).where(CelestialEvent.id == event_id))
        return result.scalar_one_or_none()

    async def get_events(
        self,
        db: AsyncSession,
        body_id: Optional[str] = None,
        start_time: Optional[datetime] = None,
        end_time: Optional[datetime] = None,
        limit: int = 100,
        offset: int = 0
    ) -> List[CelestialEvent]:
        """Get a list of celestial events, with optional filters"""
        query = select(CelestialEvent).options(selectinload(CelestialEvent.body))
        if body_id:
            query = query.where(CelestialEvent.body_id == body_id)
        if start_time:
            query = query.where(CelestialEvent.event_time >= start_time)
        if end_time:
            query = query.where(CelestialEvent.event_time <= end_time)

        query = query.order_by(CelestialEvent.event_time).offset(offset).limit(limit)
        result = await db.execute(query)
        return result.scalars().all()

    async def delete_event(self, event_id: int, db: AsyncSession) -> bool:
        """Delete a celestial event by ID"""
        event = await self.get_event(event_id, db)
        if event:
            await db.delete(event)
            await db.commit()
            logger.info(f"Deleted celestial event: {event.title} (ID: {event.id})")
            return True
        return False
    
    async def delete_events_for_body_before(self, body_id: str, before_time: datetime, db: AsyncSession) -> int:
        """Delete old events for a specific body before a given time"""
        result = await db.execute(
            delete(CelestialEvent).where(
                CelestialEvent.body_id == body_id,
                CelestialEvent.event_time < before_time
            )
        )
        await db.commit()
        return result.rowcount

event_service = EventService()