Multi-Instance Support

pub struct FileWatcher {
    tx: broadcast::Sender<ChangeEvent>,
    task_handle: Arc<TokioMutex<Option<tokio::task::JoinHandle<()>>>>,
    paused: Arc<AtomicBool>,
}

impl FileWatcher {
    /// Create a new file watcher with buffer size of 10
    pub fn new() -> Self {
        let (tx, _) = broadcast::channel(10);
        Self {
            tx,
            task_handle: Arc::new(TokioMutex::new(None)),
            paused: Arc::new(AtomicBool::new(false)),
        }
    }

    /// Pause file watching - events will be ignored until resumed
    pub fn pause(&self) {
        self.paused.store(true, Ordering::SeqCst);
    }

    /// Resume file watching - events will be processed normally
    pub fn resume(&self) {
        self.paused.store(false, Ordering::SeqCst);
    }
}

let is_relevant_event = matches!(
    event.kind,
    notify::EventKind::Modify(notify::event::ModifyKind::Data(
        notify::event::DataChange::Content,
    )) | notify::EventKind::Create(_)
       | notify::EventKind::Remove(_)
);

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FileMetadata {
    /// Last modified time of the file
    pub modified_time: SystemTime,
    /// File size in bytes for additional verification
    pub size: u64,
    /// Content hash for detecting changes even when timestamp/size are identical
    pub content_hash: u64,
}

impl FileMetadata {
    pub fn from_file(path: &Path) -> std::io::Result<Self> {
        let metadata = fs::metadata(path)?;
        let modified_time = metadata.modified()?;
        let size = metadata.len();

        // Compute content hash for comprehensive change detection
        let content = fs::read(path)?;
        let mut hasher = std::collections::hash_map::DefaultHasher::new();
        content.hash(&mut hasher);
        let content_hash = hasher.finish();

        Ok(Self { modified_time, size, content_hash })
    }

    pub fn has_changed(&self, path: &Path) -> std::io::Result<bool> {
        let current = Self::from_file(path)?;
        Ok(current != *self)
    }
}

async fn save(&self, snapshot: StoreSnapshot) -> KanbanResult<PersistenceMetadata> {
    // Check for external file modifications before saving
    if self.path.exists() {
        let current_metadata = FileMetadata::from_file(&self.path)?;

        // Compare with last known metadata
        let guard = self.lock_metadata();
        if let Some(last_known) = *guard {
            if last_known != current_metadata {
                return Err(KanbanError::ConflictDetected {
                    path: self.path.to_string_lossy().to_string(),
                    source: None,
                });
            }
        }
    }

    // Proceed with atomic write...
    AtomicWriter::write_atomic(&self.path, &json_bytes).await?;

    // Update last known metadata after successful write
    if let Ok(new_metadata) = FileMetadata::from_file(&self.path) {
        let mut guard = self.lock_metadata();
        *guard = Some(new_metadata);
    }

    Ok(snapshot.metadata)
}

pub struct JsonFileStore {
    path: PathBuf,
    instance_id: Uuid,  // Unique per instance
    last_known_metadata: Mutex<Option<FileMetadata>>,
}

impl JsonFileStore {
    pub fn new(path: impl AsRef<Path>) -> Self {
        Self {
            path: path.as_ref().to_path_buf(),
            instance_id: Uuid::new_v4(),  // Generated on creation
            last_known_metadata: Mutex::new(None),
        }
    }
}