diaryx_core 0.11.0

//! CRDT-updating filesystem decorator.
//!
//! This module provides [`CrdtFs`], a decorator that automatically updates the
//! workspace CRDT when filesystem operations occur. This ensures that local file
//! changes are automatically synchronized to the CRDT layer.
//!
//! # Doc-ID Bridge Layer
//!
//! CrdtFs bridges path-based filesystem operations to the doc-ID-based CRDT:
//!
//! ```text
//! Path Operation → CrdtFs → find_by_path() → doc_id → CRDT Update
//!                         ↘ or create_file() ↗
//! ```
//!
//! - For writes: Look up doc_id by path, or create new file with UUID if not found
//! - For renames: Just update the `filename` property (doc_id is stable!)
//! - For moves: Just update the `part_of` property (doc_id is stable!)
//! - For deletes: Mark the file as deleted (tombstone)
//!
//! # Architecture
//!
//! ```text
//! Local Write → CrdtFs.write_file() → Inner FS → Update WorkspaceCrdt
//!                                                       ↓
//!                                              WorkspaceCrdt.observe_updates()
//!                                                       ↓
//!                                              RustSyncBridge (syncs to server)
//! ```
//!
//! # Feature Gate
//!
//! This module requires the `crdt` feature to be enabled.

use std::collections::HashSet;
use std::io::Result;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, RwLock};

use crate::crdt::{BodyDocManager, FileMetadata, WorkspaceCrdt};
use crate::frontmatter;
use crate::fs::{AsyncFileSystem, BoxFuture};
use crate::link_parser;

/// A filesystem decorator that automatically updates the CRDT on file operations.
///
/// This decorator intercepts filesystem writes and updates the workspace CRDT
/// with file metadata extracted from frontmatter. It supports:
///
/// - Automatic CRDT updates on file write/create
/// - Soft deletion (tombstone) on file delete
/// - Path tracking on file move/rename
/// - Runtime enable/disable toggle
///
/// # Example
///
/// ```ignore
/// use diaryx_core::fs::{CrdtFs, InMemoryFileSystem, SyncToAsyncFs};
/// use diaryx_core::crdt::{WorkspaceCrdt, MemoryStorage};
/// use std::sync::Arc;
///
/// let inner_fs = SyncToAsyncFs::new(InMemoryFileSystem::new());
/// let storage = Arc::new(MemoryStorage::new());
/// let workspace_crdt = Arc::new(WorkspaceCrdt::new(storage.clone()));
/// let body_manager = Arc::new(BodyDocManager::new(storage));
///
/// let crdt_fs = CrdtFs::new(inner_fs, workspace_crdt, body_manager);
///
/// // All writes now automatically update the CRDT
/// crdt_fs.write_file(Path::new("test.md"), "---\ntitle: Test\n---\nContent").await?;
/// ```
pub struct CrdtFs<FS: AsyncFileSystem> {
    /// The underlying filesystem.
    inner: FS,
    /// The workspace CRDT for file metadata.
    workspace_crdt: Arc<WorkspaceCrdt>,
    /// Manager for per-file body documents.
    body_doc_manager: Arc<BodyDocManager>,
    /// Whether CRDT updates are enabled.
    enabled: AtomicBool,
    /// Paths currently being written locally (for loop prevention).
    local_writes_in_progress: RwLock<HashSet<PathBuf>>,
    /// Paths currently being written from sync (skip CRDT updates entirely).
    /// This prevents feedback loops where remote sync writes trigger new CRDT updates.
    sync_writes_in_progress: RwLock<HashSet<PathBuf>>,
}

impl<FS: AsyncFileSystem> CrdtFs<FS> {
    /// Create a new CRDT filesystem decorator.
    pub fn new(
        inner: FS,
        workspace_crdt: Arc<WorkspaceCrdt>,
        body_doc_manager: Arc<BodyDocManager>,
    ) -> Self {
        Self {
            inner,
            workspace_crdt,
            body_doc_manager,
            enabled: AtomicBool::new(true),
            local_writes_in_progress: RwLock::new(HashSet::new()),
            sync_writes_in_progress: RwLock::new(HashSet::new()),
        }
    }

    /// Normalize a path to a canonical form for CRDT storage.
    ///
    /// Strips leading "./" and "/" prefixes to ensure consistent keys
    /// across the CRDT. This matches how `InitializeWorkspaceCrdt` derives
    /// canonical paths from the workspace tree.
    fn normalize_crdt_path(path: &Path) -> String {
        let path_str = path.to_string_lossy();
        path_str
            .trim_start_matches("./")
            .trim_start_matches('/')
            .to_string()
    }

    /// Check if CRDT updates are enabled.
    pub fn is_enabled(&self) -> bool {
        self.enabled.load(Ordering::SeqCst)
    }

    /// Enable or disable CRDT updates.
    pub fn set_enabled(&self, enabled: bool) {
        self.enabled.store(enabled, Ordering::SeqCst);
    }

    /// Get a reference to the workspace CRDT.
    pub fn workspace_crdt(&self) -> &Arc<WorkspaceCrdt> {
        &self.workspace_crdt
    }

    /// Get a reference to the body document manager.
    pub fn body_doc_manager(&self) -> &Arc<BodyDocManager> {
        &self.body_doc_manager
    }

    /// Get a reference to the inner filesystem.
    pub fn inner(&self) -> &FS {
        &self.inner
    }

    /// Check if a path is currently being written locally.
    ///
    /// Used to prevent loops when CRDT observers trigger writes.
    pub fn is_local_write_in_progress(&self, path: &Path) -> bool {
        let writes = self.local_writes_in_progress.read().unwrap();
        writes.contains(&path.to_path_buf())
    }

    /// Mark a path as being written locally.
    fn mark_local_write_start(&self, path: &Path) {
        let mut writes = self.local_writes_in_progress.write().unwrap();
        writes.insert(path.to_path_buf());
    }

    /// Clear the local write marker for a path.
    fn mark_local_write_end(&self, path: &Path) {
        let mut writes = self.local_writes_in_progress.write().unwrap();
        writes.remove(&path.to_path_buf());
    }

    /// Check if a path is currently being written from sync.
    ///
    /// Sync writes should skip CRDT updates entirely to prevent feedback loops.
    pub fn is_sync_write_in_progress(&self, path: &Path) -> bool {
        let writes = self.sync_writes_in_progress.read().unwrap();
        writes.contains(&path.to_path_buf())
    }

    /// Mark a path as being written from sync (internal implementation).
    fn mark_sync_write_start_internal(&self, path: &Path) {
        let mut writes = self.sync_writes_in_progress.write().unwrap();
        writes.insert(path.to_path_buf());
        log::debug!(
            "CrdtFs: Marked sync write start for {:?} (total: {})",
            path,
            writes.len()
        );
    }

    /// Clear the sync write marker for a path (internal implementation).
    fn mark_sync_write_end_internal(&self, path: &Path) {
        let mut writes = self.sync_writes_in_progress.write().unwrap();
        writes.remove(&path.to_path_buf());
        log::debug!(
            "CrdtFs: Marked sync write end for {:?} (remaining: {})",
            path,
            writes.len()
        );
    }

    /// Extract FileMetadata from file content, including the filename.
    ///
    /// Parses frontmatter and converts known fields to FileMetadata.
    /// Paths in `part_of` and `contents` are converted to canonical
    /// (workspace-relative) paths for consistent CRDT storage.
    ///
    /// Supports multiple link formats:
    /// - Markdown links: `[Title](/path/file.md)` or `[Title](../file.md)`
    /// - Plain paths: `/path/file.md`, `../file.md`, `file.md`
    fn extract_metadata(&self, path: &Path, content: &str) -> FileMetadata {
        let mut metadata = match frontmatter::parse_or_empty(content) {
            Ok(parsed) => self.frontmatter_to_metadata(&parsed.frontmatter),
            Err(_) => FileMetadata::default(),
        };

        // Set the filename from the path
        metadata.filename = path
            .file_name()
            .and_then(|n| n.to_str())
            .unwrap_or("")
            .to_string();

        // Convert part_of to canonical path using link_parser
        // This handles markdown links, root paths, and relative paths
        if let Some(ref part_of) = metadata.part_of {
            let parsed = link_parser::parse_link(part_of);
            // Only resolve relative paths. If the path is already canonical
            // (WorkspaceRoot) or looks like a canonical path (contains '/' but
            // doesn't start with '.'), use it as-is to avoid path doubling.
            let canonical = if parsed.path_type == link_parser::PathType::WorkspaceRoot {
                parsed.path.clone()
            } else {
                link_parser::to_canonical(&parsed, path)
            };
            metadata.part_of = Some(canonical);
        }

        // Convert contents to canonical paths using link_parser
        if let Some(ref contents) = metadata.contents {
            metadata.contents = Some(
                contents
                    .iter()
                    .map(|link_str| {
                        let parsed = link_parser::parse_link(link_str);
                        // Only resolve relative paths. If the path is already canonical
                        // (WorkspaceRoot) or looks like a canonical path (contains '/' but
                        // doesn't start with '.'), use it as-is to avoid path doubling.
                        if parsed.path_type == link_parser::PathType::WorkspaceRoot {
                            parsed.path.clone()
                        } else {
                            link_parser::to_canonical(&parsed, path)
                        }
                    })
                    .collect(),
            );
        }

        metadata
    }

    /// Look up a doc_id by path, returning the path as the key for backward compatibility.
    ///
    /// This maintains backward compatibility with existing code that expects
    /// path-based CRDT keys. The doc-ID based system is used when:
    /// 1. The workspace has been migrated (needs_migration() returns false)
    /// 2. A file is explicitly created with create_file()
    ///
    /// For now, this returns the path as the key, which maintains compatibility
    /// with all existing tests and functionality. The migration to doc-IDs
    /// will be triggered explicitly via migrate_to_doc_ids().
    fn path_to_doc_id(&self, path: &Path, _metadata: &FileMetadata) -> Option<String> {
        // Normalize the path to a canonical form for CRDT storage
        let normalized = Self::normalize_crdt_path(path);

        // For backward compatibility, always use path as the key
        // The doc-ID based system is opt-in via explicit migration
        //
        // In the future, after migration:
        // 1. Try find_by_path() to get existing doc_id
        // 2. If not found, create_file() to generate new UUID
        //
        // But for now, maintain compatibility with existing code

        Some(normalized)
    }

    /// Convert frontmatter to FileMetadata.
    fn frontmatter_to_metadata(
        &self,
        fm: &indexmap::IndexMap<String, serde_yaml::Value>,
    ) -> FileMetadata {
        // Helper to parse the frontmatter "updated" value into a timestamp (ms)
        fn parse_updated_value(value: &serde_yaml::Value) -> Option<i64> {
            if let Some(num) = value.as_i64() {
                return Some(num);
            }

            if let Some(num) = value.as_f64() {
                return Some(num as i64);
            }

            if let Some(raw) = value.as_str() {
                // Try numeric string first
                if let Ok(num) = raw.parse::<i64>() {
                    return Some(num);
                }

                // Try RFC3339/ISO8601 timestamp
                if let Ok(parsed) = chrono::DateTime::parse_from_rfc3339(raw) {
                    return Some(parsed.timestamp_millis());
                }
            }

            None
        }

        // Try to convert via JSON for automatic field mapping
        if let Ok(json_value) = serde_json::to_value(fm)
            && let Ok(metadata) = serde_json::from_value::<FileMetadata>(json_value)
        {
            let mut metadata = metadata;

            if let Some(updated) = fm.get("updated").and_then(parse_updated_value) {
                metadata.modified_at = updated;
            }

            // Only default to "now" if modified_at is missing/zero
            if metadata.modified_at == 0 {
                metadata.modified_at = chrono::Utc::now().timestamp_millis();
            }

            return metadata;
        }

        // Fallback: manual extraction of known fields
        let mut metadata = FileMetadata::default();

        if let Some(title) = fm.get("title") {
            metadata.title = title.as_str().map(String::from);
        }
        if let Some(part_of) = fm.get("part_of") {
            metadata.part_of = part_of.as_str().map(String::from);
        }
        if let Some(contents) = fm.get("contents")
            && let Some(seq) = contents.as_sequence()
        {
            metadata.contents = Some(
                seq.iter()
                    .filter_map(|v| v.as_str().map(String::from))
                    .collect(),
            );
        }
        if let Some(audience) = fm.get("audience")
            && let Some(seq) = audience.as_sequence()
        {
            metadata.audience = Some(
                seq.iter()
                    .filter_map(|v| v.as_str().map(String::from))
                    .collect(),
            );
        }
        if let Some(description) = fm.get("description") {
            metadata.description = description.as_str().map(String::from);
        }

        // Store remaining fields in extra
        let known_fields = [
            "title",
            "part_of",
            "contents",
            "audience",
            "description",
            "attachments",
            "deleted",
            "modified_at",
            "updated",
        ];
        for (key, value) in fm {
            if !known_fields.contains(&key.as_str())
                && let Ok(json_value) = serde_json::to_value(value)
            {
                metadata.extra.insert(key.clone(), json_value);
            }
        }

        if let Some(updated) = fm.get("updated").and_then(parse_updated_value) {
            metadata.modified_at = updated;
        } else if metadata.modified_at == 0 {
            metadata.modified_at = chrono::Utc::now().timestamp_millis();
        }
        metadata
    }

    /// Update CRDT with metadata from a file.
    ///
    /// This is skipped if:
    /// - CRDT updates are disabled globally
    /// - The path is marked as a sync write (to prevent feedback loops)
    fn update_crdt_for_file(&self, path: &Path, content: &str) {
        self.update_crdt_for_file_internal(path, content, false);
    }

    /// Update CRDT for a newly created file.
    ///
    /// This clears any stale state from storage before creating the body doc,
    /// preventing concatenation with old content from deleted files.
    fn update_crdt_for_new_file(&self, path: &Path, content: &str) {
        self.update_crdt_for_file_internal(path, content, true);
    }

    /// Internal implementation for CRDT updates.
    ///
    /// If `is_new_file` is true, any existing body doc storage is deleted first
    /// to prevent stale state from being merged with new content.
    fn update_crdt_for_file_internal(&self, path: &Path, content: &str, is_new_file: bool) {
        if !self.is_enabled() {
            return;
        }

        // Skip CRDT update if this is a sync write (prevents feedback loops)
        if self.is_sync_write_in_progress(path) {
            log::debug!("CrdtFs: Skipping CRDT update for sync write: {:?}", path);
            return;
        }

        let path_str = path.to_string_lossy().to_string();

        // Skip temporary files created by the metadata writer's safe write process
        // These files should never be synced to the server
        if path_str.ends_with(".tmp") || path_str.ends_with(".bak") || path_str.ends_with(".swap") {
            log::debug!(
                "CrdtFs: Skipping CRDT update for temporary file: {}",
                path_str
            );
            return;
        }
        let body = frontmatter::extract_body(content);
        log::trace!(
            "[CrdtFs] update_crdt_for_file_internal: path_str='{}', is_new_file={}, body_preview='{}'",
            path_str,
            is_new_file,
            body.chars().take(50).collect::<String>()
        );
        let metadata = self.extract_metadata(path, content);

        // Get or create doc_id for this path
        // In doc-ID mode, this finds existing doc_id or creates new UUID
        // In legacy mode, this just returns the path as the key
        let doc_key = self
            .path_to_doc_id(path, &metadata)
            .unwrap_or(path_str.clone());

        // Update workspace CRDT with the doc_key (doc_id or path)
        log::trace!("[CrdtFs] BEFORE set_file: doc_key={}", doc_key);
        if let Err(e) = self.workspace_crdt.set_file(&doc_key, metadata.clone()) {
            log::warn!("[CrdtFs] set_file FAILED: {}: {}", doc_key, e);
        } else {
            log::trace!("[CrdtFs] set_file SUCCESS: {}", doc_key);
            // Verify write by reading back (debug only)
            let verify = self.workspace_crdt.get_file(&doc_key);
            log::trace!(
                "[CrdtFs] set_file VERIFY: {} -> {:?}",
                doc_key,
                verify.is_some()
            );
        }

        // Update body doc using the same key
        let body = frontmatter::extract_body(content);

        // For new files, delete any stale storage and create a fresh doc
        // to prevent concatenation with old content from deleted files
        let body_doc = if is_new_file {
            // Delete stale storage first, then create fresh doc
            let _ = self.body_doc_manager.delete(&doc_key);
            self.body_doc_manager.create(&doc_key)
        } else {
            self.body_doc_manager.get_or_create(&doc_key)
        };

        let _ = body_doc.set_body(body);
    }

    /// Update parent's contents array when a child is moved or deleted.
    ///
    /// For rename/move: `new_path` is Some with the new path.
    /// For delete: `new_path` is None.
    fn update_parent_contents(&self, old_path: &str, new_path: Option<&str>) {
        if !self.is_enabled() {
            return;
        }

        let old_metadata = match self.workspace_crdt.get_file(old_path) {
            Some(m) => m,
            None => return,
        };

        if let Some(ref parent_path) = old_metadata.part_of
            && let Some(mut parent) = self.workspace_crdt.get_file(parent_path)
            && let Some(ref mut contents) = parent.contents
        {
            // Find old filename in contents
            let old_filename = std::path::Path::new(old_path)
                .file_name()
                .and_then(|n| n.to_str())
                .unwrap_or(old_path);

            if let Some(idx) = contents
                .iter()
                .position(|e| e == old_filename || e == old_path)
            {
                match new_path {
                    Some(np) => {
                        // Rename: replace with new filename
                        let new_filename = std::path::Path::new(np)
                            .file_name()
                            .and_then(|n| n.to_str())
                            .unwrap_or(np);
                        contents[idx] = new_filename.to_string();
                    }
                    None => {
                        // Delete: remove from contents
                        contents.remove(idx);
                    }
                }
                parent.modified_at = chrono::Utc::now().timestamp_millis();
                let _ = self.workspace_crdt.set_file(parent_path, parent);
            }
        }
    }
}

// Implement Clone if the inner FS is Clone
impl<FS: AsyncFileSystem + Clone> Clone for CrdtFs<FS> {
    fn clone(&self) -> Self {
        Self {
            inner: self.inner.clone(),
            workspace_crdt: Arc::clone(&self.workspace_crdt),
            body_doc_manager: Arc::clone(&self.body_doc_manager),
            enabled: AtomicBool::new(self.enabled.load(Ordering::SeqCst)),
            local_writes_in_progress: RwLock::new(HashSet::new()),
            sync_writes_in_progress: RwLock::new(HashSet::new()),
        }
    }
}

// AsyncFileSystem implementation - delegates to inner with CRDT updates
#[cfg(not(target_arch = "wasm32"))]
impl<FS: AsyncFileSystem + Send + Sync> AsyncFileSystem for CrdtFs<FS> {
    fn read_to_string<'a>(&'a self, path: &'a Path) -> BoxFuture<'a, Result<String>> {
        self.inner.read_to_string(path)
    }

    fn write_file<'a>(&'a self, path: &'a Path, content: &'a str) -> BoxFuture<'a, Result<()>> {
        Box::pin(async move {
            // Mark local write in progress
            self.mark_local_write_start(path);

            // Write to inner filesystem
            let result = self.inner.write_file(path, content).await;

            // Update CRDT if write succeeded and enabled
            if result.is_ok() {
                self.update_crdt_for_file(path, content);
            }

            // Clear local write marker
            self.mark_local_write_end(path);

            result
        })
    }

    fn create_new<'a>(&'a self, path: &'a Path, content: &'a str) -> BoxFuture<'a, Result<()>> {
        Box::pin(async move {
            log::info!(
                "[CrdtFs] create_new CALLED: path='{}', enabled={}, content_len={}",
                path.display(),
                self.is_enabled(),
                content.len()
            );

            // Mark local write in progress
            self.mark_local_write_start(path);

            // Create in inner filesystem
            let result = self.inner.create_new(path, content).await;

            log::info!(
                "[CrdtFs] create_new RESULT: path='{}', success={}, err={:?}",
                path.display(),
                result.is_ok(),
                result.as_ref().err()
            );

            // Update CRDT if creation succeeded and enabled
            // Use new file variant to clear any stale state from storage
            if result.is_ok() {
                log::info!(
                    "[CrdtFs] create_new calling update_crdt_for_new_file: path='{}'",
                    path.display()
                );
                self.update_crdt_for_new_file(path, content);
            }

            // Clear local write marker
            self.mark_local_write_end(path);

            result
        })
    }

    fn delete_file<'a>(&'a self, path: &'a Path) -> BoxFuture<'a, Result<()>> {
        Box::pin(async move {
            // Mark local write in progress
            self.mark_local_write_start(path);

            // Delete from inner filesystem
            let result = self.inner.delete_file(path).await;

            // Mark as deleted in CRDT if deletion succeeded and enabled
            if result.is_ok() && self.is_enabled() {
                let path_str = Self::normalize_crdt_path(path);

                // Update parent's contents to remove the deleted file
                self.update_parent_contents(&path_str, None);

                if let Err(e) = self.workspace_crdt.delete_file(&path_str) {
                    log::warn!(
                        "Failed to mark file as deleted in CRDT for {}: {}",
                        path_str,
                        e
                    );
                }
            }

            // Clear local write marker
            self.mark_local_write_end(path);

            result
        })
    }

    fn list_md_files<'a>(&'a self, dir: &'a Path) -> BoxFuture<'a, Result<Vec<PathBuf>>> {
        self.inner.list_md_files(dir)
    }

    fn exists<'a>(&'a self, path: &'a Path) -> BoxFuture<'a, bool> {
        self.inner.exists(path)
    }

    fn create_dir_all<'a>(&'a self, path: &'a Path) -> BoxFuture<'a, Result<()>> {
        self.inner.create_dir_all(path)
    }

    fn is_dir<'a>(&'a self, path: &'a Path) -> BoxFuture<'a, bool> {
        self.inner.is_dir(path)
    }

    fn move_file<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<()>> {
        Box::pin(async move {
            // Mark both paths as local writes in progress
            self.mark_local_write_start(from);
            self.mark_local_write_start(to);

            // Perform the physical move
            let result = self.inner.move_file(from, to).await;

            // Update CRDT if move succeeded
            if result.is_ok() && self.is_enabled() {
                let from_str = Self::normalize_crdt_path(from);
                let to_str = Self::normalize_crdt_path(to);

                // Find the doc_id for the file being moved
                if let Some(doc_id) = self.workspace_crdt.find_by_path(from) {
                    let new_filename = to
                        .file_name()
                        .and_then(|n| n.to_str())
                        .unwrap_or("")
                        .to_string();

                    // Detect rename (same directory) vs move (different directory)
                    let from_parent = from.parent();
                    let to_parent = to.parent();
                    let is_rename = from_parent == to_parent;

                    if is_rename {
                        // Rename: Just update the filename property - doc_id stays stable
                        log::debug!(
                            "CrdtFs: Renaming doc_id={} from {:?} to {}",
                            doc_id,
                            from,
                            new_filename
                        );
                        if let Err(e) = self.workspace_crdt.rename_file(&doc_id, &new_filename) {
                            log::warn!("Failed to rename file in CRDT: {}", e);
                        }
                    } else {
                        // Move: Update the parent reference - doc_id stays stable
                        // Find the new parent's doc_id
                        let new_parent_id =
                            to_parent.and_then(|p| self.workspace_crdt.find_by_path(p));

                        log::debug!(
                            "CrdtFs: Moving doc_id={} to parent={:?}, new_filename={}",
                            doc_id,
                            new_parent_id,
                            new_filename
                        );

                        // Update parent reference
                        if let Err(e) = self
                            .workspace_crdt
                            .move_file(&doc_id, new_parent_id.as_deref())
                        {
                            log::warn!("Failed to move file in CRDT: {}", e);
                        }

                        // Also update filename if it changed
                        if let Some(meta) = self.workspace_crdt.get_file(&doc_id)
                            && meta.filename != new_filename
                            && let Err(e) = self.workspace_crdt.rename_file(&doc_id, &new_filename)
                        {
                            log::warn!("Failed to rename file during move in CRDT: {}", e);
                        }
                    }

                    // Update parent's contents list (replace old path with new path)
                    self.update_parent_contents(&from_str, Some(&to_str));
                } else {
                    // Fallback for legacy path-based entries: use old delete+create behavior
                    log::debug!(
                        "CrdtFs: No doc_id found for {:?}, using legacy move behavior",
                        from
                    );
                    self.update_parent_contents(&from_str, Some(&to_str));

                    if let Err(e) = self.workspace_crdt.delete_file(&from_str) {
                        log::warn!("Failed to mark old path as deleted in CRDT: {}", e);
                    }

                    if let Ok(content) = self.inner.read_to_string(to).await {
                        self.update_crdt_for_file(to, &content);
                    }
                }
            }

            // Clear local write markers
            self.mark_local_write_end(from);
            self.mark_local_write_end(to);

            result
        })
    }

    fn read_binary<'a>(&'a self, path: &'a Path) -> BoxFuture<'a, Result<Vec<u8>>> {
        self.inner.read_binary(path)
    }

    fn write_binary<'a>(&'a self, path: &'a Path, content: &'a [u8]) -> BoxFuture<'a, Result<()>> {
        // Binary files are not tracked in the CRDT (they're attachments)
        self.inner.write_binary(path, content)
    }

    fn list_files<'a>(&'a self, dir: &'a Path) -> BoxFuture<'a, Result<Vec<PathBuf>>> {
        self.inner.list_files(dir)
    }

    fn get_modified_time<'a>(&'a self, path: &'a Path) -> BoxFuture<'a, Option<i64>> {
        self.inner.get_modified_time(path)
    }

    // Override sync write markers to track which paths are being written from sync
    fn mark_sync_write_start(&self, path: &Path) {
        self.mark_sync_write_start_internal(path);
    }

    fn mark_sync_write_end(&self, path: &Path) {
        self.mark_sync_write_end_internal(path);
    }
}

// WASM implementation (without Send + Sync bounds)
#[cfg(target_arch = "wasm32")]
impl<FS: AsyncFileSystem> AsyncFileSystem for CrdtFs<FS> {
    fn read_to_string<'a>(&'a self, path: &'a Path) -> BoxFuture<'a, Result<String>> {
        self.inner.read_to_string(path)
    }

    fn write_file<'a>(&'a self, path: &'a Path, content: &'a str) -> BoxFuture<'a, Result<()>> {
        Box::pin(async move {
            // Mark local write in progress
            self.mark_local_write_start(path);

            // Write to inner filesystem
            let result = self.inner.write_file(path, content).await;

            // Update CRDT if write succeeded and enabled
            if result.is_ok() {
                self.update_crdt_for_file(path, content);
            }

            // Clear local write marker
            self.mark_local_write_end(path);

            result
        })
    }

    fn create_new<'a>(&'a self, path: &'a Path, content: &'a str) -> BoxFuture<'a, Result<()>> {
        Box::pin(async move {
            log::info!(
                "[CrdtFs] create_new CALLED: path='{}', enabled={}, content_len={}",
                path.display(),
                self.is_enabled(),
                content.len()
            );

            // Mark local write in progress
            self.mark_local_write_start(path);

            // Create in inner filesystem
            let result = self.inner.create_new(path, content).await;

            log::info!(
                "[CrdtFs] create_new RESULT: path='{}', success={}, err={:?}",
                path.display(),
                result.is_ok(),
                result.as_ref().err()
            );

            // Update CRDT if creation succeeded and enabled
            // Use new file variant to clear any stale state from storage
            if result.is_ok() {
                log::info!(
                    "[CrdtFs] create_new calling update_crdt_for_new_file: path='{}'",
                    path.display()
                );
                self.update_crdt_for_new_file(path, content);
            }

            // Clear local write marker
            self.mark_local_write_end(path);

            result
        })
    }

    fn delete_file<'a>(&'a self, path: &'a Path) -> BoxFuture<'a, Result<()>> {
        Box::pin(async move {
            // Mark local write in progress
            self.mark_local_write_start(path);

            // Delete from inner filesystem
            let result = self.inner.delete_file(path).await;

            // Mark as deleted in CRDT if deletion succeeded and enabled
            if result.is_ok() && self.is_enabled() {
                let path_str = Self::normalize_crdt_path(path);

                // Update parent's contents to remove the deleted file
                self.update_parent_contents(&path_str, None);

                if let Err(e) = self.workspace_crdt.delete_file(&path_str) {
                    log::warn!(
                        "Failed to mark file as deleted in CRDT for {}: {}",
                        path_str,
                        e
                    );
                }
            }

            // Clear local write marker
            self.mark_local_write_end(path);

            result
        })
    }

    fn list_md_files<'a>(&'a self, dir: &'a Path) -> BoxFuture<'a, Result<Vec<PathBuf>>> {
        self.inner.list_md_files(dir)
    }

    fn exists<'a>(&'a self, path: &'a Path) -> BoxFuture<'a, bool> {
        self.inner.exists(path)
    }

    fn create_dir_all<'a>(&'a self, path: &'a Path) -> BoxFuture<'a, Result<()>> {
        self.inner.create_dir_all(path)
    }

    fn is_dir<'a>(&'a self, path: &'a Path) -> BoxFuture<'a, bool> {
        self.inner.is_dir(path)
    }

    fn move_file<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<()>> {
        Box::pin(async move {
            // Mark both paths as local writes in progress
            self.mark_local_write_start(from);
            self.mark_local_write_start(to);

            // Perform the physical move
            let result = self.inner.move_file(from, to).await;

            // Update CRDT if move succeeded
            if result.is_ok() && self.is_enabled() {
                let from_str = Self::normalize_crdt_path(from);
                let to_str = Self::normalize_crdt_path(to);

                // Find the doc_id for the file being moved
                if let Some(doc_id) = self.workspace_crdt.find_by_path(from) {
                    let new_filename = to
                        .file_name()
                        .and_then(|n| n.to_str())
                        .unwrap_or("")
                        .to_string();

                    // Detect rename (same directory) vs move (different directory)
                    let from_parent = from.parent();
                    let to_parent = to.parent();
                    let is_rename = from_parent == to_parent;

                    if is_rename {
                        // Rename: Just update the filename property - doc_id stays stable
                        log::debug!(
                            "CrdtFs: Renaming doc_id={} from {:?} to {}",
                            doc_id,
                            from,
                            new_filename
                        );
                        if let Err(e) = self.workspace_crdt.rename_file(&doc_id, &new_filename) {
                            log::warn!("Failed to rename file in CRDT: {}", e);
                        }
                    } else {
                        // Move: Update the parent reference - doc_id stays stable
                        // Find the new parent's doc_id
                        let new_parent_id =
                            to_parent.and_then(|p| self.workspace_crdt.find_by_path(p));

                        log::debug!(
                            "CrdtFs: Moving doc_id={} to parent={:?}, new_filename={}",
                            doc_id,
                            new_parent_id,
                            new_filename
                        );

                        // Update parent reference
                        if let Err(e) = self
                            .workspace_crdt
                            .move_file(&doc_id, new_parent_id.as_deref())
                        {
                            log::warn!("Failed to move file in CRDT: {}", e);
                        }

                        // Also update filename if it changed
                        if let Some(meta) = self.workspace_crdt.get_file(&doc_id) {
                            if meta.filename != new_filename {
                                if let Err(e) =
                                    self.workspace_crdt.rename_file(&doc_id, &new_filename)
                                {
                                    log::warn!("Failed to rename file during move in CRDT: {}", e);
                                }
                            }
                        }
                    }

                    // Update parent's contents list (replace old path with new path)
                    self.update_parent_contents(&from_str, Some(&to_str));
                } else {
                    // Fallback for legacy path-based entries: use old delete+create behavior
                    log::debug!(
                        "CrdtFs: No doc_id found for {:?}, using legacy move behavior",
                        from
                    );
                    self.update_parent_contents(&from_str, Some(&to_str));

                    if let Err(e) = self.workspace_crdt.delete_file(&from_str) {
                        log::warn!("Failed to mark old path as deleted in CRDT: {}", e);
                    }

                    if let Ok(content) = self.inner.read_to_string(to).await {
                        self.update_crdt_for_file(to, &content);
                    }
                }
            }

            // Clear local write markers
            self.mark_local_write_end(from);
            self.mark_local_write_end(to);

            result
        })
    }

    fn read_binary<'a>(&'a self, path: &'a Path) -> BoxFuture<'a, Result<Vec<u8>>> {
        self.inner.read_binary(path)
    }

    fn write_binary<'a>(&'a self, path: &'a Path, content: &'a [u8]) -> BoxFuture<'a, Result<()>> {
        // Binary files are not tracked in the CRDT (they're attachments)
        self.inner.write_binary(path, content)
    }

    fn list_files<'a>(&'a self, dir: &'a Path) -> BoxFuture<'a, Result<Vec<PathBuf>>> {
        self.inner.list_files(dir)
    }

    fn get_modified_time<'a>(&'a self, path: &'a Path) -> BoxFuture<'a, Option<i64>> {
        self.inner.get_modified_time(path)
    }

    // Override sync write markers to track which paths are being written from sync
    fn mark_sync_write_start(&self, path: &Path) {
        self.mark_sync_write_start_internal(path);
    }

    fn mark_sync_write_end(&self, path: &Path) {
        self.mark_sync_write_end_internal(path);
    }
}

impl<FS: AsyncFileSystem> std::fmt::Debug for CrdtFs<FS> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("CrdtFs")
            .field("enabled", &self.is_enabled())
            .field("workspace_crdt", &self.workspace_crdt)
            .field("body_doc_manager", &self.body_doc_manager)
            .finish()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::crdt::{CrdtStorage, MemoryStorage};
    use crate::fs::{InMemoryFileSystem, SyncToAsyncFs};

    fn create_test_crdt_fs() -> CrdtFs<SyncToAsyncFs<InMemoryFileSystem>> {
        let inner = SyncToAsyncFs::new(InMemoryFileSystem::new());
        let storage: Arc<dyn CrdtStorage> = Arc::new(MemoryStorage::new());
        let workspace_crdt = Arc::new(WorkspaceCrdt::new(Arc::clone(&storage)));
        let body_manager = Arc::new(BodyDocManager::new(storage));
        CrdtFs::new(inner, workspace_crdt, body_manager)
    }

    #[test]
    fn test_write_updates_crdt() {
        let fs = create_test_crdt_fs();
        let content = "---\ntitle: Test\npart_of: index.md\n---\nBody content";

        futures_lite::future::block_on(async {
            fs.write_file(Path::new("test.md"), content).await.unwrap();
        });

        // Check CRDT was updated
        let metadata = fs.workspace_crdt.get_file("test.md").unwrap();
        assert_eq!(metadata.title, Some("Test".to_string()));
        assert_eq!(metadata.part_of, Some("index.md".to_string()));
    }

    #[test]
    fn test_delete_marks_deleted_in_crdt() {
        let fs = create_test_crdt_fs();
        let content = "---\ntitle: Test\n---\nBody";

        futures_lite::future::block_on(async {
            fs.write_file(Path::new("test.md"), content).await.unwrap();
            fs.delete_file(Path::new("test.md")).await.unwrap();
        });

        // Check file is marked as deleted in CRDT
        let metadata = fs.workspace_crdt.get_file("test.md").unwrap();
        assert!(metadata.deleted);
    }

    #[test]
    fn test_disabled_skips_crdt_updates() {
        let fs = create_test_crdt_fs();
        fs.set_enabled(false);

        let content = "---\ntitle: Test\n---\nBody";

        futures_lite::future::block_on(async {
            fs.write_file(Path::new("test.md"), content).await.unwrap();
        });

        // CRDT should not have the file
        assert!(fs.workspace_crdt.get_file("test.md").is_none());
    }

    #[test]
    fn test_toggle_enabled() {
        let fs = create_test_crdt_fs();

        assert!(fs.is_enabled());
        fs.set_enabled(false);
        assert!(!fs.is_enabled());
        fs.set_enabled(true);
        assert!(fs.is_enabled());
    }

    #[test]
    fn test_local_write_tracking() {
        let fs = create_test_crdt_fs();

        assert!(!fs.is_local_write_in_progress(Path::new("test.md")));

        fs.mark_local_write_start(Path::new("test.md"));
        assert!(fs.is_local_write_in_progress(Path::new("test.md")));

        fs.mark_local_write_end(Path::new("test.md"));
        assert!(!fs.is_local_write_in_progress(Path::new("test.md")));
    }

    #[test]
    fn test_sync_write_tracking() {
        let fs = create_test_crdt_fs();

        assert!(!fs.is_sync_write_in_progress(Path::new("test.md")));

        fs.mark_sync_write_start(Path::new("test.md"));
        assert!(fs.is_sync_write_in_progress(Path::new("test.md")));

        fs.mark_sync_write_end(Path::new("test.md"));
        assert!(!fs.is_sync_write_in_progress(Path::new("test.md")));
    }

    #[test]
    fn test_sync_write_skips_crdt_update() {
        let fs = create_test_crdt_fs();
        let content = "---\ntitle: Sync Write Test\n---\nBody content";

        // First, write without sync marker - should update CRDT
        futures_lite::future::block_on(async {
            fs.write_file(Path::new("test1.md"), content).await.unwrap();
        });
        assert!(fs.workspace_crdt.get_file("test1.md").is_some());

        // Now, mark sync write and write - should NOT update CRDT
        fs.mark_sync_write_start(Path::new("test2.md"));
        futures_lite::future::block_on(async {
            fs.write_file(Path::new("test2.md"), content).await.unwrap();
        });
        fs.mark_sync_write_end(Path::new("test2.md"));

        // File should exist on disk but NOT in CRDT
        assert!(futures_lite::future::block_on(
            fs.exists(Path::new("test2.md"))
        ));
        assert!(
            fs.workspace_crdt.get_file("test2.md").is_none(),
            "CRDT should not have been updated for sync write"
        );
    }

    // =========================================================================
    // Link Parser Integration Tests
    // =========================================================================

    #[test]
    fn test_markdown_link_part_of_converts_to_canonical() {
        let fs = create_test_crdt_fs();
        // Write a file with markdown link in part_of
        let content =
            "---\ntitle: Child\npart_of: \"[Parent Index](/Folder/parent.md)\"\n---\nContent";

        futures_lite::future::block_on(async {
            fs.write_file(Path::new("Folder/child.md"), content)
                .await
                .unwrap();
        });

        // Check CRDT stores canonical path (without leading /)
        let metadata = fs.workspace_crdt.get_file("Folder/child.md").unwrap();
        assert_eq!(metadata.part_of, Some("Folder/parent.md".to_string()));
    }

    #[test]
    fn test_relative_part_of_converts_to_canonical() {
        let fs = create_test_crdt_fs();
        // Write a file with relative path in part_of
        let content = "---\ntitle: Child\npart_of: ../index.md\n---\nContent";

        futures_lite::future::block_on(async {
            fs.write_file(Path::new("Folder/Sub/child.md"), content)
                .await
                .unwrap();
        });

        // Check CRDT stores canonical path
        let metadata = fs.workspace_crdt.get_file("Folder/Sub/child.md").unwrap();
        assert_eq!(metadata.part_of, Some("Folder/index.md".to_string()));
    }

    #[test]
    fn test_plain_part_of_at_root_stays_canonical() {
        let fs = create_test_crdt_fs();
        // Write a file at root with plain filename part_of
        let content = "---\ntitle: Child\npart_of: index.md\n---\nContent";

        futures_lite::future::block_on(async {
            fs.write_file(Path::new("child.md"), content).await.unwrap();
        });

        // Check CRDT stores canonical path
        let metadata = fs.workspace_crdt.get_file("child.md").unwrap();
        assert_eq!(metadata.part_of, Some("index.md".to_string()));
    }

    #[test]
    fn test_markdown_link_contents_converts_to_canonical() {
        let fs = create_test_crdt_fs();
        // Write a file with markdown links in contents
        let content = r#"---
title: Parent Index
contents:
  - "[Child 1](/Folder/child1.md)"
  - "[Child 2](/Folder/Sub/child2.md)"
---
Content"#;

        futures_lite::future::block_on(async {
            fs.write_file(Path::new("Folder/index.md"), content)
                .await
                .unwrap();
        });

        // Check CRDT stores canonical paths (without leading /)
        let metadata = fs.workspace_crdt.get_file("Folder/index.md").unwrap();
        assert_eq!(
            metadata.contents,
            Some(vec![
                "Folder/child1.md".to_string(),
                "Folder/Sub/child2.md".to_string()
            ])
        );
    }

    #[test]
    fn test_relative_contents_converts_to_canonical() {
        let fs = create_test_crdt_fs();
        // Write a file with relative paths in contents
        let content = r#"---
title: Parent Index
contents:
  - child1.md
  - Sub/child2.md
---
Content"#;

        futures_lite::future::block_on(async {
            fs.write_file(Path::new("Folder/index.md"), content)
                .await
                .unwrap();
        });

        // Check CRDT stores canonical paths
        let metadata = fs.workspace_crdt.get_file("Folder/index.md").unwrap();
        assert_eq!(
            metadata.contents,
            Some(vec![
                "Folder/child1.md".to_string(),
                "Folder/Sub/child2.md".to_string()
            ])
        );
    }

    #[test]
    fn test_mixed_format_links_all_convert_to_canonical() {
        let fs = create_test_crdt_fs();
        // Write a file with mixed link formats
        let content = r#"---
title: Parent Index
part_of: "[Root](/README.md)"
contents:
  - child1.md
  - "[Child 2](/Folder/Sub/child2.md)"
  - ../sibling.md
---
Content"#;

        futures_lite::future::block_on(async {
            fs.write_file(Path::new("Folder/index.md"), content)
                .await
                .unwrap();
        });

        // Check CRDT stores all paths as canonical
        let metadata = fs.workspace_crdt.get_file("Folder/index.md").unwrap();
        assert_eq!(metadata.part_of, Some("README.md".to_string()));
        assert_eq!(
            metadata.contents,
            Some(vec![
                "Folder/child1.md".to_string(),
                "Folder/Sub/child2.md".to_string(),
                "sibling.md".to_string(),
            ])
        );
    }
}