AT_COMPILE_TIME :: true;

SOURCE_PATH :: "src";
LIB_BASE_NAME :: "stb_rect_pack";

#if AT_COMPILE_TIME {
    #run,stallable {
        set_build_options_dc(.{do_output=false});
        options := get_build_options();
        args := options.compile_time_command_line;
        if !generate_bindings(args, options.minimum_os_version) {
            compiler_set_workspace_status(.FAILED);
        }
    }
} else {
    #import "System";

    main :: () {
        set_working_directory(path_strip_filename(get_path_of_running_executable()));
        if !generate_bindings(get_command_line_arguments(), #run get_build_options().minimum_os_version) {
            exit(1);
        }
    }
}

generate_bindings :: (args: [] string, minimum_os_version: type_of(Build_Options.minimum_os_version)) -> bool {
    os_target  := OS;
    cpu_target := CPU;

    target_android := array_find(args, "-android");
    target_arm     := array_find(args, "-arm64");
    compile        := array_find(args, "-compile");
    compile_debug  := array_find(args, "-debug");

    if target_android {
        os_target = .ANDROID;
    }
    if target_arm {
        cpu_target = .ARM64;
    }

    output_filename := "bindings.jai"; // The only difference between platforms is windows defaults enums to s32, unix to u32 but its fine.
    lib_directory: string;
    if os_target == {
        case .WINDOWS;
            lib_directory = "windows";
        case .LINUX;
            lib_directory = "linux";
        case .MACOS;
            // @Incomplete: do Arm64
            lib_directory = "macos";
        case .ANDROID;
            lib_directory = ifx cpu_target == .X64 then "android/x64" else "android/arm64";
        case;
            assert(false);
    }

    if compile {
        source_file := tprint("%/stb_rect_pack.c", SOURCE_PATH);

        make_directory_if_it_does_not_exist(lib_directory, recursive = true);
        lib_path := tprint("%/%", lib_directory, LIB_BASE_NAME);
        extra: [] string;
        if os_target == {
            case .WINDOWS;
                extra = .["/MD"];
            case .MACOS;
                // @Incomplete: do Arm64
                macos_version_arg := tprint("-mmacos-version-min=%.%", minimum_os_version.major, minimum_os_version.minor);
                extra = .[macos_version_arg];
            case .ANDROID;
                _, target_triple_with_sdk := get_android_target_triple(cpu_target);
                extra = .["-target", target_triple_with_sdk];
        }

        success := true;
        //success &&= build_cpp_dynamic_lib(lib_path, source_file, target = os_target, debug = compile_debug, extra = extra);
        success &&= build_cpp_static_lib(lib_path, source_file, target = os_target, debug = compile_debug, extra = extra);

        if !success     return false;
    }

    options: Generate_Bindings_Options;
    options.os = os_target;
    options.cpu = cpu_target;
    {
        using options;

        array_add(*libpaths, lib_directory);
        array_add(*libnames, LIB_BASE_NAME);
        array_add(*source_files, tprint("%/stb_rect_pack.h", SOURCE_PATH));
        array_add(*typedef_prefixes_to_unwrap, "stbi_");

        generate_library_declarations = false;
        footer = tprint(FOOTER_TEMPLATE, LIB_BASE_NAME);

        auto_detect_enum_prefixes = true;
        log_stripped_declarations = false;
        generate_compile_time_struct_checks = false;
    }

    return generate_bindings(options, output_filename);
}

FOOTER_TEMPLATE :: #string END

#if OS == .WINDOWS {
    %1 :: #library,no_dll "windows/%1";
} else #if OS == .LINUX {
    %1 :: #library "linux/%1";
} else #if OS == .MACOS {
    %1 :: #library "macos/%1";
} else #if OS == .ANDROID {
    #if CPU == .X64 {
        %1 :: #library "android/x64/%1";
    } else #if CPU == .ARM64 {
        %1 :: #library "android/arm64/%1";
    }
} else {
    #assert false;
}

END

#import "Toolchains/Android";
#import "Basic";
#import "BuildCpp";
#import "Bindings_Generator";
#import "Compiler";
#import "File";