#module_parameters(disable := false, loc := #caller_location);

Status :: enum {
   none;
   quit;
   soft_reload;
   hard_reload;
}

Init_Proc     :: #type (*void, Allocator, bool);
Setup_Proc    :: #type ();
Teardown_Proc :: #type ();
Frame_Proc    :: #type () -> Status;


#scope_module;

#placeholder frame;
#placeholder init;
#placeholder setup;
#placeholder teardown;

// Ensure laptops use the higher performance GPU on Windows.
#if OS == .WINDOWS {
   /*
   https://docs.nvidia.com/gameworks/content/technologies/desktop/optimus.htm

   Starting with the Release 302 drivers, application developers can direct the Optimus driver at runtime to use the High Performance Graphics to render any application —- even those applications for which there is no existing application profile. They can do this by exporting a global variable named NvOptimusEnablement. The Optimus driver looks for the existence and value of the export. Only the LSB of the DWORD matters at this time. A value of 0x00000001 indicates that rendering should be performed using High Performance Graphics. A value of 0x00000000 indicates that this method should be ignored.
   */
   #program_export NvOptimusEnablement: u32 = 0x00000001;

   /*
   https://gpuopen.com/learn/amdpowerxpressrequesthighperformance/

   Many gaming and workstation laptops are available with both (1) integrated power saving and (2) discrete high performance graphics devices. Unfortunately, 3D intensive application performance may suffer greatly if the best graphics device is not selected. For example, a game may run at 30 Frames Per Second (FPS) on the integrated GPU rather than the 60 FPS the discrete GPU would enable. As a developer you can easily fix this problem by adding only one line to your executable's source code:
   */
   #program_export AmdPowerXpressRequestHighPerformance: u32 = 0x00000001;
}

#if !disable {
   #load "reload_main.jai";
}


#scope_file;

#assert (type_of(init)     == Init_Proc) "init was the wrong type!";
#assert (type_of(setup)    == Setup_Proc) "setup was the wrong type!";
#assert (type_of(teardown) == Teardown_Proc) "teardown was the wrong type!";
#assert (type_of(frame)    == Frame_Proc) "frame was the wrong type!";

file_path   :: #run -> string { return loc.fully_pathed_filename; }
proj_path   :: #run -> string { return path_strip_filename(file_path); }
temp_path   :: #run -> string { return tprint("%/.build/tmp.jai", proj_path); };
temp_exists :: #run -> bool   { return file_exists(temp_path); }

// only run the build when we the module importing us is compiled
#if !(disable || temp_exists) #run {
   set_build_options_dc(.{ do_output = false });

   make_directory_if_it_does_not_exist(".build");

   out_path := path_strip_extension(proj_path);
   out_name := path_strip_extension(path_filename(file_path));

   // build target executable
   {
      ws := compiler_create_workspace(file_path);
      defer compiler_destroy_workspace(ws);

      opts := get_build_options(ws);
      opts.text_output_flags = 0;
      opts.output_path = out_path;
      opts.output_type = .EXECUTABLE;
      opts.output_executable_name = out_name;

      tmp: String_Builder;
      print_to_builder(*tmp, #string END
         #load "%1";

         main :: () {
            (#import "jx/reload").reload_main();
         }
      END, file_path);

      assert(write_entire_file(temp_path, builder_to_string(*tmp)));

      compiler_begin_intercept(ws);
      set_build_options(opts, ws);

      add_build_file(temp_path, ws);
      while true {
         msg := compiler_wait_for_message();
         if msg.kind == .COMPLETE || msg.kind == .ERROR break;
      }
      compiler_end_intercept(ws);
   }

   // build library
   {
      ws := compiler_create_workspace(file_path);
      defer compiler_destroy_workspace(ws);

      opts := get_build_options(ws);
      opts.output_path = out_path;
      opts.output_type = .DYNAMIC_LIBRARY;
      opts.output_executable_name = "lib";

      compiler_begin_intercept(ws);
      set_build_options(opts, ws);

      add_build_file(temp_path, ws);
      while true {
         msg := compiler_wait_for_message();
         if msg.kind == .COMPLETE || msg.kind == .ERROR break;
      }
      compiler_end_intercept(ws);
   }

   file_delete(temp_path);
}

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