mod depth_visitor;

mod symbol_table;

mod type_table;

mod visitor;

use depth_visitor::*;

use symbol_table::SymbolTable;

use visitor::{Visitor2, ValidityAndLinkerVisitor};

use type_table::TypeTable;

use crate::protocol::ast::*;

use crate::protocol::inputsource::*;

use crate::protocol::lexer::*;

use std::collections::HashMap;

use crate::protocol::parser::visitor::Ctx;

use crate::protocol::ast_printer::ASTWriter;

// TODO: @fixme, pub qualifier

pub(crate) struct LexedModule {

    pub(crate) source: InputSource,

    module_name: Vec<u8>,

    version: Option<u64>,

    root_id: RootId,

}

pub struct Parser {

    pub(crate) heap: Heap,

    pub(crate) modules: Vec<LexedModule>,

    pub(crate) module_lookup: HashMap<Vec<u8>, usize>, // from (optional) module name to `modules` idx

}

impl Parser {

    pub fn new() -> Self {

        Parser{

            heap: Heap::new(),

            modules: Vec::new(),

            module_lookup: HashMap::new()

        }

    }

    // TODO: @fix, temporary implementation to keep code compilable

    pub fn new_with_source(source: InputSource) -> Result<Self, ParseError2> {

        let mut parser = Parser::new();

        parser.feed(source)?;

        Ok(parser)

    }

    pub fn feed(&mut self, mut source: InputSource) -> Result<RootId, ParseError2> {

        // Lex the input source

        let mut lex = Lexer::new(&mut source);

        let pd = lex.consume_protocol_description(&mut self.heap)?;

        // Seek the module name and version

        let root = &self.heap[pd];

        let mut module_name_pos = InputPosition::default();

        let mut module_name = Vec::new();

        let mut module_version_pos = InputPosition::default();

        let mut module_version = None;

        for pragma in &root.pragmas {

            match &self.heap[*pragma] {

                Pragma::Module(module) => {

                    if !module_name.is_empty() {

                        return Err(

                            ParseError2::new_error(&source, module.position, "Double definition of module name in the same file")

                                .with_postfixed_info(&source, module_name_pos, "Previous definition was here")

                        )

                    }

                    module_name_pos = module.position.clone();

                    module_name = module.value.clone();

                },

                Pragma::Version(version) => {

                    if module_version.is_some() {

                        return Err(

                            ParseError2::new_error(&source, version.position, "Double definition of module version")

                                .with_postfixed_info(&source, module_version_pos, "Previous definition was here")

                        )

                    }

                    module_version_pos = version.position.clone();

                    module_version = Some(version.version);

                },

            }

        }

        // Add module to list of modules and prevent naming conflicts

        let cur_module_idx = self.modules.len();

        if let Some(prev_module_idx) = self.module_lookup.get(&module_name) {

            // Find `#module` statement in other module again

            let prev_module = &self.modules[*prev_module_idx];

            let prev_module_pos = self.heap[prev_module.root_id].pragmas

                .iter()

                .find_map(|p| {

                    match &self.heap[*p] {

                        Pragma::Module(module) => Some(module.position.clone()),

                        _ => None

                    }

                })

                .unwrap_or(InputPosition::default());

            let module_name_msg = if module_name.is_empty() {

                format!("a nameless module")

            } else {

                format!("module '{}'", String::from_utf8_lossy(&module_name))

            };

            return Err(

                ParseError2::new_error(&source, module_name_pos, &format!("Double definition of {} across files", module_name_msg))