1 files changed, 122 insertions, 22 deletions

diff --git a/src/engine.c b/src/engine.c
index 944c0f4..a063520 100644
--- a/src/engine.c
+++ b/src/engine.c
@@ -10,38 +10,138 @@
 #include "uci.h"
 #include "ipc.h"
 
+// TODO: implement break conditions from the go command
+struct thread_args {
+  int id;
+  int stop;
+  position_t position;
+  struct engine_message *message;
+};
+void *engine_thread(void *_args) {
+  struct thread_args *args = (struct thread_args*)_args;
+
+  int k = 0;
+  while (k < 10) {
+    if (args->stop) continue;
+    struct engine_message *message = args->message;
+
+    k++;
+    message->depth = 69;
+    message->multipv = args->id;
+    message->pv = comm_moves_init();
+    add_comm_move(&message->pv, (struct uci_move) { 14, 24 });
+
+    if (k == 10) {
+      message->best_move = (struct uci_move) { 12, 24 };
+      message->ponder = (struct uci_move) { 42, 54 };
+    }
+
+    message->next = malloc(sizeof(struct engine_message*));
+    message->ready = 1;
+    args->message = message->next;
+  }
+}
+
+struct threads {
+  pthread_t *threads;
+  struct thread_args* args;
+  engine_messages *engine_messages;
+  size_t count;
+  size_t capacity;
+
+  position_t sharing_position;
+};
+
+void increase_threads(struct threads *threads, size_t change) {
+  if (threads->count + change > threads->capacity) {
+    threads->capacity = threads->count + change + 16; // TODO: maybe round it to the upper power of 2
+  }
+
+  threads->threads = threads->threads == NULL
+    ? malloc(sizeof(*threads->threads) * threads->capacity)
+    : realloc(threads->threads, sizeof(*threads->threads) * threads->capacity);
+
+  threads->args = threads->args == NULL
+    ? malloc(sizeof(*threads->args) * threads->capacity)
+    : realloc(threads->args, sizeof(*threads->args) * threads->capacity);
+
+  threads->engine_messages->data = threads->engine_messages->data == NULL
+    ? malloc(sizeof(*threads->engine_messages->data) * threads->capacity)
+    : realloc(
+      threads->engine_messages->data,
+      sizeof(*threads->engine_messages->data) * threads->capacity
+    );
+
+  for (int i = threads->count; i < threads->count + change; i++) {
+    threads->engine_messages->data[i] = malloc(sizeof(struct engine_message));
+    threads->engine_messages->data[i]->ready = 0;
+    threads->args[i] = (struct thread_args) {
+      i,
+      0,
+      threads->sharing_position,
+      threads->engine_messages->data[i],
+    };
+    pthread_create(
+      threads->threads + i,
+      NULL,
+      &engine_thread,
+      (void*)(threads->args + i)
+    );
+  }
+  threads->count += change;
+  threads->engine_messages->count = threads->count;
+}
+
+void decrease_threads(struct threads *threads, size_t change) {
+  for (int i = 0; i < change; i++) {
+    free(threads->engine_messages->data[threads->count - i - 1]);
+    pthread_cancel(threads->threads[threads->count - i - 1]);
+  }
+  threads->count -= change;
+  threads->engine_messages->count = threads->count;
+}
+
+void set_threads(struct threads *threads, size_t new_size) {
+  if (new_size > threads->count) {
+    increase_threads(threads, new_size - threads->count);
+  } else {
+    decrease_threads(threads, threads->count - new_size);
+  }
+}
+
+// TODO: someday fix that some structs have typedef, some dont
 int main(int argc, char** argv) {
   comms *comms = malloc(sizeof(*comms));
   comms->engine_messages = malloc(sizeof(*comms->engine_messages));
-
-  comms->engine_messages->data = malloc(
-    sizeof(*comms->engine_messages->data) * 1 // TODO: GET FROM UCI SETTINGS
-  );
-  comms->engine_messages->count = 1;
-  comms->engine_messages->data[0] = malloc(sizeof(
-    *comms->engine_messages->data[0]
-  ));
-  comms->engine_messages->data[0]->ready = 0;
-
-  printf("ENGINE: %p\nENGINE MESSAGE: %p\n", comms, comms->engine_messages);
+  comms->uci_state_initialized = 0;
 
   pthread_t uci_thread;
   pthread_create(&uci_thread, NULL, &uci, (void*)comms);
-  int k = 0;
+  
+  while (atomic_load(&comms->uci_state_initialized) == 0);
+  comms->state.quit = 0;
+
+  struct threads engine_threads = {0};
+  engine_threads.engine_messages = comms->engine_messages;
+  int initialized = 0;
+
   while (1) {
-    if (k == 0) {
-      struct engine_message *message = comms->engine_messages->data[0];
-      message->depth = 69;
-      message->pv = comm_moves_init();
-      add_comm_move(&message->pv, (struct uci_move) { 14, 24 });
-      message->next = malloc(sizeof(struct engine_message*));
-      printf("\n%p\n", message->pv.moves);
-
-      message->ready = 1;
-      k++;
+    if (atomic_load(&comms->state.quit)) break;
+    if (!atomic_load(&comms->state.go)) continue;
+
+    if (initialized == 0) {
+      engine_threads.sharing_position = comms->state.position;
+      set_threads(&engine_threads, comms->state.threads);
+      initialized = 1;
     }
   }
 
+  set_threads(&engine_threads, 0);
+  free(engine_threads.threads);
+  free(engine_threads.args);
+  free(comms->engine_messages);
+  free(comms->engine_messages->data);
+  free(comms);
   return 0;
 }