#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/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();

  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:
  ipc_state_wait_for_event(&ipc_state, EVENT_ENGINE_GO);

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

  ipc_state_set_event(&ipc_state, EVENT_UCI_RUNNING);

  bool is_stop;
  while (1) {
    while (
      !ipc_state_is_event(&ipc_state, EVENT_ENGINE_RUNNING) &&
      !(is_stop = ipc_state_is_event(&ipc_state, EVENT_ENGINE_STOP))
    );
    if (is_stop) {
      printf("ENDED\n");
      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);
    // if (atomic_load(&ipc_state->state.quit)) break;
    // if (atomic_load(&ipc_state->state.cleanup)) {
    //   set_threads(&engine_threads, 0);
    //   for (int i = 0; i < engine_threads.count; i++) {
    //     engine_threads.args[i].stop = -1;
    //   }
    // }
    // if (atomic_load(&ipc_state->state.go)) {
    //   printf("going\n");
    //   engine_threads.sharing_position = ipc_state->state.position;
    //   engine_threads.go_args = (struct go_args*)ipc_state->state.go_args;
    //   set_threads(&engine_threads, ipc_state->state.threads);
    //   atomic_store(&ipc_state->state.go, 0);
    //   atomic_store(&ipc_state->state.go_ready_receive, 1);
    // }
    // if (atomic_load(&ipc_state->state.stop)) {
    //   printf("stopping\n");
    //   send_stop_signal(&engine_threads);
    //   if (!all_stopped(&engine_threads)) continue;
    //   set_threads(&engine_threads, 0);
    //   for (int i = 0; i < engine_threads.count; i++) {
    //     engine_threads.args[i].stop = -1;
    //   }
    //   atomic_store(&ipc_state->state.stop, 0);
    // }
  }

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

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