#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>

#include "ipc/state.h"
#include "ipc/threads.h"
#include "ipc/uci.h"
#include "engine/ttable.h"
#include "engine/magic.h"

void *uci_thread_func(void* data) {
  ipc_state_t *state = (ipc_state_t*)data;
  return uci(state);
}

int main(int argc, char** argv) {
  magic_init();
  zobrist_init();

  ipc_state_t ipc_state;
  ipc_state_init(&ipc_state);

  pthread_t uci_thread;
  pthread_create(&uci_thread, NULL, uci_thread_func, (void*)&ipc_state);

  struct threads engine_threads = {0};
  threads_init(&engine_threads, ipc_state.uci_state.threads);
  threads_link(&engine_threads, &ipc_state);

  engine_messages_init(&ipc_state.engine_messages);
  goto skip_refresh;
waiting_for_go:
  engine_messages_refresh(&ipc_state.engine_messages);
skip_refresh:
  bool is_stop, quit;
  while (
    !ipc_state_is_event(&ipc_state, EVENT_ENGINE_GO) &&
    !(quit = ipc_state_is_event(&ipc_state, EVENT_QUIT))
  );
  if (quit) goto quit;

  engine_threads.running_count = ipc_state.uci_state.threads;
  ipc_state.engine_messages.count = ipc_state.uci_state.threads;
  threads_reserve(&engine_threads, engine_threads.running_count);
  threads_go(&engine_threads);

  ipc_state_set_event(&ipc_state, EVENT_UCI_RUNNING);

  while (1) {
    while (
      !ipc_state_is_event(&ipc_state, EVENT_ENGINE_RUNNING) &&
      !(quit = ipc_state_is_event(&ipc_state, EVENT_QUIT)) &&
      !(is_stop = ipc_state_is_event(&ipc_state, EVENT_ENGINE_STOP))
    );
    if (quit) {
      break;
    }
    if (is_stop) {
      threads_cleanup(&engine_threads);
      ipc_state_set_event(&ipc_state, EVENT_UCI_RUNNING);
      goto waiting_for_go;
    }
    threads_go_loop(&engine_threads);
    ipc_state_set_event(&ipc_state, EVENT_UCI_RUNNING);
  }

quit:
  ipc_state_deinit(&ipc_state);
  pthread_cancel(uci_thread);
  threads_deinit(&engine_threads);
  return 0;
}

#include "fen.c"
#include "bitboard.c"
#include "random.c"