#ifndef _STB_CB_H
#define _STB_CB_H
#include <openssl/md5.h> // Requires OpenSSL
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

//============================= arglist.h
//=======================================
typedef struct {
  char **list;
  int count;
  int capacity;
} CB_ARGLIST;

static inline CB_ARGLIST *arglist_new();
static inline void arglist_append(CB_ARGLIST *arglist, ...); // sentinel: NULL
static inline void arglist_append_array(CB_ARGLIST *arglist, const char **arr);
static inline void arglist_free(CB_ARGLIST *arglist);

//============================= platform & macros
//===============================
#if defined(_WIN32)
#define OS_WIN 1
#include <process.h>
#include <windows.h>
#else
#define OS_UNIX 1
#include <sys/wait.h>
#include <unistd.h>
#endif

#if defined(__APPLE__)
#define OS_MACOS 1
#endif

#ifdef CB_DEBUG
#define CB_DEBUG_LOG(fmt, ...)                                                 \
  fprintf(stderr, "\x1b[36m[DEBUG] %s:%d: " fmt "\x1b[0m\n", __FILE__,         \
          __LINE__, ##__VA_ARGS__)
#else
#define CB_DEBUG_LOG(fmt, ...)
#endif

#if OS_UNIX
#include <ctype.h>
#include <errno.h>
#include <glob.h>
#include <limits.h>
#include <sys/types.h>
#endif

// Allow override by macro or environment
#ifndef CB_COMPILER
#if OS_WIN
#define COMPILER_NAME_DEFAULT "cl"
#elif defined(OS_MACOS)
#define COMPILER_NAME_DEFAULT "clang"
#else
#define COMPILER_NAME_DEFAULT "cc"
#endif
#else
#define COMPILER_NAME_DEFAULT CB_COMPILER
#endif

#define COLOR_RESET "\x1b[0m"
#define COLOR_RED "\x1b[31m"
#define COLOR_GREEN "\x1b[32m"
#define COLOR_YELLOW "\x1b[33m"
#define COLOR_CYAN "\x1b[36m"

typedef enum { BUILD_EXEC, BUILD_STATIC, BUILD_SHARED } _CB_BUILD_TYPE;

typedef struct _CB_PROJECT {
  char *name;
  char *output;
  CB_ARGLIST *files; // may contain wildcard patterns; expanded before build
  CB_ARGLIST *buildflags;
  CB_ARGLIST *flags;
  char *compile_command;
  int is_rebuild;
  _CB_BUILD_TYPE build_type;
  int CB_PYTHON;
} _CB_PROJECT;

typedef struct {
  _CB_PROJECT **projects;
  int run;            // run produced outputs?
  int run_if_skipped; // run even if build skipped (cache hit)
  int parallel_build; // NEW: number of parallel build jobs
  int parallel_run;   // NEW: number of parallel run jobs
  int parallel; // DEPRECATED: kept for back-compat; treated as parallel_run if
                // >0
} CB_PROJECT_BUILD_CONFIG;

#define CB_STRLIST(...) ((const char *[]){__VA_ARGS__, NULL})
#define CB_PROJECT_LIST(...) ((_CB_PROJECT *[]){__VA_ARGS__, NULL})

#define _CB_CREATE_PROJECT(var, ...)                                           \
  _CB_PROJECT *var = (_CB_PROJECT *)malloc(sizeof(_CB_PROJECT));               \
  if (!(var)) {                                                                \
    fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET);                    \
    exit(1);                                                                   \
  }                                                                            \
  memset(var, 0, sizeof(_CB_PROJECT));                                         \
  struct {                                                                     \
    char *name;                                                                \
    char *output;                                                              \
    const char **files;                                                        \
    const char **buildflags;                                                   \
    const char **flags;                                                        \
    int is_rebuild;                                                            \
    _CB_BUILD_TYPE build_type;                                                 \
    int CB_PYTHON;                                                             \
  } var##_init = {__VA_ARGS__};                                                \
  var->name = var##_init.name;                                                 \
  var->output = var##_init.output;                                             \
  var->files = arglist_new();                                                  \
  var->buildflags = arglist_new();                                             \
  var->flags = arglist_new();                                                  \
  var->is_rebuild = var##_init.is_rebuild;                                     \
  var->build_type = var##_init.build_type;                                     \
  var->CB_PYTHON = var##_init.CB_PYTHON;                                       \
  if (var##_init.files)                                                        \
    arglist_append_array(var->files, var##_init.files);                        \
  if (var##_init.buildflags)                                                   \
    arglist_append_array(var->buildflags, var##_init.buildflags);              \
  if (var##_init.flags)                                                        \
  arglist_append_array(var->flags, var##_init.flags)

#define CB_NEEDED_LIBS "-lssl -lcrypto"

// — forward decls —
static char *cb_concat_compile_command(_CB_PROJECT *proj);
#define _CB_BUILD_COMPILE_COMMAND(proj)                                        \
  do {                                                                         \
    if ((proj)->compile_command) {                                             \
      free((proj)->compile_command);                                           \
    }                                                                          \
    (proj)->compile_command = cb_concat_compile_command(proj);                 \
  } while (0)

static void cb_dump_to_console(const _CB_PROJECT *project);
static void cb_free_project(_CB_PROJECT *project);
static char *cb_compute_md5(const char *data, size_t len);
static char *cb_read_file_content(const char *filepath, size_t *out_len);
static char *cb_compute_project_checksum(_CB_PROJECT *proj);
static char *cb_read_checksum(const char *filename);
static int cb_write_checksum(const char *filename, const char *checksum);
static void cb_expand_project_wildcards(_CB_PROJECT *proj); // NEW

typedef struct {
#if OS_WIN
  PROCESS_INFORMATION pi;
#else
  pid_t pid;
#endif
  int running;
  _CB_PROJECT *project;
  int is_build;
} proc_t;

static int proc_start_run(proc_t *proc, _CB_PROJECT *proj, char **argv);
static int proc_start_build_cmd(proc_t *proc, _CB_PROJECT *proj,
                                const char *cmdline);
static int proc_poll(proc_t *proc);
static void proc_wait_all(proc_t *procs, int count);

#define _CB_PROJECT_BUILD(...)                                                 \
  _cb_project_build_internal((CB_PROJECT_BUILD_CONFIG){__VA_ARGS__})
static void _cb_project_build_internal(CB_PROJECT_BUILD_CONFIG config);

#define _CB_IMPLEMENTATION
//============================= implementation
//==================================
#ifdef _CB_IMPLEMENTATION

//---------- small utils ----------
static char *cb_strdup(const char *s) {
  if (!s)
    return NULL;
  size_t n = strlen(s) + 1;
  char *p = (char *)malloc(n);
  if (!p) {
    fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET);
    exit(1);
  }
  memcpy(p, s, n);
  return p;
}
static void *cb_realloc(void *p, size_t sz) {
  void *q = realloc(p, sz);
  if (!q) {
    fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET);
    exit(1);
  }
  return q;
}
static int cb_str_has_wildcards(const char *s) {
  if (!s)
    return 0;
  for (; *s; ++s) {
    if (*s == '*' || *s == '?' || *s == '[')
      return 1;
#if OS_WIN
      // Windows doesn't support [...] in FindFirstFile, but treat it as pattern
      // anyway
#endif
  }
  return 0;
}

// Growable string builder append
static void cb_strcatf(char **dst, size_t *cap, size_t *len, const char *fmt,
                       ...) {
  va_list ap;
  for (;;) {
    va_start(ap, fmt);
    int need = vsnprintf((*dst) ? *dst + *len : NULL, (*dst) ? *cap - *len : 0,
                         fmt, ap);
    va_end(ap);
    if (need < 0) { // encoding error
      return;
    }
    size_t req = (size_t)need;
    if ((*dst) && *len + req < *cap) {
      *len += req;
      return;
    }
    size_t newcap = (*cap ? *cap : 64);
    while (newcap <= *len + req)
      newcap *= 2;
    *dst = (char *)cb_realloc(*dst, newcap);
    if (*cap == 0) {
      (*dst)[0] = '\0';
    }
    *cap = newcap;
  }
}

//---------- arglist ----------
static inline CB_ARGLIST *arglist_new() {
  CB_ARGLIST *a = (CB_ARGLIST *)malloc(sizeof(CB_ARGLIST));
  if (!a) {
    fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET);
    exit(1);
  }
  a->count = 0;
  a->capacity = 8;
  a->list = (char **)malloc(sizeof(char *) * a->capacity);
  if (!a->list) {
    fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET);
    exit(1);
  }
  return a;
}
static void arglist__ensure(CB_ARGLIST *a, int need) {
  if (a->count + need <= a->capacity)
    return;
  while (a->count + need > a->capacity)
    a->capacity *= 2;
  a->list = (char **)cb_realloc(a->list, sizeof(char *) * a->capacity);
}
static inline void arglist_append(CB_ARGLIST *arglist, ...) {
  if (!arglist)
    return;
  va_list args;
  va_start(args, arglist);
  for (;;) {
    char *arg = va_arg(args, char *);
    if (!arg)
      break;
    arglist__ensure(arglist, 1);
    arglist->list[arglist->count++] = cb_strdup(arg);
  }
  va_end(args);
}
static inline void arglist_append_array(CB_ARGLIST *arglist, const char **arr) {
  if (!arglist || !arr)
    return;
  for (int i = 0; arr[i] != NULL; i++) {
    arglist_append(arglist, arr[i], NULL);
  }
}
static inline void arglist_free(CB_ARGLIST *arglist) {
  if (!arglist)
    return;
  for (int i = 0; i < arglist->count; i++)
    free(arglist->list[i]);
  free(arglist->list);
  free(arglist);
}

//---------- compiler selection ----------
static const char *cb_pick_compiler_name(void) {
  const char *env = getenv("CB_CC");
  if (env && env[0])
    return env;
  return COMPILER_NAME_DEFAULT;
}

//---------- wildcard expansion ----------
static void cb_files_add(CB_ARGLIST *files, const char *s) {
  arglist_append(files, s, NULL);
}

#if OS_WIN
static void cb_expand_pattern_win(CB_ARGLIST *out, const char *pattern) {
  // Split directory part to preserve prefix
  char dir[MAX_PATH];
  const char *slash = strrchr(pattern, '\\');
  const char *slash2 = strrchr(pattern, '/');
  const char *cut = slash ? slash : slash2;
  size_t dlen = 0;
  if (cut) {
    dlen = (size_t)(cut - pattern + 1);
    if (dlen >= sizeof(dir))
      dlen = sizeof(dir) - 1;
    memcpy(dir, pattern, dlen);
    dir[dlen] = '\0';
  } else {
    dir[0] = '\0';
  }

  WIN32_FIND_DATAA fd;
  HANDLE h = FindFirstFileA(pattern, &fd);
  if (h == INVALID_HANDLE_VALUE) {
    // no match: keep literal to let compiler report it
    cb_files_add(out, pattern);
    return;
  }
  do {
    if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
      char path[MAX_PATH * 2];
      snprintf(path, sizeof(path), "%s%s", dir, fd.cFileName);
      cb_files_add(out, path);
    }
  } while (FindNextFileA(h, &fd));
  FindClose(h);
}
#else
static void cb_expand_pattern_unix(CB_ARGLIST *out, const char *pattern) {
  glob_t gl;
  memset(&gl, 0, sizeof(gl));
  int r = glob(pattern, GLOB_TILDE, NULL, &gl);
  if (r == 0) {
    for (size_t i = 0; i < gl.gl_pathc; i++) {
      cb_files_add(out, gl.gl_pathv[i]);
    }
    globfree(&gl);
    return;
  }
  // No matches or error — keep as literal so the compiler can error out if
  // needed.
  cb_files_add(out, pattern);
}
#endif

static void cb_expand_project_wildcards(_CB_PROJECT *proj) {
  if (!proj || !proj->files)
    return;
  CB_ARGLIST *expanded = arglist_new();
  for (int i = 0; i < proj->files->count; i++) {
    const char *f = proj->files->list[i];
    if (cb_str_has_wildcards(f)) {
#if OS_WIN
      cb_expand_pattern_win(expanded, f);
#else
      cb_expand_pattern_unix(expanded, f);
#endif
    } else {
      cb_files_add(expanded, f);
    }
  }
  // swap lists
  arglist_free(proj->files);
  proj->files = expanded;
  CB_DEBUG_LOG("Wildcard expansion for %s produced %d file(s)", proj->name,
               proj->files->count);
}

#ifdef _CB_PY

#include "cb_py.h"



typedef struct {
  const char *name;

  char *file_data;
  int file_size;

  char ***code_blocks;
  int code_block_count;
  int *code_block_sizes;
  int *code_block_starts;

} _CB_PROJECT_TRANSPILE;

static void _cb_project_transpile_free(_CB_PROJECT_TRANSPILE *transpile) {
  for (int i = 0; i < transpile->code_block_count; i++) {
    for (int j = 0; j < transpile->code_block_sizes[i]; j++) {
      free(transpile->code_blocks[i][j]); // free each line
    }
    free(transpile->code_blocks[i]); // free line array
  }
  free(transpile->code_blocks);
  free(transpile->code_block_sizes);
  free(transpile->code_block_starts);
  free(transpile->file_data);
  free(transpile);
}

static void _cb_project_transpile_append(_CB_PROJECT_TRANSPILE *transpile,
                                         char **code_block, int code_block_size,
                                         int start_line) {
  transpile->code_blocks =
      (char ***)realloc(transpile->code_blocks,
                        (transpile->code_block_count + 1) * sizeof(char **));
  transpile->code_block_sizes =
      (int *)realloc(transpile->code_block_sizes,
                     (transpile->code_block_count + 1) * sizeof(int));
  transpile->code_block_starts =
      (int *)realloc(transpile->code_block_starts,
                     (transpile->code_block_count + 1) * sizeof(int));

  transpile->code_blocks[transpile->code_block_count] = code_block;
  transpile->code_block_sizes[transpile->code_block_count] = code_block_size;
  transpile->code_block_starts[transpile->code_block_count] = start_line;
  transpile->code_block_count++;

  // Debug print
  CB_DEBUG_LOG("Captured code block #%d starting at line %d (%d lines):",
               transpile->code_block_count, start_line, code_block_size);
}

static char *cb_strip_comment_prefix(const char *line) {
  const char *p = line;
  while (*p == ' ' || *p == '\t')
    p++;

  if (p[0] == '/' && p[1] == '/') {
    p += 2;
    if (*p == ' ')
      p++;
  }

  return strdup(p); // return cleaned line
}
static int _py_to_c99(_CB_PROJECT *proj) {
  for (int i = 0; i < proj->files->count; i++) {
    const char *f = proj->files->list[i];
    FILE *fp = fopen(f, "r");
    if (!fp) {
      CB_DEBUG_LOG("Failed to open file %s", f);
      return -1;
    }

    // read file into memory
    fseek(fp, 0, SEEK_END);
    int file_size = ftell(fp);
    fseek(fp, 0, SEEK_SET);
    char *file_data = (char *)malloc(file_size + 1);
    if (!file_data) {
      CB_DEBUG_LOG("Failed to allocate memory for file %s", f);
      fclose(fp);
      return -1;
    }
    fread(file_data, 1, file_size, fp);
    file_data[file_size] = '\0';
    fclose(fp);

    // split into lines
    int line_count = 0;
    char **lines = NULL;
    char *saveptr;
    char *tok = strtok_r(file_data, "\n", &saveptr);
    while (tok) {
      lines = (char **)realloc(lines, (line_count + 1) * sizeof(char *));
      lines[line_count++] = strdup(tok);
      tok = strtok_r(NULL, "\n", &saveptr);
    }

    // process file: detect blocks
    int in_block = 0;
    char **current_block = NULL;
    int current_size = 0;
    int start_line = 0;

    // new file buffer (lines replaced)
    char **new_lines = NULL;
    int new_count = 0;

    for (int j = 0; j < line_count; j++) {
      const char *line = lines[j];
      if (!in_block && strstr(line, "__CB_PY_BEGIN")) {
        in_block = 1;
        start_line = j;
        // keep a marker comment in output
        new_lines =
            (char **)realloc(new_lines, (new_count + 1) * sizeof(char *));
        new_lines[new_count++] = strdup("// transpiled block begin");
        continue;
      }

      if (in_block && strstr(line, "__CB_PY_END")) {
        in_block = 0;

        CB_DEBUG_LOG("Captured code block #%d starting at line %d (%d lines):",
                     new_count, start_line, current_size);
        for (int k = 0; k < current_size; k++) {
          CB_DEBUG_LOG("  %s", current_block[k]);
        }
        // transpile captured block
        int out_size = 0;
        char **c_lines =
            transpile_py_block(current_block, current_size, &out_size);

        for (int k = 0; k < out_size; k++) {
          new_lines =
              (char **)realloc(new_lines, (new_count + 1) * sizeof(char *));
          new_lines[new_count++] = c_lines[k]; // already malloc’d
        }

        // cleanup block
        for (int k = 0; k < current_size; k++)
          free(current_block[k]);
        free(current_block);
        current_block = NULL;
        current_size = 0;

        new_lines =
            (char **)realloc(new_lines, (new_count + 1) * sizeof(char *));
        new_lines[new_count++] = strdup("// transpiled block end");
        continue;
      }

      if (in_block) {
        // capture block lines (strip // prefix)
        current_block = (char **)realloc(current_block,
                                         (current_size + 1) * sizeof(char *));
        current_block[current_size++] = cb_strip_comment_prefix(line);
      } else {
        // just copy normal line
        new_lines =
            (char **)realloc(new_lines, (new_count + 1) * sizeof(char *));
        new_lines[new_count++] = strdup(line);
      }
    }

    // write file back
    fp = fopen(f, "w");
    if (!fp) {
      CB_DEBUG_LOG("Failed to write file %s", f);
      return -1;
    }
    for (int j = 0; j < new_count; j++) {
      fprintf(fp, "%s\n", new_lines[j]);
      free(new_lines[j]);
    }
    fclose(fp);

    // cleanup
    for (int j = 0; j < line_count; j++)
      free(lines[j]);
    free(lines);
    free(new_lines);
    free(file_data);

    CB_DEBUG_LOG("Transpiled %s", f);
  }
  return 0;
}

#define _CB_PYTHON_TRANSPILE(proj) int ret = _py_to_c99(proj)

#endif // _CB_PY
//---------- compile command ----------
static char *cb_concat_compile_command(_CB_PROJECT *proj) {
  if (!proj || !proj->files || proj->files->count == 0)
    return cb_strdup("[error] No source files");

#ifdef  _CB_PY
  if (proj->CB_PYTHON) {
    CB_DEBUG_LOG("Project is set to have _PY() blocks: %s", proj->output);
    CB_DEBUG_LOG("Will try to transpile into c99.");
    _CB_PYTHON_TRANSPILE(proj);
    if (ret != 0) {
      return cb_strdup("[error] Failed to transpile project");
    }
    CB_DEBUG_LOG("Transpilation successful for %s.", proj->output);
  }
#endif //    _CB_PY
  const char *cc = cb_pick_compiler_name();
  char *cmd = NULL;
  size_t cap = 0, len = 0;

#if OS_WIN
  switch (proj->build_type) {
  case BUILD_EXEC:
    cb_strcatf(&cmd, &cap, &len, "%s", cc);
    break;
  case BUILD_STATIC:
    // compile to .obj files
    for (int i = 0; i < proj->files->count; i++)
      cb_strcatf(&cmd, &cap, &len, "%s /c %s && ", cc, proj->files->list[i]);
    cb_strcatf(&cmd, &cap, &len, "lib /OUT:%s", proj->output);
    return cmd;
  case BUILD_SHARED:
    cb_strcatf(&cmd, &cap, &len, "%s /LD", cc);
    break;
  }
#else // Unix
  switch (proj->build_type) {
  case BUILD_EXEC:
    cb_strcatf(&cmd, &cap, &len, "%s", cc);
    break;
  case BUILD_STATIC:
    // compile all to .o then archive
    for (int i = 0; i < proj->files->count; i++)
      cb_strcatf(&cmd, &cap, &len, "%s -c %s && ", cc, proj->files->list[i]);
    cb_strcatf(&cmd, &cap, &len, "ar rcs %s *.o", proj->output);
    return cmd;
  case BUILD_SHARED:
    cb_strcatf(&cmd, &cap, &len, "%s -fPIC -shared", cc);
    break;
  }
#endif

  // Common flags
  for (int i = 0; i < proj->buildflags->count; i++)
    cb_strcatf(&cmd, &cap, &len, " %s", proj->buildflags->list[i]);

  if (proj->is_rebuild)
    cb_strcatf(&cmd, &cap, &len, " %s", CB_NEEDED_LIBS);

  // Add sources
  for (int i = 0; i < proj->files->count; i++)
    cb_strcatf(&cmd, &cap, &len, " %s", proj->files->list[i]);

  // Output handling
  if (proj->output) {
#if OS_WIN
    if (proj->build_type == BUILD_EXEC)
      cb_strcatf(&cmd, &cap, &len, " /Fe%s", proj->output);
    else if (proj->build_type == BUILD_SHARED)
      cb_strcatf(&cmd, &cap, &len, " /Fe%s", proj->output);
#else
    if (proj->build_type == BUILD_EXEC)
      cb_strcatf(&cmd, &cap, &len, " -o %s", proj->output);
    else if (proj->build_type == BUILD_SHARED)
      cb_strcatf(&cmd, &cap, &len, " -o %s", proj->output);
#endif
  }

  CB_DEBUG_LOG("Generated compile command: %s", cmd);
  return cmd;
}

//---------- info & free ----------
static void _cb_project_dump(_CB_PROJECT *proj) {
  if (!proj)
    return;

  printf("== Project Dump ==\n");
  printf("Name: %s\n", proj->name ? proj->name : "(unnamed)");
  printf("Output: %s\n", proj->output ? proj->output : "(none)");

  // Build type
  const char *type_str = "EXEC";
  if (proj->build_type == BUILD_STATIC)
    type_str = "STATIC";
  else if (proj->build_type == BUILD_SHARED)
    type_str = "SHARED";
  printf("Build type: %s\n", type_str);

  // Files
  printf("Files (%d):\n", proj->files ? proj->files->count : 0);
  if (proj->files)
    for (int i = 0; i < proj->files->count; i++)
      printf("  %s\n", proj->files->list[i]);

  // Build Flags
  printf("Build flags (%d):\n", proj->buildflags ? proj->buildflags->count : 0);
  if (proj->buildflags)
    for (int i = 0; i < proj->buildflags->count; i++)
      printf("  %s\n", proj->buildflags->list[i]);

  // Flags
  printf("Flags (%d):\n", proj->flags ? proj->flags->count : 0);
  if (proj->flags)
    for (int i = 0; i < proj->flags->count; i++)
      printf("  %s\n", proj->flags->list[i]);

  // Command
  printf("Compile command: %s\n",
         proj->compile_command ? proj->compile_command : "(none)");
}

static void cb_free_project(_CB_PROJECT *project) {
  if (!project)
    return;
  if (project->files)
    arglist_free(project->files);
  if (project->buildflags)
    arglist_free(project->buildflags);
  if (project->flags)
    arglist_free(project->flags);
  if (project->compile_command)
    free(project->compile_command);
  free(project);
}

//---------- checksum ----------
static char *cb_compute_md5(const char *data, size_t len) {
  unsigned char digest[MD5_DIGEST_LENGTH];
  MD5((const unsigned char *)data, len, digest);
  char *out = (char *)malloc(MD5_DIGEST_LENGTH * 2 + 1);
  if (!out) {
    fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET);
    exit(1);
  }
  for (int i = 0; i < MD5_DIGEST_LENGTH; i++)
    sprintf(out + i * 2, "%02x", digest[i]);
  out[MD5_DIGEST_LENGTH * 2] = 0;
  return out;
}

static char *cb_read_file_content(const char *filepath, size_t *out_len) {
  FILE *f = fopen(filepath, "rb");
  if (!f)
    return NULL;
  if (fseek(f, 0, SEEK_END) != 0) {
    fclose(f);
    return NULL;
  }
  long size = ftell(f);
  if (size < 0) {
    fclose(f);
    return NULL;
  }
  if (fseek(f, 0, SEEK_SET) != 0) {
    fclose(f);
    return NULL;
  }
  char *buffer = (char *)malloc((size_t)size);
  if (!buffer) {
    fclose(f);
    return NULL;
  }
  size_t read_len = fread(buffer, 1, (size_t)size, f);
  fclose(f);
  if (out_len)
    *out_len = read_len;
  return buffer;
}

static char *cb_compute_project_checksum(_CB_PROJECT *proj) {
  if (!proj)
    return NULL;
  MD5_CTX ctx;
  MD5_Init(&ctx);

  // include compile command, which includes flags & file list
  if (proj->compile_command)
    MD5_Update(&ctx, proj->compile_command, strlen(proj->compile_command));

  // include file contents
  for (int i = 0; i < proj->files->count; i++) {
    size_t flen = 0;
    char *fcontent = cb_read_file_content(proj->files->list[i], &flen);
    if (fcontent) {
      MD5_Update(&ctx, fcontent, flen);
      free(fcontent);
    }
  }

  unsigned char digest[MD5_DIGEST_LENGTH];
  MD5_Final(digest, &ctx);

  char *checksum = (char *)malloc(MD5_DIGEST_LENGTH * 2 + 1);
  if (!checksum) {
    fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET);
    exit(1);
  }
  for (int i = 0; i < MD5_DIGEST_LENGTH; i++)
    sprintf(checksum + i * 2, "%02x", digest[i]);
  checksum[MD5_DIGEST_LENGTH * 2] = 0;
  return checksum;
}

static char *cb_read_checksum(const char *filename) {
  FILE *f = fopen(filename, "r");
  if (!f)
    return NULL;
  char buf[MD5_DIGEST_LENGTH * 2 + 1];
  size_t r = fread(buf, 1, MD5_DIGEST_LENGTH * 2, f);
  fclose(f);
  if (r != MD5_DIGEST_LENGTH * 2)
    return NULL;
  buf[r] = 0;
  return cb_strdup(buf);
}

static int cb_write_checksum(const char *filename, const char *checksum) {
  FILE *f = fopen(filename, "w");
  if (!f)
    return -1;
  size_t w = fwrite(checksum, 1, strlen(checksum), f);
  fclose(f);
  return (w == strlen(checksum)) ? 0 : -1;
}

//---------- process helpers ----------
static int proc_start_build_cmd(proc_t *proc, _CB_PROJECT *proj,
                                const char *cmdline) {
  if (!cmdline)
    return -1;
#if OS_WIN
  STARTUPINFOA si;
  ZeroMemory(&si, sizeof(si));
  si.cb = sizeof(si);
  ZeroMemory(&proc->pi, sizeof(proc->pi));

  // run through cmd.exe to avoid manual argument parsing
  char *full = NULL;
  size_t cap = 0, len = 0;
  cb_strcatf(&full, &cap, &len, "cmd.exe /C %s", cmdline);

  BOOL ok = CreateProcessA(NULL, full, NULL, NULL, FALSE, 0, NULL, NULL, &si,
                           &proc->pi);
  free(full);
  if (!ok) {
    fprintf(stderr, COLOR_RED "[error] Failed to start build: %s\n" COLOR_RESET,
            cmdline);
    proc->running = 0;
    return -1;
  }
  proc->running = 1;
  proc->project = proj;
  proc->is_build = 1;
  return 0;
#else
  pid_t pid = fork();
  if (pid == 0) {
    // child: run via /bin/sh -c "cmdline"
    execl("/bin/sh", "sh", "-c", cmdline, (char *)NULL);
    perror("execl");
    _exit(127);
  } else if (pid > 0) {
    proc->pid = pid;
    proc->running = 1;
    proc->project = proj;
    proc->is_build = 1;
    return 0;
  } else {
    perror("fork");
    proc->running = 0;
    return -1;
  }
#endif
}

static int proc_start_run(proc_t *proc, _CB_PROJECT *proj, char **argv) {
#if OS_WIN
  STARTUPINFOA si;
  ZeroMemory(&si, sizeof(si));
  si.cb = sizeof(si);
  ZeroMemory(&proc->pi, sizeof(proc->pi));

  // Build a quoted commandline
  size_t cmdlen = 0;
  for (int i = 0; argv[i]; i++) {
    size_t arglen = strlen(argv[i]);
    int needs_quotes = strchr(argv[i], ' ') != NULL;
    cmdlen += arglen + (needs_quotes ? 2 : 0) + 1;
  }
  char *cmdline = (char *)malloc(cmdlen + 1);
  if (!cmdline)
    return -1;
  cmdline[0] = 0;
  for (int i = 0; argv[i]; i++) {
    int needs_quotes = strchr(argv[i], ' ') != NULL;
    if (i > 0)
      strcat(cmdline, " ");
    if (needs_quotes)
      strcat(cmdline, "\"");
    strcat(cmdline, argv[i]);
    if (needs_quotes)
      strcat(cmdline, "\"");
  }
  BOOL success = CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL,
                                &si, &proc->pi);
  free(cmdline);
  if (!success) {
    fprintf(stderr, COLOR_RED "[error] Failed to run %s\n" COLOR_RESET,
            argv[0]);
    proc->running = 0;
    return -1;
  }
  proc->running = 1;
  proc->project = proj;
  proc->is_build = 0;
  return 0;
#else
  pid_t pid = fork();
  if (pid == 0) {
    execvp(argv[0], argv);
    perror("execvp");
    _exit(127);
  } else if (pid > 0) {
    proc->pid = pid;
    proc->running = 1;
    proc->project = proj;
    proc->is_build = 0;
    return 0;
  } else {
    perror("fork");
    proc->running = 0;
    return -1;
  }
#endif
}

static int proc_poll(proc_t *proc) {
  if (!proc->running)
    return -1;
#if OS_WIN
  DWORD res = WaitForSingleObject(proc->pi.hProcess, 0);
  if (res == WAIT_OBJECT_0) {
    DWORD code;
    GetExitCodeProcess(proc->pi.hProcess, &code);
    CloseHandle(proc->pi.hProcess);
    CloseHandle(proc->pi.hThread);
    proc->running = 0;
    return (int)code;
  }
  return -1;
#else
  int status;
  pid_t ret = waitpid(proc->pid, &status, WNOHANG);
  if (ret == 0)
    return -1; // still running
  else if (ret == proc->pid) {
    proc->running = 0;
    if (WIFEXITED(status))
      return WEXITSTATUS(status);
    else
      return -1;
  }
  return -1;
#endif
}

static void proc_wait_all(proc_t *procs, int count) {
  int running = count;
  while (running > 0) {
    running = 0;
    for (int i = 0; i < count; i++) {
      if (procs[i].running) {
        int ret = proc_poll(&procs[i]);
        if (ret < 0)
          running++;
      }
    }
#if OS_WIN
    Sleep(10);
#else
    struct timespec ts;
    ts.tv_sec = 0;
    ts.tv_nsec = 10000000;
    nanosleep(&ts, NULL);
#endif
  }
}

//---------- main build driver ----------
static void _cb_project_build_internal(CB_PROJECT_BUILD_CONFIG config) {
  if (!config.projects) {
    fprintf(stderr, COLOR_RED "[error] No projects to build.\n" COLOR_RESET);
    return;
  }

  // Back-compat: old .parallel means parallel_run if caller used it
  if (config.parallel_run <= 0 && config.parallel > 0)
    config.parallel_run = config.parallel;
  if (config.parallel_build <= 0)
    config.parallel_build = 1;
  if (config.parallel_run <= 0)
    config.parallel_run = 1;

#ifdef _CB_LOG_TO_FILE
  FILE *log = fopen(".cb_build.out", "a");
  if (!log) {
    perror("fopen");
    return;
  }
  time_t now = time(NULL);
  fprintf(log, "\n=== Build Started: %s", ctime(&now));
#endif

  // 1) Prepare: expand wildcards, build commands, compute checksums, decide
  // build/no-build
  typedef struct {
    _CB_PROJECT *proj;
    int should_build;
    char checksum_file[512];
    char *new_checksum;
    char *old_checksum;
  } item_t;

  int nproj = 0;
  while (config.projects[nproj])
    nproj++;
  item_t *items = (item_t *)calloc(nproj, sizeof(item_t));
  if (!items) {
    fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET);
    return;
  }

  for (int i = 0; i < nproj; i++) {
    _CB_PROJECT *proj = config.projects[i];

    // Expand wildcards BEFORE command & checksum
    cb_expand_project_wildcards(proj);
    _CB_BUILD_COMPILE_COMMAND(proj);

    // checksum filename (safe-ish)
    snprintf(items[i].checksum_file, sizeof(items[i].checksum_file),
             ".cb_checksum_%s", proj->name ? proj->name : "noname");
    items[i].proj = proj;

    // compute checksums
    items[i].new_checksum = cb_compute_project_checksum(proj);
    items[i].old_checksum = cb_read_checksum(items[i].checksum_file);
    items[i].should_build = 1;
    if (items[i].new_checksum && items[i].old_checksum &&
        strcmp(items[i].new_checksum, items[i].old_checksum) == 0) {
      items[i].should_build = 0;
    }
  }

  // 2) Build stage (parallel if requested)
  int build_jobs = 0;
  for (int i = 0; i < nproj; i++)
    if (items[i].should_build)
      build_jobs++;

  if (build_jobs == 0) {
    for (int i = 0; i < nproj; i++) {
      printf(COLOR_YELLOW
             "[build] Skipping %s (no changes detected)\n\n" COLOR_RESET,
             items[i].proj->name);
#ifdef _CB_LOG_TO_FILE
      if (log)
        fprintf(log, "[build] Skipped project: %s\n", items[i].proj->name);
#endif
    }
  } else if (config.parallel_build <= 1) {
    for (int i = 0; i < nproj; i++) {
      if (!items[i].should_build) {
        printf(COLOR_YELLOW
               "[build] Skipping %s (no changes detected)\n\n" COLOR_RESET,
               items[i].proj->name);
        continue;
      }
      _CB_PROJECT *proj = items[i].proj;
      printf(COLOR_YELLOW "[build] Building %s\n" COLOR_RESET, proj->name);
      printf("  %s\n", proj->compile_command);
#ifdef _CB_LOG_TO_FILE
      if (log)
        fprintf(log, "[build] Project: %s\nCommand: %s\n", proj->name,
                proj->compile_command);
#endif
      clock_t start = clock();
      // Run synchronously (serial mode)
#if OS_WIN
      // Use system here; it will invoke cmd.exe
      int ret = system(proj->compile_command);
#else
      int ret = system(proj->compile_command);
#endif
      clock_t end = clock();
      if (ret != 0) {
        fprintf(stderr, COLOR_RED "[error] Build failed for %s\n" COLOR_RESET,
                proj->name);
#ifdef _CB_LOG_TO_FILE
        if (log)
          fprintf(log, "[error] Build failed for %s\n", proj->name);
#endif
        continue;
      }
      double duration = (double)(end - start) / CLOCKS_PER_SEC;
      printf(COLOR_GREEN "[success] Built in %.2fs\n" COLOR_RESET, duration);
#ifdef _CB_LOG_TO_FILE
      if (log)
        fprintf(log, "[success] Built in %.2fs\n", duration);
#endif
      cb_write_checksum(items[i].checksum_file, items[i].new_checksum);
    }
  } else {
    // Parallel build pool
    int maxp = config.parallel_build;
    proc_t *pool = (proc_t *)calloc(maxp, sizeof(proc_t));
    if (!pool) {
      fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET);
      goto after_builds;
    }
    int active = 0, next = 0;

    while (1) {
      // launch while capacity
      while (active < maxp && next < nproj) {
        if (!items[next].should_build) {
          next++;
          continue;
        }
        _CB_PROJECT *proj = items[next].proj;
        printf(COLOR_YELLOW "[build] Building %s (parallel)\n" COLOR_RESET,
               proj->name);
        printf("  %s\n", proj->compile_command);
#ifdef _CB_LOG_TO_FILE
        if (log)
          fprintf(log, "[build] Project: %s\nCommand: %s\n", proj->name,
                  proj->compile_command);
#endif
        // find free slot
        int k = -1;
        for (int t = 0; t < maxp; t++)
          if (!pool[t].running) {
            k = t;
            break;
          }
        if (k == -1)
          break; // shouldn't happen due to active<maxp
        if (proc_start_build_cmd(&pool[k], proj, proj->compile_command) == 0) {
          active++;
        } else {
          fprintf(stderr,
                  COLOR_RED
                  "[error] Failed to start build for %s\n" COLOR_RESET,
                  proj->name);
        }
        next++;
      }

      if (active == 0) {
        // maybe there are only skipped projects left
        int remaining = 0;
        for (int j = next; j < nproj; j++)
          if (items[j].should_build)
            remaining++;
        if (remaining == 0)
          break;
      }

      // poll
      for (int t = 0; t < maxp; t++) {
        if (pool[t].running) {
          int ret = proc_poll(&pool[t]);
          if (ret >= 0) {
            active--;
            if (ret != 0) {
              fprintf(stderr,
                      COLOR_RED
                      "[error] Build failed for %s (exit %d)\n" COLOR_RESET,
                      pool[t].project ? pool[t].project->name : "(unknown)",
                      ret);
#ifdef _CB_LOG_TO_FILE
              if (log)
                fprintf(log, "[error] Build failed for %s\n",
                        pool[t].project ? pool[t].project->name : "(unknown)");
#endif
            } else {
              // success → write checksum
              for (int i = 0; i < nproj; i++)
                if (items[i].proj == pool[t].project)
                  cb_write_checksum(items[i].checksum_file,
                                    items[i].new_checksum);
              printf(COLOR_GREEN "[success] Built %s\n" COLOR_RESET,
                     pool[t].project ? pool[t].project->name : "");
            }
          }
        }
      }
#if OS_WIN
      Sleep(10);
#else
      struct timespec ts;
      ts.tv_sec = 0;
      ts.tv_nsec = 10000000;
      nanosleep(&ts, NULL);

#endif
      if (next >= nproj && active == 0)
        break;
    }
    free(pool);
  after_builds:;
    // Print skips that never printed
    for (int i = 0; i < nproj; i++)
      if (!items[i].should_build)
        printf(COLOR_YELLOW
               "[build] Skipping %s (no changes detected)\n" COLOR_RESET,
               items[i].proj->name);
  }

  // 3) Optional run stage (may be parallel)
  if (config.run) {
    int maxp = (config.parallel_run > 0 ? config.parallel_run : 1);
    proc_t *pool = (proc_t *)calloc(maxp, sizeof(proc_t));
    if (!pool) {
      fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET);
      goto cleanup;
    }
    int active = 0;
    for (int i = 0; i < nproj; i++) {
      _CB_PROJECT *proj = items[i].proj;

      int should_run = proj->output != NULL &&
                       (items[i].should_build || config.run_if_skipped);
      if (!should_run)
        continue;

      int argc = proj->flags ? proj->flags->count : 0;
      char **argv = (char **)malloc(sizeof(char *) * (argc + 2));
      if (!argv) {
        fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET);
        continue;
      }

      char output_path[512];
#if OS_WIN
      snprintf(output_path, sizeof(output_path), "%s", proj->output);
#else
      snprintf(output_path, sizeof(output_path), "./%s", proj->output);
#endif
      argv[0] = cb_strdup(output_path);
      for (int j = 0; j < argc; j++)
        argv[j + 1] = proj->flags->list[j];
      argv[argc + 1] = NULL;

      if (maxp <= 1) {
        // run serially and wait
        printf(COLOR_CYAN "[run] %s\n" COLOR_RESET, argv[0]);
#if OS_WIN
        STARTUPINFOA si;
        ZeroMemory(&si, sizeof(si));
        si.cb = sizeof(si);
        PROCESS_INFORMATION pi;
        ZeroMemory(&pi, sizeof(pi));
        // Build cmdline
        size_t cmdlen = 0;
        for (int z = 0; argv[z]; z++) {
          size_t L = strlen(argv[z]);
          int q = strchr(argv[z], ' ') != NULL;
          cmdlen += L + (q ? 2 : 0) + 1;
        }
        char *cmdline = (char *)malloc(cmdlen + 1);
        cmdline[0] = 0;
        for (int z = 0; argv[z]; z++) {
          int q = strchr(argv[z], ' ') != NULL;
          if (z > 0)
            strcat(cmdline, " ");
          if (q)
            strcat(cmdline, "\"");
          strcat(cmdline, argv[z]);
          if (q)
            strcat(cmdline, "\"");
        }
        if (CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si,
                           &pi)) {
          WaitForSingleObject(pi.hProcess, INFINITE);
          CloseHandle(pi.hProcess);
          CloseHandle(pi.hThread);
        } else {
          fprintf(stderr, COLOR_RED "[error] Failed to run %s\n" COLOR_RESET,
                  argv[0]);
        }
        free(cmdline);
#else
        pid_t pid = fork();
        if (pid == 0) {
          execvp(argv[0], argv);
          perror("execvp");
          _exit(127);
        } else if (pid > 0) {
          waitpid(pid, NULL, 0);
        } else {
          perror("fork");
        }
#endif
        free(argv[0]);
        free(argv);
        if (proj->is_rebuild) {
          // as per your debug note: stop the program if it's just a rebuild
          exit(1);
        }
      } else {
        // run in parallel pool
        // ensure slot
        for (;;) {
          int used = 0;
          for (int k = 0; k < maxp; k++)
            if (pool[k].running)
              used++;
          if (used < maxp)
            break;
          for (int k = 0; k < maxp; k++) {
            if (pool[k].running) {
              int ret = proc_poll(&pool[k]);
              (void)ret;
            }
          }
#if OS_WIN
          Sleep(10);
#else
          struct timespec ts;
          ts.tv_sec = 0;
          ts.tv_nsec = 10000000;
          nanosleep(&ts, NULL);
#endif
        }
        // find free slot
        int k = -1;
        for (int t = 0; t < maxp; t++)
          if (!pool[t].running) {
            k = t;
            break;
          }
        if (k >= 0) {
          printf(COLOR_CYAN "[run] %s (parallel)\n" COLOR_RESET, argv[0]);
          if (proc_start_run(&pool[k], proj, argv) != 0) {
            fprintf(stderr,
                    COLOR_RED "[error] Failed to start %s\n" COLOR_RESET,
                    argv[0]);
          }
        }
        // argv memory: argv[0] was strdup'ed; the child process duplicates
        // memory; we can free now
        free(argv[0]);
        free(argv);
      }
    }
    if (maxp > 1) {
      proc_wait_all(pool, maxp);
    }
    free(pool);
  }

cleanup:
#ifdef _CB_LOG_TO_FILE
  if (log)
    fclose(log);
#endif
  for (int i = 0; i < nproj; i++) {
    free(items[i].old_checksum);
    free(items[i].new_checksum);
  }
  free(items);
}

#endif // _CB_IMPLEMENTATION
#endif // _STB_CB_H