import io:*
import grammer:*
import parser:*
import ast_transformation:*
import string:*
import util:*
import symbol:*
import tree:*
import serialize:*
import c_generator:*
import os:*
import compiler_version


fun main(argc: int, argv: **char):int {
    if (argc <= 1) {
        error("No input file!\n Call with one argument (the input file), or two arguments (input file and output name)")
    } else if (string(argv[1]) == "-v" || string(argv[1]) == "--version") {
        println(compiler_version::version_string)
        exit(0)
    }
    /*var gram.construct(): grammer*/
    // delay construction until we either load it or copy construct it
    var gram: grammer
    var base_dir = string("/").join(string(argv[0]).split('/').slice(0,-2))
    /*println(base_dir)*/
    var file_name = base_dir + "/krakenGrammer.kgm"
    /*println(file_name)*/

    var compiled_name = file_name + string(".comp_new")
    var compiled_version = 1
    var file_contents = read_file(file_name)
    var loaded_and_valid = false

    if (file_exists(compiled_name)) {
        /*println("cached file exists")*/
        var pos = 0
        var binary = read_file_binary(compiled_name)
        /*println("read file!")*/
        var saved_version = 0
        unpack(saved_version, pos) = unserialize<int>(binary, pos)
        if (saved_version == compiled_version) {
            var cached_contents = string()
            unpack(cached_contents, pos) = unserialize<string>(binary, pos)
            if (cached_contents == file_contents) {
                /*println("loaded_and_valid, using cached version!")*/
                loaded_and_valid = true
                /*unpack(gram, pos) = unserialize<grammer>(binary, pos)*/
                // skip unnecessary copies this way
                pos = gram.unserialize(binary, pos)
                /*println("finished unserializeing!!")*/
            } else println("contents different")
        } else println("version number different")
    } else {
        println("cached file does not exist")
    }
    if (!loaded_and_valid) {
        println("Not loaded_and_valid, re-generating and writing out")
        /*gram = load_grammer(file_contents)*/
        // since we now don't construct before hand
        gram.copy_construct(&load_grammer(file_contents))
        println("grammer loaded, calculate_first_set")
        gram.calculate_first_set()
        println("grammer loaded, calculate_state_automaton")
        gram.calculate_state_automaton()
        println("calculated, writing out")
        write_file_binary(compiled_name, serialize(compiled_version) + serialize(file_contents) + serialize(gram))
        println("done writing")
    }

    var kraken_file_name = string(argv[1])
    var parse.construct(gram): parser
    var ast_pass.construct(): ast_transformation
    var importer.construct(parse, ast_pass, vector(string(), base_dir + "/stdlib/")): importer
    /*print("parsing: ")*/
    importer.import(kraken_file_name)
    println("Generating C")
    /*println("NOW DOING C_GENERATOR")*/
    var c_generator.construct(): c_generator
    var c_output_pair = c_generator.generate_c(importer.name_ast_map)
    var kraken_c_output_name = kraken_file_name + ".c"
    write_file(kraken_c_output_name, c_output_pair.first)
    /*println(string("linker string: ") + c_output_pair.second)*/

    var executable_name = string(".").join(kraken_file_name.split('.').slice(0,-2))
    if (argc == 3)
        executable_name = string(argv[2])
    var compile_string = "cc -g -O3 -std=c99 " + c_output_pair.second + " " + kraken_c_output_name + " -o " + executable_name
    println(compile_string)
    system(compile_string)

    return 0
}