plum

use std::collections::{HashMap, HashSet};

use std::path::{Path, PathBuf};

use crate::ast::{Import, Item, Source};

use crate::parser::AstParser;

/// Resolves `entry`'s `import` statements (transitively, and tolerating

/// diamond imports and cycles) against `lib_path`, and merges every reachable

/// file's top-level items into a single `Source`. The result's `module` and

/// `imports` fields are `entry`'s own (imported files' `module`/`imports`

/// fields are not otherwise used once their `items` have been merged in) —

/// only `items` accumulates across files.

///

/// `import "std/option"` resolves to `<lib_path>/std/option.plum`.

pub fn loadAndMerge(entry: &Path, lib_path: &Path) -> Result<Source, String> {

    let entry_canon = std::fs::canonicalize(entry)

        .map_err(|e| format!("cannot read entry file '{}': {}", entry.display(), e))?;

    let entry_source = parseFile(&entry_canon)?;

    let mut visited: HashSet<PathBuf> = HashSet::new();

    let mut items: Vec<Item> = Vec::new();

    let mut names: HashMap<String, PathBuf> = HashMap::new();

    visited.insert(entry_canon.clone());

    mergeItems(&entry_canon, &entry_source, &mut items, &mut names)?;

    for import in &entry_source.imports {

        loadImport(import, lib_path, &mut visited, &mut items, &mut names)?;

    }

    Ok(Source {

        module: entry_source.module,

        imports: entry_source.imports,

        items,

    })

}

fn loadImport(

    import: &Import,

    lib_path: &Path,

    visited: &mut HashSet<PathBuf>,

    items: &mut Vec<Item>,

    names: &mut HashMap<String, PathBuf>,

) -> Result<(), String> {

    let target = lib_path.join(format!("{}.plum", import.path));

    let target_canon = std::fs::canonicalize(&target)

        .map_err(|_| format!("import '{}': no such file '{}'", import.path, target.display()))?;

    if !visited.insert(target_canon.clone()) {

        // Already loaded — a diamond import or a cycle. Either way, its items

        // are already in `items`; nothing more to do.

        return Ok(());

    }

    let source = parseFile(&target_canon)?;

    mergeItems(&target_canon, &source, items, names)?;

    for nested in &source.imports {

        loadImport(nested, lib_path, visited, items, names)?;

    }

    Ok(())

}

fn parseFile(path: &Path) -> Result<Source, String> {

    let text = std::fs::read_to_string(path)

        .map_err(|e| format!("cannot read '{}': {}", path.display(), e))?;

    let mut parser = tree_sitter::Parser::new();

    parser

        .set_language(&tree_sitter_plum::LANGUAGE.into())

        .map_err(|e| format!("language error: {}", e))?;

    let tree = parser

        .parse(&text, None)

        .ok_or_else(|| format!("parse failed for '{}'", path.display()))?;

    let ap = AstParser::new(&text);

    Ok(ap.parseSource(tree.root_node()))

}

fn mergeItems(

    file: &Path,

    source: &Source,

    items: &mut Vec<Item>,

    names: &mut HashMap<String, PathBuf>,

) -> Result<(), String> {

    for item in &source.items {

        let key = itemNameKey(item);

        if let Some(existing_file) = names.get(&key) {

            return Err(format!(

                "duplicate declaration '{}': declared in both '{}' and '{}'",

                key,

                existing_file.display(),

                file.display()

            ));

        }

        names.insert(key, file.to_path_buf());

        items.push(item.clone());

    }

    Ok(())

}

/// A collision key that mirrors `plum-checker`'s own separation of

/// namespaces: methods are keyed by `(receiver, name)` (so `length<Cat>` and

/// `length<Box>` never collide, exactly like `plum_checker::MethodEnv`),

/// while classes/traits/enums/consts/free-functions are each their own

/// flat, kind-qualified namespace.

fn itemNameKey(item: &Item) -> String {

    match item {

        Item::Class(c) => format!("class::{}", c.name),

        Item::Trait(t) => format!("trait::{}", t.name),

        Item::Enum(e) => format!("enum::{}", e.name),

        Item::Const(c) => format!("const::{}", c.name),

        Item::Fn(f) => match &f.type_param {

            Some(recv) => format!("method::{}::{}", recv, f.name),

            None => format!("fn::{}", f.name),

        },

    }

}