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))

                    .with_postfixed_info(&prev_module.source, prev_module_pos, "Other definition was here")

            );

        }

        self.modules.push(LexedModule{

            source,

            module_name: module_name.clone(),

            version: module_version,

            root_id: pd

        });

        self.module_lookup.insert(module_name, cur_module_idx);

        Ok(pd)

    }

    pub fn compile(&mut self) {

        // Build module lookup

    }

    fn resolve_symbols_and_types(&mut self) -> Result<(SymbolTable, TypeTable), ParseError2> {

        // Construct the symbol table to resolve any imports and/or definitions,

        // then use the symbol table to actually annotate all of the imports.

        // If the type table is constructed correctly then all imports MUST be

        // resolvable.

        // TODO: Update once namespaced identifiers are implemented

        let symbol_table = SymbolTable::new(&self.heap, &self.modules)?;

        // Not pretty, but we need to work around rust's borrowing rules, it is

        // totally safe to mutate the contents of an AST element that we are

        // not borrowing anywhere else.

        // TODO: Maybe directly access heap's members to allow borrowing from

        //  mutliple members of Heap? Not pretty though...

        let mut module_index = 0;

        let mut import_index = 0;

        loop {

            if module_index >= self.modules.len() {

                break;

            }

            let module_root_id = self.modules[module_index].root_id;

            let import_id = {

                let root = &self.heap[module_root_id];

                if import_index >= root.imports.len() {

                    module_index += 1;

                    import_index = 0;

                    continue

                }

                root.imports[import_index]

            };

            let import = &mut self.heap[import_id];

            match import {

                Import::Module(import) => {

                    debug_assert!(import.module_id.is_none(), "module import already resolved");

                    let target_module_id = symbol_table.resolve_module(&import.module_name)

                        .expect("module import is resolved by symbol table");

                    import.module_id = Some(target_module_id)

                },

                Import::Symbols(import) => {

                    debug_assert!(import.module_id.is_none(), "module of symbol import already resolved");

                    let target_module_id = symbol_table.resolve_module(&import.module_name)

                        .expect("symbol import's module is resolved by symbol table");

                    import.module_id = Some(target_module_id);

                    for symbol in &mut import.symbols {

                        debug_assert!(symbol.definition_id.is_none(), "symbol import already resolved");

                        let (_, target_definition_id) = symbol_table.resolve_symbol(module_root_id, &symbol.alias)

                            .expect("symbol import is resolved by symbol table")

                            .as_definition()

                            .expect("symbol import does not resolve to namespace symbol");

                        symbol.definition_id = Some(target_definition_id);

                    }

                }

            }

        }

        // All imports in the AST are now annotated. We now use the symbol table

        // to construct the type table.

        let type_table = TypeTable::new(&symbol_table, &self.heap, &self.modules)?;

        Ok((symbol_table, type_table))

    }

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

    pub fn parse(&mut self) -> Result<RootId, ParseError2> {

        assert_eq!(self.modules.len(), 1, "Fix meeeee");

        let root_id = self.modules[0].root_id;

        let (mut symbol_table, mut type_table) = self.resolve_symbols_and_types()?;

        // TODO: @cleanup

        let mut ctx = visitor::Ctx{

            heap: &mut self.heap,

            module: &self.modules[0],

            symbols: &mut symbol_table,

            types: &mut type_table,

        };