ryo-source 0.1.0

//! Multi-file generator.
//!
//! Generates code into multiple files following Rust module conventions.
//! Supports both modern (`module.rs` + `module/`) and legacy (`module/mod.rs`) styles.

use super::{GeneratedSource, ModuleTree};
use crate::pure::{PureFile, PureItem, PureMod};
use std::collections::HashMap;
use std::path::{Path, PathBuf};

/// Result of multi-file generation.
#[derive(Debug, Clone, Default)]
pub struct GeneratedFiles {
    /// Map of relative file paths to generated source.
    pub files: HashMap<PathBuf, GeneratedSource>,
}

impl GeneratedFiles {
    /// Create empty GeneratedFiles.
    pub fn new() -> Self {
        Self::default()
    }

    /// Get all file paths.
    pub fn paths(&self) -> impl Iterator<Item = &PathBuf> {
        self.files.keys()
    }

    /// Get a specific file.
    pub fn get(&self, path: &Path) -> Option<&GeneratedSource> {
        self.files.get(path)
    }

    /// Get number of files.
    pub fn len(&self) -> usize {
        self.files.len()
    }

    /// Check if empty.
    pub fn is_empty(&self) -> bool {
        self.files.is_empty()
    }

    /// Compute diff against existing PureFiles.
    ///
    /// Returns only the files that have changed (or are new).
    /// Comparison is done on PureFile structure, not source text,
    /// so formatting differences are ignored.
    pub fn diff(&self, existing: &HashMap<PathBuf, PureFile>) -> GeneratedFiles {
        let mut changed = GeneratedFiles::new();

        for (path, generated) in &self.files {
            let is_changed = match existing.get(path) {
                None => true, // New file
                Some(existing_pure) => {
                    // Compare PureFile structures
                    // We use Debug representation for structural comparison
                    // This is not perfect but works for most cases
                    format!("{:?}", generated.pure_file) != format!("{:?}", existing_pure)
                }
            };

            if is_changed {
                changed.files.insert(path.clone(), generated.clone());
            }
        }

        changed
    }

    /// Get paths of files that would be deleted (exist in `existing` but not in generated).
    pub fn deleted_paths<'a>(&self, existing: &'a HashMap<PathBuf, PureFile>) -> Vec<&'a PathBuf> {
        existing
            .keys()
            .filter(|path| !self.files.contains_key(*path))
            .collect()
    }
}

/// Generator that outputs code into multiple files.
///
/// This generator follows Rust's module conventions:
///
/// **Modern style** (`use_mod_rs = false`):
/// ```text
/// src/
///   lib.rs           # crate root
///   models.rs        # mod models
///   models/
///     user.rs        # mod models::user
///     post.rs        # mod models::post
/// ```
///
/// **Legacy style** (`use_mod_rs = true`):
/// ```text
/// src/
///   lib.rs           # crate root
///   models/
///     mod.rs         # mod models
///     user.rs        # mod models::user
///     post.rs        # mod models::post
/// ```
#[derive(Debug, Clone)]
pub struct MultiFileGenerator {
    /// Use mod.rs style (legacy) instead of module.rs style (modern).
    pub use_mod_rs: bool,
    /// Root file name (default: "lib.rs").
    pub root_file: String,
}

impl Default for MultiFileGenerator {
    fn default() -> Self {
        Self {
            use_mod_rs: false,
            root_file: "lib.rs".to_string(),
        }
    }
}

impl MultiFileGenerator {
    /// Create a new multi-file generator with modern style.
    pub fn new() -> Self {
        Self::default()
    }

    /// Use legacy mod.rs style.
    pub fn with_mod_rs_style(mut self) -> Self {
        self.use_mod_rs = true;
        self
    }

    /// Set root file name (e.g., "main.rs" for binaries).
    pub fn with_root_file(mut self, name: impl Into<String>) -> Self {
        self.root_file = name.into();
        self
    }

    /// Generate files from a ModuleTree.
    pub fn generate(&self, tree: &ModuleTree) -> Result<GeneratedFiles, crate::pure::ToSynError> {
        let mut files = GeneratedFiles::new();
        let root_path = PathBuf::from(&self.root_file);

        self.generate_module(tree, &root_path, &PathBuf::new(), true, &mut files)?;

        Ok(files)
    }

    /// Generate a module and its children recursively.
    ///
    /// - `tree`: The module tree to generate
    /// - `file_path`: Path to the file for this module
    /// - `dir_path`: Directory path for child modules
    /// - `is_root`: Whether this is the crate root
    /// - `files`: Output map
    fn generate_module(
        &self,
        tree: &ModuleTree,
        file_path: &Path,
        dir_path: &Path,
        is_root: bool,
        files: &mut GeneratedFiles,
    ) -> Result<(), crate::pure::ToSynError> {
        // Build items for this module
        let mut items = Vec::new();

        // Add uses first
        for u in &tree.uses {
            items.push(PureItem::Use(u.clone()));
        }

        // Add items
        items.extend(tree.items.iter().cloned());

        // Add mod declarations for children (without content - they're in separate files)
        for child in &tree.children {
            items.push(PureItem::Mod(PureMod {
                attrs: vec![],
                vis: child.vis.clone(),
                name: child.name.clone(),
                items: vec![], // External module - no inline content
            }));
        }

        // Create PureFile for this module
        let pure_file = PureFile {
            attrs: tree.inner_attrs.clone(),
            items,
        };

        let source = pure_file.to_source()?;
        files.files.insert(
            file_path.to_path_buf(),
            GeneratedSource { source, pure_file },
        );

        // Generate child modules recursively
        for child in &tree.children {
            let (child_file_path, child_dir_path) = if self.use_mod_rs {
                // Legacy style: module/mod.rs
                let child_dir = dir_path.join(&child.name);
                let child_file = child_dir.join("mod.rs");
                (child_file, child_dir)
            } else {
                // Modern style: module.rs + module/
                if child.children.is_empty() && is_root {
                    // Leaf module at root level: just module.rs
                    let child_file = dir_path.join(format!("{}.rs", child.name));
                    (child_file, dir_path.join(&child.name))
                } else if child.children.is_empty() {
                    // Leaf module in subdir: dir/module.rs
                    let child_file = dir_path.join(format!("{}.rs", child.name));
                    (child_file, dir_path.join(&child.name))
                } else {
                    // Non-leaf module: module.rs + module/
                    let child_file = dir_path.join(format!("{}.rs", child.name));
                    let child_dir = dir_path.join(&child.name);
                    (child_file, child_dir)
                }
            };

            self.generate_module(child, &child_file_path, &child_dir_path, false, files)?;
        }
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::pure::{
        PureBlock, PureFields, PureFn, PureGenerics, PureStruct, PureUse, PureUseTree, PureVis,
    };

    fn make_struct(name: &str) -> PureItem {
        PureItem::Struct(PureStruct {
            attrs: vec![],
            vis: PureVis::Public,
            name: name.to_string(),
            generics: PureGenerics::default(),
            fields: PureFields::Unit,
        })
    }

    fn make_fn(name: &str) -> PureItem {
        PureItem::Fn(PureFn {
            attrs: vec![],
            vis: PureVis::Public,
            is_async: false,
            is_async_inferred: false,
            is_const: false,
            is_unsafe: false,
            abi: None,
            name: name.to_string(),
            generics: PureGenerics::default(),
            params: vec![],
            ret: None,
            body: PureBlock::default(),
        })
    }

    fn make_use(path: &str) -> PureUse {
        let parts: Vec<&str> = path.split("::").collect();
        let tree = build_use_tree(&parts);
        PureUse {
            vis: PureVis::Private,
            tree,
        }
    }

    fn build_use_tree(parts: &[&str]) -> PureUseTree {
        if parts.len() == 1 {
            PureUseTree::Name(parts[0].to_string())
        } else {
            PureUseTree::Path {
                path: parts[0].to_string(),
                tree: Box::new(build_use_tree(&parts[1..])),
            }
        }
    }

    // ========================================================================
    // Basic Tests
    // ========================================================================

    #[test]
    fn test_multi_file_single_module() {
        let tree = ModuleTree::crate_root().with_item(make_struct("Config"));

        let generator = MultiFileGenerator::new();
        let result = generator.generate(&tree).unwrap();

        assert_eq!(result.len(), 1);
        assert!(result.get(Path::new("lib.rs")).is_some());

        let lib = result.get(Path::new("lib.rs")).unwrap();
        assert!(lib.source.contains("struct Config"));
    }

    #[test]
    fn test_multi_file_with_child_modern_style() {
        let tree = ModuleTree::crate_root()
            .with_item(make_struct("Config"))
            .with_child(
                ModuleTree::new("models")
                    .with_vis(PureVis::Public)
                    .with_item(make_struct("User")),
            );

        let generator = MultiFileGenerator::new();
        let result = generator.generate(&tree).unwrap();

        assert_eq!(result.len(), 2);

        // lib.rs should have mod declaration
        let lib = result.get(Path::new("lib.rs")).unwrap();
        assert!(lib.source.contains("struct Config"));
        assert!(lib.source.contains("pub mod models;"));
        assert!(!lib.source.contains("struct User")); // User is in separate file

        // models.rs should have User
        let models = result.get(Path::new("models.rs")).unwrap();
        assert!(models.source.contains("struct User"));
    }

    #[test]
    fn test_multi_file_with_child_mod_rs_style() {
        let tree = ModuleTree::crate_root()
            .with_item(make_struct("Config"))
            .with_child(
                ModuleTree::new("models")
                    .with_vis(PureVis::Public)
                    .with_item(make_struct("User")),
            );

        let generator = MultiFileGenerator::new().with_mod_rs_style();
        let result = generator.generate(&tree).unwrap();

        assert_eq!(result.len(), 2);

        // lib.rs should have mod declaration
        let lib = result.get(Path::new("lib.rs")).unwrap();
        assert!(lib.source.contains("pub mod models;"));

        // models/mod.rs should have User
        let models = result.get(Path::new("models/mod.rs")).unwrap();
        assert!(models.source.contains("struct User"));
    }

    #[test]
    fn test_multi_file_nested_modules() {
        let tree = ModuleTree::crate_root().with_child(
            ModuleTree::new("models")
                .with_vis(PureVis::Public)
                .with_item(make_struct("User"))
                .with_child(
                    ModuleTree::new("dto")
                        .with_vis(PureVis::Public)
                        .with_item(make_struct("UserDto")),
                ),
        );

        let generator = MultiFileGenerator::new();
        let result = generator.generate(&tree).unwrap();

        assert_eq!(result.len(), 3);

        // Check file structure
        assert!(result.get(Path::new("lib.rs")).is_some());
        assert!(result.get(Path::new("models.rs")).is_some());
        assert!(result.get(Path::new("models/dto.rs")).is_some());

        // Check content
        let lib = result.get(Path::new("lib.rs")).unwrap();
        assert!(lib.source.contains("pub mod models;"));

        let models = result.get(Path::new("models.rs")).unwrap();
        assert!(models.source.contains("struct User"));
        assert!(models.source.contains("pub mod dto;"));

        let dto = result.get(Path::new("models/dto.rs")).unwrap();
        assert!(dto.source.contains("struct UserDto"));
    }

    #[test]
    fn test_multi_file_with_uses() {
        let tree = ModuleTree::crate_root()
            .with_use(make_use("std::io"))
            .with_child(
                ModuleTree::new("utils")
                    .with_use(make_use("std::fmt"))
                    .with_item(make_fn("helper")),
            );

        let generator = MultiFileGenerator::new();
        let result = generator.generate(&tree).unwrap();

        let lib = result.get(Path::new("lib.rs")).unwrap();
        assert!(lib.source.contains("use std") && lib.source.contains("io"));

        let utils = result.get(Path::new("utils.rs")).unwrap();
        assert!(utils.source.contains("use std") && utils.source.contains("fmt"));
    }

    // ========================================================================
    // Diff Tests
    // ========================================================================

    #[test]
    fn test_diff_new_file() {
        let tree = ModuleTree::crate_root().with_item(make_struct("Config"));

        let generator = MultiFileGenerator::new();
        let generated = generator.generate(&tree).unwrap();

        // No existing files
        let existing: HashMap<PathBuf, PureFile> = HashMap::new();
        let diff = generated.diff(&existing);

        // All files should be in diff (they're new)
        assert_eq!(diff.len(), 1);
    }

    #[test]
    fn test_diff_unchanged() {
        let tree = ModuleTree::crate_root().with_item(make_struct("Config"));

        let generator = MultiFileGenerator::new();
        let generated = generator.generate(&tree).unwrap();

        // Same PureFile as generated
        let mut existing: HashMap<PathBuf, PureFile> = HashMap::new();
        existing.insert(
            PathBuf::from("lib.rs"),
            generated
                .get(Path::new("lib.rs"))
                .unwrap()
                .pure_file
                .clone(),
        );

        let diff = generated.diff(&existing);

        // No changes
        assert_eq!(diff.len(), 0);
    }

    #[test]
    fn test_diff_changed() {
        let tree = ModuleTree::crate_root().with_item(make_struct("Config"));

        let generator = MultiFileGenerator::new();
        let generated = generator.generate(&tree).unwrap();

        // Different PureFile
        let mut existing: HashMap<PathBuf, PureFile> = HashMap::new();
        existing.insert(
            PathBuf::from("lib.rs"),
            PureFile {
                attrs: vec![],
                items: vec![make_struct("OldConfig")], // Different!
            },
        );

        let diff = generated.diff(&existing);

        // lib.rs changed
        assert_eq!(diff.len(), 1);
        assert!(diff.get(Path::new("lib.rs")).is_some());
    }

    #[test]
    fn test_deleted_paths() {
        let tree = ModuleTree::crate_root().with_item(make_struct("Config"));

        let generator = MultiFileGenerator::new();
        let generated = generator.generate(&tree).unwrap();

        // Existing has extra file
        let mut existing: HashMap<PathBuf, PureFile> = HashMap::new();
        existing.insert(PathBuf::from("lib.rs"), PureFile::default());
        existing.insert(PathBuf::from("old_module.rs"), PureFile::default());

        let deleted = generated.deleted_paths(&existing);

        assert_eq!(deleted.len(), 1);
        assert_eq!(deleted[0], &PathBuf::from("old_module.rs"));
    }

    // ========================================================================
    // Main.rs Tests
    // ========================================================================

    #[test]
    fn test_multi_file_main_rs() {
        let tree = ModuleTree::crate_root().with_item(make_fn("main"));

        let generator = MultiFileGenerator::new().with_root_file("main.rs");
        let result = generator.generate(&tree).unwrap();

        assert!(result.get(Path::new("main.rs")).is_some());
        assert!(result.get(Path::new("lib.rs")).is_none());
    }

    // ========================================================================
    // Deep Nesting Tests
    // ========================================================================

    #[test]
    fn test_multi_file_deep_nesting() {
        let tree = ModuleTree::crate_root().with_child(ModuleTree::new("a").with_child(
            ModuleTree::new("b").with_child(ModuleTree::new("c").with_item(make_struct("Deep"))),
        ));

        let generator = MultiFileGenerator::new();
        let result = generator.generate(&tree).unwrap();

        // Should have: lib.rs, a.rs, a/b.rs, a/b/c.rs
        assert_eq!(result.len(), 4);
        assert!(result.get(Path::new("lib.rs")).is_some());
        assert!(result.get(Path::new("a.rs")).is_some());
        assert!(result.get(Path::new("a/b.rs")).is_some());
        assert!(result.get(Path::new("a/b/c.rs")).is_some());

        let c = result.get(Path::new("a/b/c.rs")).unwrap();
        assert!(c.source.contains("struct Deep"));
    }

    #[test]
    fn test_multi_file_deep_nesting_mod_rs() {
        let tree = ModuleTree::crate_root().with_child(
            ModuleTree::new("a").with_child(ModuleTree::new("b").with_item(make_struct("Deep"))),
        );

        let generator = MultiFileGenerator::new().with_mod_rs_style();
        let result = generator.generate(&tree).unwrap();

        // Should have: lib.rs, a/mod.rs, a/b/mod.rs
        assert_eq!(result.len(), 3);
        assert!(result.get(Path::new("lib.rs")).is_some());
        assert!(result.get(Path::new("a/mod.rs")).is_some());
        assert!(result.get(Path::new("a/b/mod.rs")).is_some());
    }

    // ========================================================================
    // Valid Rust Tests
    // ========================================================================

    #[test]
    fn test_all_generated_files_are_valid_rust() {
        let tree = ModuleTree::crate_root()
            .with_use(make_use("std::collections::HashMap"))
            .with_item(make_struct("App"))
            .with_child(
                ModuleTree::new("models")
                    .with_vis(PureVis::Public)
                    .with_item(make_struct("User"))
                    .with_child(
                        ModuleTree::new("dto")
                            .with_vis(PureVis::Public)
                            .with_item(make_struct("UserDto")),
                    ),
            )
            .with_child(ModuleTree::new("utils").with_item(make_fn("helper")));

        let generator = MultiFileGenerator::new();
        let result = generator.generate(&tree).unwrap();

        for (path, generated) in &result.files {
            syn::parse_str::<syn::File>(&generated.source).unwrap_or_else(|_| {
                panic!(
                    "File {} should be valid Rust:\n{}",
                    path.display(),
                    generated.source
                )
            });
        }
    }
}