import io:*
import mem:*
import map:*
import string:*
import util:*
import tree:*
import symbol:*
import ast_nodes:*
import poset:*


obj c_generator (Object) {
    fun construct(): *c_generator {
        return this
    }
    fun copy_construct(old: *c_generator) {
    }
    fun operator=(other: ref c_generator) {
        destruct()
        copy_construct(&other)
    }
    fun destruct() {
    }
    fun generate_c(name_ast_map: map<string, pair<*tree<symbol>,*ast_node>>): pair<string,string> {
        var linker_string:string = ""
        var prequal: string = "#include <stdbool.h>\n#include <stdlib.h>\n#include <stdio.h>\n"
        var plain_typedefs: string = "\n/**Plain Typedefs**/\n"
        var top_level_c_passthrough: string = ""
        var variable_extern_declarations: string = ""
        var structs: string = "\n/**Type Structs**/\n"
        var function_typedef_string_pre: string = ""
        var function_typedef_string: string = ""
        var function_prototypes: string = "\n/**Function Prototypes**/\n"
        var function_definitions: string = "\n/**Function Definitions**/\n"
        var variable_declarations: string = "\n/**Variable Declarations**/\n"

        // moved out from below so that it can be used for methods as well as regular functions (and eventually lambdas...)
        var generate_function_definition = fun(child: *ast_node) {
            var backing = child->function

            var parameter_types = string()
            var parameters = string()
            var decorated_name = generate_function(child)
            // also add in name decoration
            backing.parameters.for_each(fun(parameter: *ast_node) {
                if (parameter_types != "") { parameter_types += ", "; parameters += ", ";}
                parameter_types += type_to_c(parameter->identifier.type)
                parameters += type_to_c(parameter->identifier.type) + " " + parameter->identifier.name
            })
            function_prototypes += type_to_c(backing.type->return_type) + " " + decorated_name + "(" + parameter_types + ");\n"

            // add parameters to destructor thingy (for returns)? Or should that be a different pass?
            function_definitions += type_to_c(backing.type->return_type) + " " + decorated_name + "(" + parameters + ") {\n" + generate_statement(backing.body_statement)
            // emit parameter destructors?
            function_definitions += "}\n"
        }

        var type_poset = poset<*ast_node>()
        // iterate through asts
        name_ast_map.for_each(fun(name: string, tree_pair: pair<*tree<symbol>,*ast_node>) {
            // iterate through children for each ast
            // assert translation_unit?
            tree_pair.second->translation_unit.children.for_each(fun(child: *ast_node) {
                match (*child) {
                    // should really check the genrator
                    ast_node::if_comp(backing) {
                        if (is_simple_passthrough(backing.statement->statement.child))
                            top_level_c_passthrough += generate_simple_passthrough(backing.statement->statement.child)
                    }
                    ast_node::simple_passthrough(backing) top_level_c_passthrough += generate_simple_passthrough(child)
                    ast_node::declaration_statement(backing) variable_declarations += generate_declaration_statement(child) + ";\n"
                    ast_node::function(backing) {
                        // make sure not a template
                        // or a passthrough
                        // check for and add to parameters if a closure
                        generate_function_definition(child)
                    }
                    ast_node::type_def(backing) {
                        type_poset.add_vertex(child)
                    }
                }
            })
        })
        type_poset.get_sorted().for_each(fun(vert: *ast_node) {
            plain_typedefs += string("typedef struct ") + vert->type_def.name + "_dummy " + vert->type_def.name + ";\n"
            structs += string("struct ") + vert->type_def.name + "_dummy {\n"
            vert->type_def.variables.for_each(fun(variable_declaration: *ast_node) structs += generate_declaration_statement(variable_declaration) + ";\n";)
            structs += "};\n"
            // generate the methods
            vert->type_def.methods.for_each(fun(method: *ast_node) generate_function_definition(method);)
        })

        return make_pair(prequal+plain_typedefs+top_level_c_passthrough+variable_extern_declarations+structs+function_typedef_string_pre+function_typedef_string+function_prototypes+variable_declarations+function_definitions + "\n", linker_string)
    }
    fun generate_if_comp(node: *ast_node): string {
        if (node->if_comp.wanted_generator == "__C__")
            return generate(node->if_comp.statement)
        return string("")
    }
    fun generate_simple_passthrough(node: *ast_node): string {
        // deal with all the passthrough params
        return node->simple_passthrough.passthrough_str
    }
    fun generate_statement(node: *ast_node): string return generate(node->statement.child) + ";\n";
    fun generate_declaration_statement(node: *ast_node): string {
        var identifier = node->declaration_statement.identifier
        var to_ret = type_to_c(identifier->identifier.type) + " " + identifier->identifier.name
        if (node->declaration_statement.expression) to_ret += string(" = ") + generate(node->declaration_statement.expression)
        return to_ret
    }
    fun generate_assignment_statement(node: *ast_node): string {
        return generate(node->assignment_statement.to) + " = " + generate(node->assignment_statement.from)
    }
    fun generate_if_statement(node: *ast_node): string {
        var if_str = string("if (") + generate(node->if_statement.condition) + ") {\n" + generate(node->if_statement.then_part) + "}"
        if (node->if_statement.else_part)
            if_str += string(" else {\n") + generate(node->if_statement.else_part) + "}"
        return if_str + "\n"
    }
    fun generate_while_loop(node: *ast_node): string {
        return string("while (") + generate(node->while_loop.condition) + ") {\n" + generate(node->while_loop.statement) + "}\n"
    }
    fun generate_for_loop(node: *ast_node): string {
        // gotta take off last semicolon
        return string("for (") + generate(node->for_loop.init) + " " + generate(node->for_loop.condition) + "; " +
            generate(node->for_loop.update).slice(0,-3) + ") {\n" + generate(node->for_loop.body) + "}\n"
    }
    fun generate_identifier(node: *ast_node): string {
        return node->identifier.name
    }
    fun generate_return_statement(node: *ast_node): string return string("return ") + generate(node->return_statement.return_value);
    fun generate_value(node: *ast_node): string return node->value.string_value;
    fun generate_code_block(node: *ast_node): string {
        var to_ret = string("{\n")
        node->code_block.children.for_each(fun(child: *ast_node) to_ret += generate(child);)
        return to_ret + "}"
    }
    // this generates the function as a value, not the actual function
    fun generate_function(node: *ast_node): string {
        var str = node->function.name
        node->function.parameters.for_each(fun(param: *ast_node) str += string("_") + type_decoration(param->identifier.type);)
        return str

    }
    fun generate_function_call(node: *ast_node): string {
        if (is_function_call(node->function_call.func) &&
            is_function(node->function_call.func->function_call.func) &&
            (node->function_call.func->function_call.func->name == "." || node->function_call.func->function_call.func->name == ".") &&
        ) {
        }

        var func_name = generate(node->function_call.func)
        var parameters = node->function_call.parameters
        if (func_name == "+" || func_name == "-" || func_name == "*" || func_name == "/" || func_name == "||"
            || func_name == "&&" || func_name == "<" || func_name == ">" || func_name == "<=" || func_name == ">="
            || func_name == "==" || func_name == "." || func_name == "->"
        )
            return string("(") + generate(parameters[0]) + func_name + generate(parameters[1]) + string(")")
        // the post ones need to be post-ed specifically, and take the p off
        if (func_name == "++p" || func_name == "--p")
            return string("(") + generate(parameters[0]) + ")" + func_name.slice(0,-2)
        var call_string = string()
        parameters.for_each(fun(param: *ast_node) {
            if (call_string != "")
                call_string += ", "
            call_string += generate(param)
        })
        return func_name + "(" + call_string + ")"
    }

    // for now, anyway
    fun generate(node: *ast_node): string {
        if (!node) return string("/*NULL*/")
        match (*node) {
            ast_node::if_comp(backing) return generate_if_comp(node)
            ast_node::simple_passthrough(backing) return generate_simple_passthrough(node)
            ast_node::statement(backing) return generate_statement(node)
            ast_node::declaration_statement(backing) return generate_declaration_statement(node)
            ast_node::assignment_statement(backing) return generate_assignment_statement(node)
            ast_node::if_statement(backing) return generate_if_statement(node)
            ast_node::while_loop(backing) return generate_while_loop(node)
            ast_node::for_loop(backing) return generate_for_loop(node)
            ast_node::function(backing) return generate_function(node)
            ast_node::function_call(backing) return generate_function_call(node)
            ast_node::code_block(backing) return generate_code_block(node)
            ast_node::return_statement(backing) return generate_return_statement(node)
            ast_node::value(backing) return generate_value(node)
            ast_node::identifier(backing) return generate_identifier(node)
        }
        return string("/* COULD NOT GENERATE */")
    }
    fun type_decoration(type: *type): string {
        var indirection = string()
        for (var i = 0; i < type->indirection; i++;) indirection += "p"
        if (type->indirection) indirection += "_"
        match (type->base) {
            base_type::none() return indirection + string("none")
            base_type::template() return indirection + string("template")
            base_type::template_type() return indirection + string("template_type")
            base_type::void_return() return indirection + string("void")
            base_type::boolean() return indirection + string("bool")
            base_type::character() return indirection + string("char")
            base_type::integer() return indirection + string("int")
            base_type::floating() return indirection + string("float")
            base_type::double_precision() return indirection + string("double")
            base_type::object() {
                return type->type_def->type_def.name
            }
            base_type::function() {
                var temp = indirection + string("function_")
                type->parameter_types.for_each(fun(parameter_type: *type) temp += type_decoration(parameter_type) + "_";)
                return indirection + temp + "_" + type_decoration(type->return_type)
            }
        }
        return string("impossible type") + indirection
    }
    fun type_to_c(type: *type): string {
        var indirection = string()
        for (var i = 0; i < type->indirection; i++;) indirection += "*"
        match (type->base) {
            base_type::none() return string("none") + indirection
            base_type::template() return string("template") + indirection
            base_type::template_type() return string("template_type") + indirection
            base_type::void_return() return string("void") + indirection
            base_type::boolean() return string("bool") + indirection
            base_type::character() return string("char") + indirection
            base_type::integer() return string("int") + indirection
            base_type::floating() return string("float") + indirection
            base_type::double_precision() return string("double") + indirection
            base_type::object() {
                return type->type_def->type_def.name
            }
            base_type::function() {
                var temp = indirection + string("function: (")
                type->parameter_types.for_each(fun(parameter_type: *type) temp += parameter_type->to_string() + " ";)
                return temp + ")" + type->return_type->to_string()
            }
        }
        return string("impossible type") + indirection
    }
}