// x-run: gcc % -lmongoose -o %.elf && ./%.elf
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <mongoose.h>
#include <sys/time.h>
#include <unistd.h>
#include <pthread.h>

#ifndef ALLOC_ON_DEMAND
#define ALLOC_ON_DEMAND 1
#endif

#ifndef OPTIMIZED_PRECALCULATION
#define OPTIMIZED_PRECALCULATION 1
#endif

#ifndef ALLOCATE_EVERYTHING
#define ALLOCATE_EVERYTHING 0
#endif


#define panic(...) { \
  fprintf(stderr, "!PANIC! at %s:%d\n", __FILE__, __LINE__);\
  fprintf(stderr, __VA_ARGS__); \
  abort(); \
}

typedef struct odd_block {
  uint64_t start;
  uint8_t *block; // 16 MiB or 134217728 numbers
  struct odd_block *next;
} OddBlock;

enum {
  RESPONSE_ODD,
  RESPONSE_EVEN,
  RESPONSE_NOT_FOUND
};

OddBlock *block_init(uint64_t start);
bool block_in_range(OddBlock blk, uint64_t value);
bool block_check(OddBlock blk, uint64_t value);
void block_add(OddBlock *blk);
int check_is_odd(uint64_t value);
inline uint64_t get_mem_usage(void);
inline double get_time(void);
#if ALLOCATE_EVERYTHING
void *allocation_thread(void*);
#endif

OddBlock *blocks_head = NULL;
size_t n_blocks = 0;
uint64_t n_requests = 0;
uint64_t n_allocs_failed = 0;
pthread_mutex_t blocks_head_lock = PTHREAD_MUTEX_INITIALIZER;
unsigned int favicon_ico_len = 318;
unsigned char favicon_ico[];

#if ALLOCATE_EVERYTHING
uint64_t next_block_number = 0;
#endif


void api_handler(struct mg_connection *c, int ev, void *evd, void *fnd);

int main(int argc, char **argv) {
  struct mg_mgr manager;
  mg_mgr_init(&manager);
  char *addr = "0.0.0.0:8080";
  if (argc >= 3) addr = argv[2];
  mg_http_listen(&manager, addr, api_handler, NULL);

#if ALLOCATE_EVERYTHING
  int n_threads = 4;
  if (argc >= 2) n_threads = atoi(argv[1]);
  pthread_t *threads = calloc(n_threads, sizeof(pthread_t));
  for (int i = 0; i < n_threads; i++)
    pthread_create(&threads[i], NULL, allocation_thread, NULL);
#endif

  for (;;) mg_mgr_poll(&manager, 1000);

#if ALLOCATE_EVERYTHING
  for (int i = 0; i < n_threads; i++)
    pthread_join(threads[i], NULL);
#endif

  mg_mgr_free(&manager);
  return 0;
}

OddBlock *block_init(uint64_t start) {
  OddBlock *blk = calloc(1, sizeof(OddBlock));
  if (blk == NULL) {
    printf("Failed to allocate a new block: %zd\n", start);
    n_allocs_failed++;
    return NULL;
  }
  if ((blk->block = malloc(0x1000000)) == NULL) {
    printf("Failed to allocate a new block contents: %zd\n", start);
    free(blk);
    n_allocs_failed++;
    return NULL;
  }
  n_blocks++;
  blk->start = start;
#if OPTIMIZED_PRECALCULATION
  memset(blk->block, 0xaa, 0x1000000);
#else
  for (uint64_t off = 0; off < 0x8000000; off++) {
    off_t byte_ndx = off >> 3;
    blk->block[byte_ndx] |= ((start + off) % 2) << (off % 8);
  }
#endif
  return blk;
}

bool block_in_range(OddBlock blk, uint64_t value) {
  return value >= blk.start && value < (blk.start + 0x8000000);
}

bool block_check(OddBlock blk, uint64_t value) {
  if (!block_in_range(blk, value))
    panic("%zd is outside of the range\n", value);
  off_t offset = value - blk.start;
  return blk.block[offset >> 3] & (1 << (offset % 8)) ? true : false;
}

void block_add(OddBlock *blk) {
#if ALLOCATE_EVERYTHING
  pthread_mutex_lock(&blocks_head_lock);
#endif
  if (blocks_head) {
    blk->next = blocks_head;
    blocks_head = blk;
  } else {
    blocks_head = blk;
  }
#if ALLOCATE_EVERYTHING
  pthread_mutex_unlock(&blocks_head_lock);
#endif
  printf("added block %p with start=%zd\n", blk, blk->start);
}

int check_is_odd(uint64_t value) {
  for (OddBlock *blk = blocks_head; blk != NULL; blk = blk->next) {
    if (block_in_range(*blk, value)) {
      return block_check(*blk, value) ? RESPONSE_ODD : RESPONSE_EVEN;
    }
  }


#if ALLOC_ON_DEMAND
  // no blocks with that number were found
  OddBlock *blk = block_init(value & ~0xFFFFFF);
  if (!blk) return RESPONSE_NOT_FOUND;
  block_add(blk);
  return block_check(*blk, value) ? RESPONSE_ODD : RESPONSE_EVEN;
#else
  return RESPONSE_NOT_FOUND;
#endif
}

void api_handler(struct mg_connection *c, int ev, void *evd, void *fnd) {
  if (ev == MG_EV_HTTP_MSG) {
    static char url[256], method[32], addr[256];
    struct mg_http_message *hm = evd;
    memset(url, 0, 256); memcpy(url, hm->uri.ptr, hm->uri.len);
    memset(method, 0, 32); memcpy(method, hm->method.ptr, hm->method.len);
    mg_straddr(&c->rem, addr, 255);

    printf("%-16s %-8s %s\n", addr, method, url);

    if (mg_http_match_uri(hm, "/analytics")) {
      char buffer[1024] = { 0 };
      snprintf(buffer, 1023, 
          "{"
          "\"ts\":%lf,"
          "\"n_blocks\":%zd,"
          "\"memory\":%zd,"
          "\"last_block_value\":%zd,"
          "\"n_requests\":%zd,"
          "\"n_allocs_failed\":%zd"
          "}",
            get_time(),
            n_blocks,
            get_mem_usage(),
            blocks_head ? blocks_head->start + 0x8000000 - 1 : -1,
            n_requests,
            n_allocs_failed);
      mg_http_reply(c, 200, "Content-Type: application/json\r\n", buffer);
    } else if (mg_http_match_uri(hm, "/blocks")) {
      mg_printf(c, "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n");
      char buffer[1024];
      for (OddBlock *blk = blocks_head; blk; blk = blk->next) {
        snprintf(buffer, 1023, "block %p (%zd...%zd)\n",
            blk, blk->start, blk->start + 0x8000000 - 1);
        mg_http_printf_chunk(c, buffer);
      }
      mg_http_printf_chunk(c, "");
    } else if (mg_http_match_uri(hm, "/isEven/*")) {
      uint64_t number;
      sscanf(url, "/isEven/%zd", &number);
      switch (check_is_odd(number)) {
        case RESPONSE_NOT_FOUND:
          mg_http_reply(c, 451, "Content-Type: application/json\r\n",
              "{ \"message\": \"This number is not indexed yet.\" }");
          break;
        case RESPONSE_ODD:
          mg_http_reply(c, 200, "Content-Type: application/json\r\n",
              "{ \"even\": false }");
          break;
        case RESPONSE_EVEN:
          mg_http_reply(c, 200, "Content-Type: application/json\r\n",
              "{ \"even\": true }");
          break;
      }
      n_requests++;
    } else if (mg_http_match_uri(hm, "/isOdd/*")) {
      uint64_t number;
      sscanf(url, "/isOdd/%zd", &number);
      switch (check_is_odd(number)) {
        case RESPONSE_NOT_FOUND:
          mg_http_reply(c, 451, "Content-Type: application/json\r\n",
              "{ \"message\": \"This number is not indexed yet.\" }");
          break;
        case RESPONSE_ODD:
          mg_http_reply(c, 200, "Content-Type: application/json\r\n",
              "{ \"odd\": true }");
          break;
        case RESPONSE_EVEN:
          mg_http_reply(c, 200, "Content-Type: application/json\r\n",
              "{ \"odd\": false }");
          break;
      }
      n_requests++;
    } else if (mg_http_match_uri(hm, "/lastEven")) {
      mg_http_reply(c, 200, "", "%zd", blocks_head->start + 0x7FFFFFE);
      n_requests++;
    } else if (mg_http_match_uri(hm, "/lastOdd")) {
      mg_http_reply(c, 200, "", "%zd", blocks_head->start + 0x7FFFFFF);
      n_requests++;
    } else if (mg_http_match_uri(hm, "/favicon.ico")) {
      mg_printf(c,
          "HTTP/1.1 200 OK\r\n"
          "Content-Type: image/vnd.microsoft.icon\r\n"
          "Content-Length: %d\r\n\r\n", favicon_ico_len);
      mg_send(c, favicon_ico, favicon_ico_len);
    } else {
      mg_http_reply(c, 500, "Content-Type: text/plain; charset=utf-8\r\n", "Internal Server Error");
    }
  }
}

uint64_t get_mem_usage(void) {
  FILE *fp = fopen("/proc/self/statm", "r");
  if (!fp) return 0;
  uint64_t res;
  fscanf(fp, "%zd", &res);
  fclose(fp);
  return res * getpagesize();
}

double get_time(void) {
  struct timeval now;
  gettimeofday(&now, NULL);
  return now.tv_sec + now.tv_usec / 1000000.0;

}

#if ALLOCATE_EVERYTHING
void *allocation_thread(void*_) {
  while (true) {
    next_block_number += 0x8000000;
    OddBlock *blk = block_init(next_block_number);
    if (!blk) continue;
    block_add(blk);
  }
}
#endif

unsigned char favicon_ico[] = {
  0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x10, 0x10, 0x10, 0x00, 0x01, 0x00,
  0x04, 0x00, 0x28, 0x01, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x28, 0x00,
  0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00,
  0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x13, 0x13, 0x13, 0x00, 0xde, 0xd9, 0xd0, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
  0x22, 0x22, 0x22, 0x22, 0x00, 0x02, 0x20, 0x00, 0x22, 0x22, 0x22, 0x22,
  0x01, 0x02, 0x20, 0x10, 0x22, 0x22, 0x22, 0x22, 0x01, 0x02, 0x20, 0x10,
  0x22, 0x22, 0x22, 0x22, 0x01, 0x02, 0x20, 0x10, 0x22, 0x22, 0x22, 0x22,
  0x01, 0x02, 0x20, 0x10, 0x22, 0x22, 0x22, 0x22, 0x01, 0x02, 0x20, 0x10,
  0x22, 0x22, 0x22, 0x22, 0x01, 0x00, 0x20, 0x10, 0x22, 0x22, 0x22, 0x22,
  0x01, 0x10, 0x00, 0x10, 0x22, 0x22, 0x22, 0x22, 0x01, 0x01, 0x11, 0x00,
  0x22, 0x22, 0x22, 0x22, 0x01, 0x00, 0x00, 0x02, 0x22, 0x22, 0x22, 0x22,
  0x01, 0x02, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x01, 0x02, 0x22, 0x22,
  0x22, 0x22, 0x22, 0x22, 0x00, 0x02, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
  0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
  0x22, 0x22, 0xff, 0xff, 0x00, 0x00, 0xf1, 0x8f, 0x00, 0x00, 0xf1, 0x8f,
  0x00, 0x00, 0xf1, 0x8f, 0x00, 0x00, 0xf1, 0x8f, 0x00, 0x00, 0xf1, 0x8f,
  0x00, 0x00, 0xf1, 0x8f, 0x00, 0x00, 0xf0, 0x8f, 0x00, 0x00, 0xf0, 0x0f,
  0x00, 0x00, 0xf0, 0x0f, 0x00, 0x00, 0xf0, 0x1f, 0x00, 0x00, 0xf1, 0xff,
  0x00, 0x00, 0xf1, 0xff, 0x00, 0x00, 0xf1, 0xff, 0x00, 0x00, 0xff, 0xff,
  0x00, 0x00, 0xff, 0xff, 0x00, 0x00
};