Radicale uses UUIDs for calendar URLs - discovered via PROPFIND

def __init__(self):
    self.base_url = f"http://{RADICALE_HOST}:{RADICALE_PORT}"
    self.calendar_url = f"{self.base_url}/{RADICALE_USER}/{FAMILY_CALENDAR_UUID}"
    self.client = httpx.AsyncClient(
        auth=(RADICALE_USER, RADICALE_PASS),
        timeout=30.0
    )

async def health(self) -> Dict[str, Any]:
    """Check Radicale connectivity."""
    try:
        response = await self.client.request("PROPFIND", self.calendar_url)
        return {
            "connected": response.status_code == 207,
            "url": self.calendar_url
        }
    except Exception as e:
        logger.warning(f"Calendar health check failed: {e}")
        return {"connected": False, "url": self.calendar_url}

async def create_event(
    self,
    summary: str,
    start_datetime: str,
    end_datetime: str,
    description: str = "",
    location: str = "",
    uid: Optional[str] = None
) -> Dict[str, Any]:
    """Create a calendar event via CalDAV.

    Args:
        summary: Event title
        start_datetime: ISO 8601 start time
        end_datetime: ISO 8601 end time
        description: Event details
        location: Event location
        uid: Optional unique ID (auto-generated if not provided)

    Returns:
        Dict with success status and event details
    """
    from uuid import uuid4
    from datetime import datetime

    uid = uid or str(uuid4())
    timestamp = datetime.now().strftime("%Y%m%dT%H%M%SZ")

    # Convert ISO datetimes to iCalendar format
    def to_ical(dt_str: str) -> str:
        dt = datetime.fromisoformat(dt_str.replace('Z', '+00:00'))
        return dt.strftime("%Y%m%dT%H%M%S")

    start_ical = to_ical(start_datetime)
    end_ical = to_ical(end_datetime)

    ical = f"""BEGIN:VCALENDAR

    event_url = f"{self.calendar_url}/{uid}.ics"

    try:
        response = await self.client.put(
            event_url,
            content=ical,
            headers={"Content-Type": "text/calendar"}
        )

        success = response.status_code in (201, 204)

        if success:
            logger.info(f"Created calendar event: {summary}")
        else:
            logger.error(f"Calendar create failed: {response.status_code}")

        return {
            "created": success,
            "uid": uid,
            "url": event_url if success else None,
            "status_code": response.status_code
        }

    except Exception as e:
        logger.exception("Calendar create failed")
        return {"created": False, "error": str(e)}

async def close(self):
    await self.client.aclose()

async def delete_event(self, uid: str) -> Dict[str, Any]:
    """Delete a calendar event by UID.

    Args:
        uid: Event UID to delete

    Returns:
        Dict with deleted status
    """
    event_url = f"{self.calendar_url}/{uid}.ics"

    try:
        response = await self.client.delete(event_url)

        # 204 = deleted, 404 = already gone (still success)
        success = response.status_code in (204, 404)

        if success:
            logger.info(f"Deleted calendar event: {uid}")
        else:
            logger.error(f"Calendar delete failed: {response.status_code}")

        return {
            "deleted": success,
            "uid": uid,
            "status_code": response.status_code
        }

    except Exception as e:
        logger.exception(f"Calendar delete failed for {uid}")
        return {"deleted": False, "uid": uid, "error": str(e)}