Platform-Specific Rename Detection

struct MacOSRenameDetector {
    // Maps inode → (path, timestamp) for recently deleted files
    deleted_inodes: HashMap<u64, (PathBuf, SystemTime)>,
    // Cleanup timer
    cleanup_interval: Duration,  // 500ms
}

impl MacOSRenameDetector {
    async fn handle_create(&mut self, path: PathBuf, inode: u64) -> Option<FsEvent> {
        // Check if this inode was recently deleted
        if let Some((old_path, _)) = self.deleted_inodes.remove(&inode) {
            // Same inode created within 500ms = rename!
            return Some(FsEvent {
                path: path.clone(),
                kind: FsEventKind::Rename {
                    from: old_path,
                    to: path,
                },
                timestamp: SystemTime::now(),
                is_directory: None,
            });
        }

        // Not a rename, just a create
        Some(FsEvent {
            path,
            kind: FsEventKind::Create,
            timestamp: SystemTime::now(),
            is_directory: None,
        })
    }

    async fn handle_delete(&mut self, path: PathBuf, inode: u64) {
        // Buffer delete for 500ms
        self.deleted_inodes.insert(inode, (path, SystemTime::now()));

        // After 500ms, if no matching create, emit actual delete
    }

    async fn cleanup_expired(&mut self) -> Vec<FsEvent> {
        let now = SystemTime::now();
        let mut expired = Vec::new();

        self.deleted_inodes.retain(|_, (path, timestamp)| {
            if now.duration_since(*timestamp).unwrap() > self.cleanup_interval {
                // No matching create arrived, emit delete
                expired.push(FsEvent {
                    path: path.clone(),
                    kind: FsEventKind::Remove,
                    timestamp: *timestamp,
                    is_directory: None,
                });
                false  // Remove from map
            } else {
                true  // Keep buffering
            }
        });

        expired
    }
}

struct LinuxRenameDetector {
    // Maps cookie → old_path for pending moves
    pending_moves: HashMap<u32, PathBuf>,
}

impl LinuxRenameDetector {
    async fn handle_moved_from(&mut self, path: PathBuf, cookie: u32) {
        // Buffer old path with cookie
        self.pending_moves.insert(cookie, path);
    }

    async fn handle_moved_to(&mut self, path: PathBuf, cookie: u32) -> FsEvent {
        if let Some(old_path) = self.pending_moves.remove(&cookie) {
            // Matching cookie = rename
            FsEvent {
                path: path.clone(),
                kind: FsEventKind::Rename {
                    from: old_path,
                    to: path,
                },
                timestamp: SystemTime::now(),
                is_directory: None,
            }
        } else {
            // No matching cookie, treat as create
            FsEvent {
                path,
                kind: FsEventKind::Create,
                timestamp: SystemTime::now(),
                is_directory: None,
            }
        }
    }
}

struct WindowsRenameDetector {
    // Buffer remove events briefly to match with creates
    removed_paths: HashMap<PathBuf, SystemTime>,
}

impl WindowsRenameDetector {
    async fn handle_remove(&mut self, path: PathBuf) {
        self.removed_paths.insert(path, SystemTime::now());
    }

    async fn handle_create(&mut self, path: PathBuf) -> FsEvent {
        // Check if similar path was removed recently (fuzzy match)
        // Windows rename detection is less precise, so we do best-effort
        // Based on file extension and parent directory matching

        for (removed_path, timestamp) in &self.removed_paths {
            if paths_likely_same_file(&path, removed_path) {
                return FsEvent {
                    path: path.clone(),
                    kind: FsEventKind::Rename {
                        from: removed_path.clone(),
                        to: path,
                    },
                    timestamp: SystemTime::now(),
                    is_directory: None,
                };
            }
        }

        // No match, just a create
        FsEvent {
            path,
            kind: FsEventKind::Create,
            timestamp: SystemTime::now(),
            is_directory: None,
        }
    }
}

# macOS
touch /tmp/test.txt
# Wait for watcher to register
mv /tmp/test.txt /tmp/renamed.txt
# Should emit: Rename { from: "/tmp/test.txt", to: "/tmp/renamed.txt" }

# Linux
touch /tmp/test.txt
mv /tmp/test.txt /tmp/renamed.txt
# Should emit: Rename (native inotify support)

# Windows
echo "test" > C:\temp\test.txt
rename C:\temp\test.txt renamed.txt
# Should emit: Rename (buffered detection)

// When Remove event received on macOS:
async fn handle_remove_with_db_lookup(path: PathBuf, inode: u64) -> FsEvent {
    // Check if inode exists in database
    if let Some(entry) = db.find_entry_by_inode(inode).await? {
        // This inode is known, might be a rename
        // Buffer it and wait for potential create
        buffer_for_rename_detection(path, inode, entry.id).await;
    } else {
        // Unknown inode, just a delete
        emit_remove_event(path).await;
    }
}