use std::fs::File;

use std::io::Read;

use clap::{App, Arg};

use reowolf_rs as rw;

fn main() {

    let app = App::new("rwc")

        .author("Henger, M.")

        .version(env!("CARGO_PKG_VERSION"))

        .about("Reowolf compiler")

        .arg(

            Arg::new("input")

                .long("input")

                .short('i')

                .help("input files")

                .required(true)

                .takes_value(true)

                .multiple_occurrences(true)

        )

        .arg(

            Arg::new("threads")

                .long("threads")

                .short('t')

                .help("number of runtime threads")

                .default_value("1")

                .takes_value(true)

        )

        .arg(

            Arg::new("debug")

                .long("debug")

                .short('d')

                .help("enable debug logging")

        );

    // Retrieve arguments and convert

    let app = app.get_matches();

    let input_files = app.values_of("input");

    if input_files.is_none() {

        println!("ERROR: Expected at least one input file");

        return;

    }

    let num_threads = app.value_of("threads").unwrap();

    let num_threads = match num_threads.parse::<i32>() {

        Ok(num_threads) => {

            if num_threads < 0 || num_threads > 255 {

                println!("ERROR: Number of threads must be a number between 0 and 256");

                return;

            }

            num_threads as u32

        },

        Err(err) => {

            println!("ERROR: Failed to parse number of threads\nbecause: {}", err);

            return;

        }

    };

    let debug_enabled = app.is_present("debug");

    // Add input files to file buffer

    let input_files = input_files.unwrap();

    assert!(input_files.len() > 0); // because arg is required

    let mut file_buffer = Vec::with_capacity(4096);

    for input_file in input_files {

        print!("Adding file: {} ... ", input_file);

        let mut file = match File::open(input_file) {

            Ok(file) => file,

            Err(err) => {

                println!("FAILED (to open file)\nbecause:\n{}", err);

                return;

            }

        };

        file_buffer.clear();

        if let Err(err) = file.read_to_end(&mut file_buffer) {

            println!("FAILED (to read file)\nbecause:\n{}", err);

            return;

        }

        if let Err(err) = builder.add(input_file.to_string(), file_buffer.clone()) {

            println!("FAILED (to tokenize file)\nbecause:\n{}", err);

        }

        println!("Success");

    }

    // Compile the program

    print!("Compiling program ... ");

    let protocol_description = match builder.compile() {

        Ok(pd) => pd,

        Err(err) => {

            println!("FAILED\nbecause:\n{}", err);

            return;

        }

    };

    println!("Success");

    // Make sure there is a nameless module with a main component

    print!("Creating main component ... ");

    if let Err(err) = runtime.create_component(b"", b"main") {

        use rw::ComponentCreationError as CCE;

        let reason = match err {

            CCE::ModuleDoesntExist => "Input files did not contain a nameless module (that should contain the 'main' component)",

            CCE::DefinitionDoesntExist => "Input files did not contain a component called 'main'",

            CCE::DefinitionNotComponent => "Input file contained a 'main' function, but not a 'main' component",

            _ => "Unexpected error"

        };

        println!("FAILED\nbecause:\n{} (raw error: {:?})", reason, err);

        return;

    }

    println!("Success");

    println!("Now running until all components have exited");

    println!("--------------------------------------------\n\n");

}

pub(crate) mod ast;

pub(crate) mod ast_writer;

mod token_writer;

use std::sync::Mutex;

use crate::collections::{StringPool, StringRef};

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

use crate::protocol::eval::*;

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

use crate::protocol::parser::*;

use crate::protocol::type_table::*;

pub use parser::type_table::TypeId;

/// A protocol description module

pub struct Module {

    pub(crate) source: InputSource,

    pub(crate) root_id: RootId,

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

}

/// Description of a protocol object, used to configure new connectors.

#[repr(C)]

pub struct ProtocolDescription {

    pub(crate) modules: Vec<Module>,

    pub(crate) heap: Heap,

    pub(crate) types: TypeTable,

    pub(crate) pool: Mutex<StringPool>,

}

#[derive(Debug, Clone)]

pub(crate) struct ComponentState {

    pub(crate) prompt: Prompt,

}

#[derive(Debug)]

pub enum ComponentCreationError {

    ModuleDoesntExist,

    DefinitionDoesntExist,

    DefinitionNotComponent,

    InvalidNumArguments,

    InvalidArgumentType(usize),

    UnownedPort,

    InSync,

}

impl ProtocolDescription {

    pub fn parse(buffer: &[u8]) -> Result<Self, String> {

        let source = InputSource::new(String::new(), Vec::from(buffer));

        parser.feed(source).expect("failed to feed source");

        if let Err(err) = parser.parse() {

            println!("ERROR:\n{}", err);

            return Err(format!("{}", err))

        }

        let modules: Vec<Module> = parser.modules.into_iter()

            .map(|module| Module{

                source: module.source,

                root_id: module.root_id,

                name: module.name.map(|(_, name)| name)

            })

            .collect();

        return Ok(ProtocolDescription {

            modules,

            heap: parser.heap,

            types: parser.type_table,

            pool: Mutex::new(parser.string_pool),

        });

    }

    pub(crate) fn new_component(

        &self, module_name: &[u8], identifier: &[u8], arguments: ValueGroup

    ) -> Result<Prompt, ComponentCreationError> {

        // Find the module in which the definition can be found

        let module_root = self.lookup_module_root(module_name);

        if module_root.is_none() {

            return Err(ComponentCreationError::ModuleDoesntExist);

        }

        let module_root = module_root.unwrap();

        let root = &self.heap[module_root];

        let definition_id = root.get_definition_by_ident(&self.heap, identifier);

        if definition_id.is_none() {

            return Err(ComponentCreationError::DefinitionDoesntExist);

        }

        let definition_id = definition_id.unwrap();

        let ast_definition = &self.heap[definition_id];

        if !ast_definition.is_procedure() {

            return Err(ComponentCreationError::DefinitionNotComponent);

        }

        // Make sure that the types of the provided value group matches that of

        // the expected types.

        let ast_definition = ast_definition.as_procedure();

                if let Value::Array(heap_pos) = argument {

                    let heap_pos = *heap_pos;

                    for element in &arguments.regions[heap_pos as usize] {

                        if !self.verify_same_type(expected, expected_idx + 1, arguments, element) {

                            return false;

                        }

                    }

                    return true;

                } else {

                    return false;

                }

            },

            CTP::Input => if let Value::Input(_) = argument { true } else { false },

            CTP::Output => if let Value::Output(_) = argument { true } else { false },

            CTP::Tuple(_) => todo!("implement full type checking on user-supplied arguments"),

            CTP::Instance(definition_id, _num_embedded) => {

                let definition = self.types.get_base_definition(definition_id).unwrap();

                match &definition.definition {

                    DefinedTypeVariant::Enum(definition) => {

                        if let Value::Enum(variant_value) = argument {

                            let is_valid = definition.variants.iter()

                                .any(|v| v.value == *variant_value);

                            return is_valid;

                        }

                    },

                    _ => todo!("implement full type checking on user-supplied arguments"),

                }

                return false;

            },

        }

    }

}

pub trait RunContext {

    fn performed_put(&mut self, port: PortId) -> bool;

    fn performed_get(&mut self, port: PortId) -> Option<ValueGroup>; // None if still waiting on message

    fn fires(&mut self, port: PortId) -> Option<Value>; // None if not yet branched

    fn performed_fork(&mut self) -> Option<bool>; // None if not yet forked

    fn created_channel(&mut self) -> Option<(Value, Value)>; // None if not yet prepared

    fn performed_select_wait(&mut self) -> Option<u32>; // None if not yet notified runtime of select blocker

}

pub struct ProtocolDescriptionBuilder {

    parser: Parser,

}

impl ProtocolDescriptionBuilder {

    }

    pub fn add(&mut self, filename: String, buffer: Vec<u8>) -> Result<(), ParseError> {

        let input = InputSource::new(filename, buffer);

        self.parser.feed(input)?;

        return Ok(())

    }

    pub fn compile(mut self) -> Result<ProtocolDescription, ParseError> {

        self.parser.parse()?;

        let modules: Vec<Module> = self.parser.modules.into_iter()

            .map(|module| Module{

                source: module.source,

                root_id: module.root_id,

                name: module.name.map(|(_, name)| name)

            })

            .collect();

        return Ok(ProtocolDescription {

            modules,

            heap: self.parser.heap,

            types: self.parser.type_table,

            pool: Mutex::new(self.parser.string_pool),

        });

    }

}

pub struct TypeInspector<'a> {

    heap: &'a Definition,

    type_table: &'a MonoType,

}

impl<'a> TypeInspector<'a> {

    pub fn as_union(&'a self) -> UnionTypeInspector<'a> {

        let heap = self.heap.as_union();

        let type_table = self.type_table.variant.as_union();

        return UnionTypeInspector{ heap, type_table };

    }

}

pub struct UnionTypeInspector<'a> {

    heap: &'a UnionDefinition,

    type_table: &'a UnionMonomorph,

}

impl UnionTypeInspector<'_> {

            message_type_id: TypeId::new_invalid(),

            uint8_type_id: TypeId::new_invalid(),

            uint16_type_id: TypeId::new_invalid(),

            uint32_type_id: TypeId::new_invalid(),

            uint64_type_id: TypeId::new_invalid(),

            sint8_type_id: TypeId::new_invalid(),

            sint16_type_id: TypeId::new_invalid(),

            sint32_type_id: TypeId::new_invalid(),

            sint64_type_id: TypeId::new_invalid(),

            char_type_id: TypeId::new_invalid(),

            string_type_id: TypeId::new_invalid(),

            array_type_id: TypeId::new_invalid(),

            slice_type_id: TypeId::new_invalid(),

            input_type_id: TypeId::new_invalid(),

            output_type_id: TypeId::new_invalid(),

            pointer_type_id: TypeId::new_invalid(),

        }

    }

}

pub struct PassCtx<'a> {

    heap: &'a mut Heap,

    symbols: &'a mut SymbolTable,

    pool: &'a mut StringPool,

    arch: &'a TargetArch,

}

pub struct Parser {

    // Storage of all information created/gathered during compilation.

    pub(crate) heap: Heap,

    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,

    pub(crate) global_module_index: usize, // contains globals, implicitly imported everywhere

    // 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,

    pass_rewriting: PassRewriting,

    pass_stack_size: PassStackSize,

    // Compiler options

    pub write_tokens_to: Option<String>,

    pub write_ast_to: Option<String>,

    pub(crate) arch: TargetArch,

}

impl Parser {

        let mut parser = Parser{

            heap: Heap::new(),

            string_pool: StringPool::new(),

            modules: Vec::new(),

            symbol_table: SymbolTable::new(),

            type_table: TypeTable::new(),

            global_module_index: 0,

            pass_tokenizer: PassTokenizer::new(),

            pass_symbols: PassSymbols::new(),

            pass_import: PassImport::new(),

            pass_definitions: PassDefinitions::new(),

            pass_validation: PassValidationLinking::new(),

            pass_typing: PassTyping::new(),

            pass_rewriting: PassRewriting::new(),

            pass_stack_size: PassStackSize::new(),

            write_tokens_to: None,

            write_ast_to: None,

            arch: TargetArch::new(),

        };

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

        // Insert builtin types

        // TODO: At some point use correct values for size/alignment

        parser.arch.void_type_id    = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Void], false, 0, 1);

        parser.arch.message_type_id = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Message], false, 24, 8);

        parser.arch.bool_type_id    = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Bool], false, 1, 1);

        parser.arch.uint8_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::UInt8], false, 1, 1);

        parser.arch.uint16_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::UInt16], false, 2, 2);

        parser.arch.uint32_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::UInt32], false, 4, 4);

        parser.arch.uint64_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::UInt64], false, 8, 8);

        parser.arch.sint8_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::SInt8], false, 1, 1);

        parser.arch.sint16_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::SInt16], false, 2, 2);

        parser.arch.sint32_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::SInt32], false, 4, 4);

        parser.arch.sint64_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::SInt64], false, 8, 8);

        parser.arch.char_type_id    = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Character], false, 4, 4);

        parser.arch.string_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::String], false, 24, 8);

        parser.arch.array_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Array, ConcreteTypePart::Void], true, 24, 8);

        parser.arch.slice_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Slice, ConcreteTypePart::Void], true, 16, 4);

        parser.arch.input_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Input, ConcreteTypePart::Void], true, 8, 8);

        parser.arch.output_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Output, ConcreteTypePart::Void], true, 8, 8);

        parser.arch.pointer_type_id = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Pointer, ConcreteTypePart::Void], true, 8, 8);

        // Parse standard library

        parser.feed_standard_library()?;

        return Ok(parser)

    }

    /// Feeds a new InputSource to the parser, which will tokenize it and store

    /// it internally for later parsing (when all modules are present). Returns

    /// the index of the new module.

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

        return self.feed_internal(source, false, false);

    }

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

        let mut pass_ctx = PassCtx{

            heap: &mut self.heap,

            symbols: &mut self.symbol_table,

            pool: &mut self.string_pool,

            arch: &self.arch,

        };

        // Advance all modules to the phase where all symbols are scanned

                arch: &self.arch,

            };

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

        }

        // Rewrite nodes in tree, then prepare for execution of code

        for module_idx in 0..self.modules.len() {

            self.modules[module_idx].phase = ModuleCompilationPhase::Typed;

            let mut ctx = visitor::Ctx{

                heap: &mut self.heap,

                modules: &mut self.modules,

                module_idx,

                symbols: &mut self.symbol_table,

                types: &mut self.type_table,

                arch: &self.arch,

            };

            self.pass_rewriting.visit_module(&mut ctx)?;

            self.pass_stack_size.visit_module(&mut ctx)?;

        }

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

    }

    /// Tries to find the standard library and add the files for parsing.

    fn feed_standard_library(&mut self) -> Result<(), String> {

        use std::env;

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

        use std::fs;

        // Pair is (name, add_to_global_namespace)

        const FILES: [(&'static str, bool); 3] = [

            ("std.global.pdl", true),

            ("std.internet.pdl", false),

            ("std.random.pdl", false),

        ];

        // Determine base directory

        let (base_path, from_env) = if let Ok(path) = env::var(REOWOLF_PATH_ENV) {

            // Path variable is set

            (path, true)

        } else {

            (path, false)

        };

        // Make sure directory exists

        let path = Path::new(&base_path);

        if !path.exists() {

            return Err(format!("std lib root directory '{}' does not exist", base_path));

        }

        // Try to load all standard library files. We might need a more unified

        // way to do this in the future (i.e. a "std" package, containing all

        // of the modules)

        let mut file_path = PathBuf::new();

        let mut first_file = true;

        for (file, add_to_global_namespace) in FILES {

            file_path.clear();

            file_path.push(path);

            file_path.push(file);

            let source = fs::read(file_path.as_path());

            if let Err(err) = source {

                return Err(format!(

                    "failed to read std lib file '{}' in root directory '{}', because: {}",

                    file, base_path, err

                ));

            }

            let source = source.unwrap();

            let input_source = InputSource::new(file.to_string(), source);

            let module_index = self.feed_internal(input_source, true, add_to_global_namespace);

            if let Err(err) = module_index {

                // A bit of a hack, but shouldn't really happen anyway: the

                // compiler should ship with a decent standard library (at some

                // point)

                return Err(format!("{}", err));

            }

            let module_index = module_index.unwrap();

            if first_file {

                self.global_module_index = module_index;

                first_file = false;

            }

        }

        return Ok(())

    }

    heap: &'a Heap,

    modules: &'a Vec<Module>,

    types: &'a TypeTable,

    symbols: &'a SymbolTable,

}

//------------------------------------------------------------------------------

// Interface for parsing and compiling

//------------------------------------------------------------------------------

pub(crate) struct Tester {

    test_name: String,

    sources: Vec<String>

}

impl Tester {

    /// Constructs a new tester, allows adding multiple sources before compiling

    pub(crate) fn new<S: ToString>(test_name: S) -> Self {

        Self{

            test_name: test_name.to_string(),

            sources: Vec::new()

        }

    }

    /// Utility for quick tests that use a single source file and expect the

    /// compilation to succeed.

    pub(crate) fn new_single_source_expect_ok<T: ToString, S: ToString>(test_name: T, source: S) -> AstOkTester {

        Self::new(test_name)

            .with_source(source)

            .compile()

            .expect_ok()

    }

    /// Utility for quick tests that use a single source file and expect the

    /// compilation to fail.

    pub(crate) fn new_single_source_expect_err<T: ToString, S: ToString>(test_name: T, source: S) -> AstErrTester {

        Self::new(test_name)

            .with_source(source)

            .compile()

            .expect_err()

    }

    pub(crate) fn with_source<S: ToString>(mut self, source: S) -> Self {

        self.sources.push(source.to_string());

        self

    }

    pub(crate) fn compile(self) -> AstTesterResult {

        for source in self.sources.into_iter() {

            let source = source.into_bytes();

            let input_source = InputSource::new(String::from(""), source);

            if let Err(err) = parser.feed(input_source) {

                return AstTesterResult::Err(AstErrTester::new(self.test_name, err))

            }

        }

        if let Err(err) = parser.parse() {

            return AstTesterResult::Err(AstErrTester::new(self.test_name, err))

        }

        AstTesterResult::Ok(AstOkTester::new(self.test_name, parser))

    }

}

pub(crate) enum AstTesterResult {

    Ok(AstOkTester),

    Err(AstErrTester)

}

impl AstTesterResult {

    pub(crate) fn expect_ok(self) -> AstOkTester {

        match self {

            AstTesterResult::Ok(v) => v,

            AstTesterResult::Err(err) => {

                let wrapped = ErrorTester{ test_name: &err.test_name, error: &err.error };

                println!("DEBUG: Full error:\n{}", &err.error);

                assert!(

                    false,

                    "[{}] Expected compilation to succeed, but it failed with {}",

                    err.test_name, wrapped.assert_postfix()

                );

                unreachable!();

            }

        }

    }

    pub(crate) fn expect_err(self) -> AstErrTester {

        match self {

            AstTesterResult::Ok(ok) => {

                assert!(false, "[{}] Expected compilation to fail, but it succeeded", ok.test_name);

                unreachable!();

            },

            AstTesterResult::Err(err) => err,

        }