use std::{collections::HashMap, path::PathBuf, sync::Arc};

use rowan::ast::{AstNode, AstPtr};

use self::{
    error::{Error, WorldCreationError},
    mod_tree::{Module, ModuleTree},
    source_file::SourceFile,
};

mod error;
mod mod_tree;
mod nodes;
mod source_file;

struct Loc<T: AstNode> {
    file: PathBuf,
    syntax_el: AstPtr<T>,
}

impl<T: AstNode> Loc<T> {
    pub fn new(file: PathBuf, syntax_el: &T) -> Self {
        Self {
            file,
            syntax_el: AstPtr::new(syntax_el),
        }
    }
}

pub struct World {
    entry_point: PathBuf,
    files: HashMap<PathBuf, SourceFile>,
    errors: Vec<Error>,
    module_tree: ModuleTree,
}

impl World {
    pub fn new(entry_point: PathBuf) -> Result<Self, WorldCreationError> {
        let entry_point = entry_point.canonicalize().unwrap();
        let source = match std::fs::read_to_string(&entry_point) {
            Ok(f) => f,
            Err(e) => return Err(WorldCreationError::FailedToOpenEntryPoint(entry_point, e)),
        };

        let (src, mut errors) = SourceFile::parse_from(entry_point.clone(), source);

        let (module_tree, mut files, new_errors) = ModuleTree::parse_from_main(&entry_point, &src);
        errors.extend(new_errors);
        module_tree.print_tree(&src.tree());
        dbg!(&errors);

        let _ = files.insert(entry_point.clone(), src);

        Ok(Self {
            files,
            entry_point,
            errors,
            module_tree,
        })
    }

    // fn parse_mod_tree(files: &mut HashMap<PathBuf, SourceFile>)
}

// struct SourceFile {
//     tree: SyntaxNode,
// items: Vec<TopLevelItem>,
// }