def __init__(self, log_path: Optional[Path] = None):
    self.log_path = log_path or REMOVAL_LOG_PATH
    self.log_path.parent.mkdir(parents=True, exist_ok=True)

async def log_removal(
    self,
    uid: str,
    summary: str,
    start_time: str,
    removed_by: str = "telegram_callback",
    source: str = "newsletter",
    reason: Optional[str] = None
) -> None:
    """Log an event removal.

    Args:
        uid: Event UID that was removed
        summary: Event title/summary
        start_time: When the event was scheduled
        removed_by: Who/what triggered removal (telegram_callback, manual, etc.)
        source: Where the event came from (newsletter, appointment, family, etc.)
        reason: Optional reason for removal
    """
    entry = {
        "uid": uid,
        "summary": summary,
        "start_time": start_time,
        "removed_at": datetime.now().isoformat(),
        "removed_by": removed_by,
        "source": source,
        "reason": reason,
        "can_undo": False  # Radicale doesn't support undo after DELETE
    }

    try:
        with open(self.log_path, "a") as f:
            f.write(json.dumps(entry) + "\n")
        logger.info(f"Logged removal: {summary} ({uid})")
    except Exception as e:
        logger.error(f"Failed to log removal: {e}")

def get_recent_removals(
    self,
    hours: int = 24,
    limit: int = 20,
    source: Optional[str] = None
) -> List[Dict[str, Any]]:
    """Get recently removed events.

    Args:
        hours: How far back to look
        limit: Max results
        source: Filter by source type (optional)

    Returns:
        List of removal records
    """
    if not self.log_path.exists():
        return []

    cutoff = datetime.now() - timedelta(hours=hours)
    removals = []

    try:
        with open(self.log_path, "r") as f:
            for line in f:
                line = line.strip()
                if not line:
                    continue
                try:
                    entry = json.loads(line)
                    removed_at = datetime.fromisoformat(entry.get("removed_at", ""))
                    if removed_at >= cutoff:
                        if source is None or entry.get("source") == source:
                            removals.append(entry)
                except (json.JSONDecodeError, ValueError):
                    continue
    except Exception as e:
        logger.error(f"Failed to read removal log: {e}")
        return []

    # Sort by removal time, newest first
    removals.sort(key=lambda x: x.get("removed_at", ""), reverse=True)
    return removals[:limit]

def cleanup_old_entries(self) -> int:
    """Remove entries older than MAX_RETENTION_DAYS.

    Returns:
        Number of entries removed
    """
    if not self.log_path.exists():
        return 0

    cutoff = datetime.now() - timedelta(days=MAX_RETENTION_DAYS)
    kept = []
    removed_count = 0

    try:
        with open(self.log_path, "r") as f:
            for line in f:
                line = line.strip()
                if not line:
                    continue
                try:
                    entry = json.loads(line)
                    removed_at = datetime.fromisoformat(entry.get("removed_at", ""))
                    if removed_at >= cutoff:
                        kept.append(line)
                    else:
                        removed_count += 1
                except (json.JSONDecodeError, ValueError):
                    kept.append(line)  # Keep malformed lines for inspection

        with open(self.log_path, "w") as f:
            for line in kept:
                f.write(line + "\n")

        if removed_count > 0:
            logger.info(f"Cleaned up {removed_count} old removal entries")

        return removed_count
    except Exception as e:
        logger.error(f"Failed to cleanup removal log: {e}")
        return 0