#import "Basic";
#import "String";
#import "Compiler";
#import "File";
#import "File_Utilities";
#import "Autorun";



// ----------------------------------------
// config
// ------


// For a template example, visit `templates/minimal/rules_minimal.jai`


// Which template should be used by default
// (You can list all templates with `jinit -l`)
SET_DEFAULT_TEMPLATE :: "arg";


// You can include this "marker" in your templates/rules
// and replace them at runtime with `jinit -t <template> -r <your new string>`
SET_RENAME_MARKER :: "__RENAME_PLACEHOLDER__";


// If you don't use a SCM, you can turn it off here
SET_SCM_IS_TURNED_OFF :: false;


// Define the initializing commands for your SCM
SET_SCM_COMMANDS :: string.[ "git", "init" ];


// [ ! IMPORTANT ! ]: Some SCMs define a directory where they store all refs
//                    and other internals.
//                    You have to set the directory name here, otherwise it
//                    will overwrite your SCM repository at every invocation!
SET_SCM_DOT_DIR :: ".git";


SET_BUILD_FILE_NAME :: "build.jai";

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


#placeholder TEMPLATES_AND_RULES;
#placeholder TR_EXEC_BUF_MAX;
#placeholder TR_EXEC_BODY;
#placeholder DEFAULT_TEMPLATE;
#placeholder BUILD_FN;
#placeholder SCM_IS_TURNED_OFF;
#placeholder SCM_COMMANDS;
#placeholder SCM_DOT_DIR;
#placeholder RENAME_MARKER;

TEMPLATE_DIR :: "templates";


build :: () {
    args := get_build_options().compile_time_command_line;

    // args
    args_help               := array_find(args, "help");
    args_compiler_silent    := array_find(args, "silent");
    args_program_run        := array_find(args, "run");
    args_build_release      := array_find(args, "release");

    // program args
    program_args := program_args_collect(args);
    defer array_free(program_args);

    // -----------------------------------------
    w := compiler_create_workspace();

    if !w {
        log("Workspace creation failed.");
        return;
    }

    set_build_options_dc(.{ do_output = false });

    if args_help {
        args_help_print();
        return;
    }


    print("The workspace w is %\n", w);
    make_directory_if_it_does_not_exist("bin");
    make_directory_if_it_does_not_exist("bin/debug");
    make_directory_if_it_does_not_exist("bin/release");

    target_options := get_build_options(w);
    target_options.output_executable_name = "jinit";

    if args_compiler_silent  target_options.text_output_flags = 0;

    if args_build_release {
        build_release(w, *target_options);
    } else {
        build_debug(w, *target_options);
    }


    compiler_begin_intercept(w);
    add_build_file(tprint("%src/main.jai", #filepath), w);

    template_rules := template_rules_find();
    defer array_free(template_rules);
    template_rules_inject(template_rules, w);

    add_build_string(
        tprint("RENAME_MARKER :: \"%\";", SET_RENAME_MARKER),
        w
    );

    add_build_string(
        tprint("SCM_IS_TURNED_OFF :: %;", SET_SCM_IS_TURNED_OFF),
        w
    );

    add_build_string(
        tprint("SCM_COMMANDS :: %.%;", "string", SET_SCM_COMMANDS),
        w
    );

    #assert(SET_SCM_DOT_DIR) "[ERR]: NO SCM REF DIRECTORY IS SET!";

    add_build_string(
        tprint("SCM_DOT_DIR :: \"%\";", SET_SCM_DOT_DIR),
        w
    );

    add_build_string(
        tprint("BUILD_FN :: \"%\";", SET_BUILD_FILE_NAME),
        w
    );

    add_build_string(
        tprint("DEFAULT_TEMPLATE :: \"%\";", SET_DEFAULT_TEMPLATE),
        w
    );

    compiler_response := compiler_message();
    compiler_end_intercept(w);

    if !compiler_response {
        log("Compiler response failed.");
        return;
    }

    if args_program_run  run_build_result_of_workspace(w, program_args);
}


build_debug :: (w: Workspace, target_options: *Build_Options) {
    log("Choosing debug options...");
    target_options.backend =.X64;
    target_options.output_path = "bin/debug";
    set_optimization(target_options, Optimization_Type.DEBUG, true);
    set_build_options(target_options.*, w);
}

build_release :: (w: Workspace, target_options: *Build_Options) {
    log("Choosing release options...");
    target_options.backend = .LLVM;
    target_options.output_path = "bin/release";
    set_optimization(target_options, Optimization_Type.VERY_OPTIMIZED);
    set_build_options(target_options.*, w);
}


args_help_print :: () {
    help_message := #string _END_
Usage:  jai build.jai - [ARGS]

Options:
    help        Prints this help menu
    silent      Disables compiler/linker statistics
    run         Runs your program afterwards
    release     Builds with release options. If omitted, it builds a debug build.

Passing Args to your Program:
    If you want to supply args to your program, pass it like that:

        `jai build.jai - run :: my_arg1 foo bar abc ABC`

    Everything after the `::` get's forwarded to your program.

_END_;
    log(help_message);
}

compiler_message :: () -> success: bool {
    while true {
        message := compiler_wait_for_message();
        if !message break;
        if message.kind == {
        case .COMPLETE;
            message_complete := cast(*Message_Complete) message;
            return message_complete.error_code == 0;
        }
    }
    return false;
}

program_args_collect :: (args: []string, divider: string = "::") -> [..]string {
    buf: [..]string;

    success, match := array_find(args, divider);
    if success  for i: match+1..args.count-1  array_add(*buf, args[i]);

    return buf;
}

template_rules_find :: () -> [..]string {
    templates: [..]string;

    collect_template_files :: (using info: *File_Visit_Info, templates: *[..]string) {
        if starts_with(short_name, "rules_") && ends_with(short_name, ".jai") {
            content, success := read_entire_file(full_name);

            if !success {
                log("Cannot read file: %", full_name);
                exit(1);
            }

            array_add(templates, content);
        }
    }

    complete := visit_files(
        TEMPLATE_DIR,
        recursive = true,
        *templates, collect_template_files,
        visit_files = true
    );

    assert(complete, "Some error occured while traversing the file tree");
    return templates;
}

template_rules_inject :: (templates: [..]string, w: Workspace) {
    count := templates.count;

    inject_proc_body :: () #expand {
        add_build_string(tprint("TR_EXEC_BUF_MAX :: %;", count), `w);

        sb: String_Builder;
        init_string_builder(*sb);

        template_arr :: "buf[%1] = #insert,scope(FILE_SCOPE) TEMPLATES_AND_RULES[%2]; ";
        template_creator :: "buf[%1].template = create_template(buf[%2].template); ";

        for i: 0..count-1 {
            append(*sb, tprint(template_arr, i, i));
            append(*sb, tprint(template_creator, i, i));
        }

        tr_exec_body := builder_to_string(*sb);
        s := trim(tr_exec_body,, temp);

        add_build_string(tprint("TR_EXEC_BODY :: \"%\";", s), `w);
    }

    inject_rules_array :: () #expand {
        sb: String_Builder;
        init_string_builder(*sb);

        append(*sb, "string.");

        escaped: [..]string;
        escaped.allocator = temp;

        for templates {
            array_add(*escaped, replace(it, "\"", "\\\""));
        }

        append(*sb, tprint("%", escaped));
        append(*sb, ";");

        s := builder_to_string(*sb);
        st := trim(s,, temp);

        add_build_string(tprint("TEMPLATES_AND_RULES :: %;", st), `w);
    }

    inject_proc_body();
    inject_rules_array();
}


main :: () {}

#run build();