#include "../lib.h"
#include "../lib_cored.h"

#include "bh_platform.h"
#include "wasm_export.h"

#include "__WASM_ARRAY_FILE__"

void fail_start_trace(void) {}
void fail_stop_trace(void) {}
void fail_marker_positive(void) {}
void fail_marker_negative(void) {}
void fail_marker_detected(void) {}

void fail_start_trace_wasm(wasm_exec_env_t exec_env) {}
void fail_stop_trace_wasm(wasm_exec_env_t exec_env) {}
void fail_marker_positive_wasm(wasm_exec_env_t exec_env) {}
void fail_marker_negative_wasm(wasm_exec_env_t exec_env) {}
void fail_marker_detected_wasm(wasm_exec_env_t exec_env) {}

#define STACK_SIZE (4 * 1024)
#define HEAP_SIZE STACK_SIZE
#define RUNTIME_POOL_SIZE 4 * STACK_SIZE

void os_main() {
  char error_buf[128];

  /* initialize the wasm runtime */
  static char global_heap_buf[RUNTIME_POOL_SIZE];
  static RuntimeInitArgs init_args;
  memset(&init_args, 0, sizeof(RuntimeInitArgs));

  init_args.mem_alloc_type = Alloc_With_Pool;
  init_args.mem_alloc_option.pool.heap_buf = global_heap_buf;
  init_args.mem_alloc_option.pool.heap_size = sizeof(global_heap_buf);
  init_args.max_thread_num = 1;
  if (!wasm_runtime_full_init(&init_args)) {
    return;
  }

  static NativeSymbol native_symbols[] = {
      {"fail_start_trace", fail_start_trace_wasm, "()"},
      {"fail_stop_trace", fail_stop_trace_wasm, "()"},
      {"fail_marker_positive", fail_marker_positive_wasm, "()"},
      {"fail_marker_negative", fail_marker_negative_wasm, "()"},
      {"fail_marker_detected", fail_marker_detected_wasm, "()"},
  };
  int n_native_symbols = sizeof(native_symbols) / sizeof(NativeSymbol);
  if (!wasm_runtime_register_natives("env", native_symbols, n_native_symbols)) {
    return;
  }

  /* parse the WASM file from buffer and create a WASM module */
  wasm_module_t module = wasm_runtime_load(__WASM_ARRAY__, __WASM_ARRAY_LEN__,
                                           error_buf, sizeof(error_buf));

  if (!module) {
    return;
  }

  /* create an instance of the WASM module (WASM linear memory is ready) */
  wasm_module_inst_t module_inst = wasm_runtime_instantiate(
      module, STACK_SIZE, HEAP_SIZE, error_buf, sizeof(error_buf));

  if (!module_inst) {
    return;
  }

  // Single exec_env for all functions (probably'd need a single one per
  // thread?)
  wasm_exec_env_t exec_env =
      wasm_runtime_create_exec_env(module_inst, STACK_SIZE);
  uint32_t args[FILTER_COUNT];

  // Place encoded input values for cored voter.
  // They'll be broken by FAIL* on read, so I don't need to inject this (?)
  // fail_start_trace();
  wasm_function_inst_t init_func =
      wasm_runtime_lookup_function(module_inst, "init_outputs");
  args[0] = 100;
  args[1] = 142;
  args[2] = 100;
  if (!wasm_runtime_call_wasm(exec_env, init_func, 3, args)) {
    return;
  }

  // CoRed vote
  wasm_function_inst_t func =
      wasm_runtime_lookup_function(module_inst, "wasm_module");
  args[0] = 0;
  args[1] = 0;
  args[2] = 0;
  fail_start_trace();
  if (!wasm_runtime_call_wasm(exec_env, func, 0, args)) {
    return;
  }
  fail_stop_trace();
  sign_t static_sig = args[0];

  // Obtain dynamic signature produced by CoRed
  wasm_function_inst_t cored_res_func =
      wasm_runtime_lookup_function(module_inst, "get_cored_res");
  args[0] = 0;
  args[1] = 0;
  args[2] = 0;
  if (!wasm_runtime_call_wasm(exec_env, cored_res_func, 0, args)) {
    return;
  }
  enc_t cored_res = args[0];

  sign_t vote_result_sig;
  switch (static_sig) {
  case SIG_s_XYZ:
  case SIG_s_XY:
  case SIG_s_XZ:
    vote_result_sig = SIG_X;
    break;
  case SIG_s_YZ:
    vote_result_sig = SIG_Y;
    break;
  default:
    // printf("ERROR: Unknown static_sig %d\n", static_sig);
    break;
  }

  // Inversely apply constant program flow signature.
  // printf("Inversely apply: cored_res=%d static_sig=%d\n", cored_res,
  //        static_sig);
  cored_res -= static_sig;

  /* Validate Vote result */
  // printf(
  //     "Validating vote result: cored_res=%d THE_A=%d vote_result_sig = % d\n
  //     ", cored_res, THE_A, vote_result_sig);
  if (!check(cored_res, THE_A, vote_result_sig)) {
    // printf("Validation failed :(\n");
    fail_marker_detected();
    return;
  }

  plain_t res = decode(cored_res, THE_A, vote_result_sig);
  // printf("Decoded result: %d (%f)\n", res, q_to_float(res));
  if (res == 100) {
    fail_marker_positive();
  } else {
    fail_marker_negative();
  }

  wasm_runtime_destroy_exec_env(exec_env);
  wasm_runtime_deinstantiate(module_inst);
  wasm_runtime_unload(module);
  wasm_runtime_destroy();

  return;
}