use std::path::PathBuf;
use tempfile::TempDir;

#[cfg(test)]
mod config_tests {
    use super::*;
    use crate::config::{Config, Dotfile};
    use crate::cli::SyncBackend;

    #[test]
    fn test_config_default() {
        let config = Config::default();
        assert_eq!(config.version, "1.0");
        assert_eq!(config.sync.branch, "main");
        assert!(config.dotfiles.is_empty());
    }

    #[test]
    fn test_config_serialization() {
        let config = Config::default();
        let serialized = serde_yaml::to_string(&config).unwrap();
        let deserialized: Config = serde_yaml::from_str(&serialized).unwrap();
        assert_eq!(config.version, deserialized.version);
    }

    #[test]
    fn test_dotfile_serialization() {
        let dotfile = Dotfile {
            path: PathBuf::from("/home/user/.vimrc"),
            content_hash: Some("abc123".to_string()),
            permissions: Some(0o644),
            platform: Some("linux".to_string()),
            template: Some(false),
            excludes: Vec::new(),
        };

        let serialized = serde_yaml::to_string(&dotfile).unwrap();
        let deserialized: Dotfile = serde_yaml::from_str(&serialized).unwrap();
        assert_eq!(dotfile.path, deserialized.path);
        assert_eq!(dotfile.content_hash, deserialized.content_hash);
    }

    #[test]
    fn test_config_default_for_backend() {
        let git_config = Config::default_for_backend(SyncBackend::Git);
        assert_eq!(git_config.sync.backend, Some(SyncBackend::Git));

        let s3_config = Config::default_for_backend(SyncBackend::S3);
        assert_eq!(s3_config.sync.backend, Some(SyncBackend::S3));
    }
}

#[cfg(test)]
mod merge_tests {
    use super::*;
    use crate::merge::Merger;

    #[test]
    fn test_diff_identical_files() {
        let merger = Merger::new();
        let a = "line1\nline2\nline3";
        let b = "line1\nline2\nline3";
        let diff = merger.diff(&PathBuf::from("a"), &PathBuf::from("b")).unwrap();
        assert!(diff.iter().all(|l| l.starts_with("  ")));
    }

    #[test]
    fn test_diff_different_files() {
        let merger = Merger::new();
        let a = "line1\nline2\nline3";
        let b = "line1\nmodified\nline3";
        let diff = merger.diff(&PathBuf::from("a"), &PathBuf::from("b")).unwrap();
        assert!(diff.iter().any(|l| l.starts_with("- ")));
        assert!(diff.iter().any(|l| l.starts_with("+ ")));
    }
}

#[cfg(test)]
mod detection_tests {
    use super::*;
    use crate::detect::Detector;
    use crate::config::Config;

    #[test]
    fn test_platform_detection() {
        use crate::cli::Platform;
        let platform = Platform::current();
        match platform {
            Platform::Linux | Platform::Macos | Platform::Wsl => {}
        }
    }

    #[test]
    fn test_detector_new() {
        let config = Config::default();
        let detector = Detector::new(&config);
        assert!(!detector.home_dir.as_os_str().is_empty());
    }
}

#[cfg(test)]
mod backup_tests {
    use super::*;
    use crate::backup::BackupManager;

    #[test]
    fn test_backup_manager_new() {
        let temp_dir = TempDir::new().unwrap();
        let backup_dir = temp_dir.path().to_path_buf();
        let manager = BackupManager::new(&backup_dir);
        assert!(backup_dir.exists());
    }
}