pub(crate) mod symbol_table;

pub(crate) mod type_table;

pub(crate) mod tokens;

pub(crate) mod token_parsing;

pub(crate) mod pass_tokenizer;

pub(crate) mod pass_symbols;

pub(crate) mod pass_imports;

pub(crate) mod pass_definitions;

pub(crate) mod pass_definitions_types;

pub(crate) mod pass_validation_linking;

pub(crate) mod pass_rewriting;

pub(crate) mod pass_typing;

mod visitor;

use tokens::*;

use crate::collections::*;

use visitor::Visitor;

use pass_tokenizer::PassTokenizer;

use pass_symbols::PassSymbols;

use pass_imports::PassImport;

use pass_definitions::PassDefinitions;

use pass_validation_linking::PassValidationLinking;

use pass_typing::{PassTyping, ResolveQueue};

use symbol_table::*;

use type_table::TypeTable;

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

use crate::protocol::input_source::*;

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

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]

pub enum ModuleCompilationPhase {

    Tokenized,              // source is tokenized

    SymbolsScanned,         // all definitions are linked to their type class

    ImportsResolved,        // all imports are added to the symbol table

    DefinitionsParsed,      // produced the AST for the entire module

    TypesAddedToTable,      // added all definitions to the type table

    ValidatedAndLinked,     // AST is traversed and has linked the required AST nodes

    Rewritten,              // Special AST nodes are rewritten into regular AST nodes

    // When we continue with the compiler:

}

pub struct Module {

    // Buffers

    pub source: InputSource,

    pub tokens: TokenBuffer,

    // Identifiers

    pub root_id: RootId,

    pub name: Option<(PragmaId, StringRef<'static>)>,

    pub version: Option<(PragmaId, i64)>,

    pub phase: ModuleCompilationPhase,

}

    pub(crate) string_pool: StringPool, // Do not deallocate, holds all strings

    pub(crate) modules: Vec<Module>,

    pub(crate) symbol_table: SymbolTable,

    pub(crate) type_table: TypeTable,

    // Compiler passes, used as little state machine that keep their memory

    // around.

    pass_tokenizer: PassTokenizer,

    pass_symbols: PassSymbols,

    pass_import: PassImport,

    pass_definitions: PassDefinitions,

    pass_validation: PassValidationLinking,

    pass_typing: PassTyping,

    // Compiler options

    pub write_ast_to: Option<String>,

    pub(crate) arch: TargetArch,

}

impl Parser {

    pub fn new() -> Self {

        let mut parser = Parser{

            heap: Heap::new(),

            string_pool: StringPool::new(),

            modules: Vec::new(),

            symbol_table: SymbolTable::new(),

            type_table: TypeTable::new(),

            pass_tokenizer: PassTokenizer::new(),

            pass_symbols: PassSymbols::new(),

            pass_import: PassImport::new(),

            pass_definitions: PassDefinitions::new(),

            pass_validation: PassValidationLinking::new(),

            pass_typing: PassTyping::new(),

            write_ast_to: None,

            arch: TargetArch {

                array_size_alignment: (3*8, 8), // pointer, length, capacity

                slice_size_alignment: (2*8, 8), // pointer, length

                string_size_alignment: (3*8, 8), // pointer, length, capacity

                port_size_alignment: (3*4, 4), // two u32s: connector + port ID

                pointer_size_alignment: (8, 8),

            }

        };

        parser.symbol_table.insert_scope(None, SymbolScope::Global);

            let top = queue.pop().unwrap();

            let mut ctx = visitor::Ctx{

                heap: &mut self.heap,

                modules: &mut self.modules,

                module_idx: top.root_id.index as usize,

                symbols: &mut self.symbol_table,

                types: &mut self.type_table,

                arch: &self.arch,

            };

            self.pass_typing.handle_module_definition(&mut ctx, &mut queue, top)?;

        }

        // Write out desired information

        if let Some(filename) = &self.write_ast_to {

            let mut writer = ASTWriter::new();

            let mut file = std::fs::File::create(std::path::Path::new(filename)).unwrap();

            writer.write_ast(&mut file, &self.heap);

        }

        Ok(())

    }

}

// Note: args and return type need to be a function because we need to know the function ID.

use crate::collections::*;

use crate::protocol::*;

use super::visitor::*;

pub(crate) struct PassRewriting {

    current_scope: ScopeId,

    statement_buffer: ScopedBuffer<StatementId>,

    call_expr_buffer: ScopedBuffer<CallExpressionId>,

    expression_buffer: ScopedBuffer<ExpressionId>,

    scope_buffer: ScopedBuffer<ScopeId>,

}

impl PassRewriting {

    pub(crate) fn new() -> Self {

        Self{

            current_scope: ScopeId::new_invalid(),

            statement_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),

            call_expr_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),

            expression_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),

            scope_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),

        }

    }

}

impl Visitor for PassRewriting {

    // --- Visiting procedures

    fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {

        let def = &ctx.heap[id];

        let body_id = def.body;

        self.current_scope = def.scope;

        return self.visit_block_stmt(ctx, body_id);

    }

    fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionDefinitionId) -> VisitorResult {

        let def = &ctx.heap[id];

        let body_id = def.body;

        // that jump to the replacement block. So set the child/parent

        // relationship already.

        // --- for the statements

        let select_stmt = &mut ctx.heap[id];

        select_stmt.next = outer_block_id.upcast();

        let end_select_stmt_id = select_stmt.end_select;

        let select_stmt_relative_pos = select_stmt.relative_pos_in_parent;

        let outer_end_block_stmt = &mut ctx.heap[outer_end_block_id];

        outer_end_block_stmt.next = end_select_stmt_id.upcast();

        // --- for the scopes

        // Create statements that will create temporary variables for all of the

        // ports passed to the "get" calls in the select case guards.

        let select_stmt = &ctx.heap[id];

        let total_num_cases = select_stmt.cases.len();

        let mut total_num_ports = 0;

        let end_select_stmt_id = select_stmt.end_select;

        let end_select = &ctx.heap[end_select_stmt_id];

        // Put heap IDs into temporary buffers to handle borrowing rules

        let mut call_id_section = self.call_expr_buffer.start_section();

        let mut expr_id_section = self.expression_buffer.start_section();

        for case in select_stmt.cases.iter() {

            total_num_ports += case.involved_ports.len();

            for (call_id, expr_id) in case.involved_ports.iter().copied() {

                call_id_section.push(call_id);

                expr_id_section.push(expr_id);

            }

        }