#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>

static inline void Print_Clear() { printf("\x1b\x5b\x48\x1b\x5b\x32\x4a"); }

typedef struct Sudoku {
  uint8_t *field;
  bool *fixed;
  size_t size;
  size_t block_size;
  size_t pos;
  size_t pos_last_placed;
  size_t num_fields;
} Sudoku;

static Sudoku *Sudoku_New(size_t block_size) {

  Sudoku *s = calloc(1, sizeof(Sudoku));

  // clang-format off
  uint8_t many_solutions_field[81] = {
      0, 0, 0, 0, 0, 0, 0, 0, 9,
      0, 0, 0, 0, 8, 9, 0, 2, 0,
      0, 0, 0, 0, 2, 0, 4, 0, 0,
      0, 0, 4, 0, 6, 0, 0, 0, 8,
      0, 0, 0, 5, 0, 0, 0, 0, 0,
      0, 6, 5, 0, 0, 2, 0, 7, 4,
      0, 3, 0, 0, 0, 5, 0, 4, 0,
      0, 0, 1, 8, 0, 0, 0, 0, 0,
      0, 0, 8, 2, 0, 0, 0, 6, 0,
  };
  // clang-format on

  size_t size = block_size * block_size;
  uint8_t *field = calloc(size * size, sizeof(uint8_t));
  bool *fixed = calloc(size * size, sizeof(bool));

  printf("num_fields: %zu\n", size * size);

  s->field = field;
  s->fixed = fixed;

  for (size_t idx = 0; idx < 81; idx++) {
    s->field[idx] = many_solutions_field[idx];
  }

  for (size_t idx = 0; idx < 81; idx++) {
    if (s->field[idx] != 0) {
      s->fixed[idx] = true;
    }
  }

  s->size = size;
  s->block_size = block_size;
  s->pos = 0;
  s->pos_last_placed = 0;
  s->num_fields = size * size;

  return s;
}

static inline void Sudoku_Print(Sudoku *s) {
  for (size_t idx = 0; idx < s->num_fields; idx++) {

    // newline
    if (idx != 0 && idx % s->size == 0)
      printf("\n");

    // nr
    printf("%hhu", s->field[idx]);

    // space
    if ((idx + 1) % s->size != 0)
      printf(" ");
  }
  printf("\n");
}

static inline bool Sudoku_Next(Sudoku *s) {
  if (s->pos == s->num_fields - 1) {
    return false;
  }

  s->pos++;
  return true;
}

static inline bool Sudoku_Prev(Sudoku *s) {
  if (s->pos == 0)
    return false;

  s->pos--;
  return true;
}

static inline bool Sudoku_IsFixed(Sudoku *s) { return s->fixed[s->pos]; }

static inline uint8_t Sudoku_GetFieldAtPos(Sudoku *s, size_t pos) {
  return s->field[pos];
}

static inline void Sudoku_Set(Sudoku *s, uint8_t nr) {
  s->field[s->pos] = nr;
  s->pos_last_placed = s->pos;
}

static inline void Sudoku_ClearCurrentField(Sudoku *s) { Sudoku_Set(s, 0); }

static inline bool Array_Contains(uint8_t *arr, size_t len, uint8_t nr) {
  for (size_t idx = 0; idx < len; idx++) {
    if (arr[idx] == nr) {
      return true;
    }
  }
  return false;
}

static inline bool Sudoku_IsEnd(Sudoku *s) {
  return !Array_Contains(s->field, s->num_fields, 0);
}

static inline bool Sudoku_GotoPrevFreeField(Sudoku *s) {
  do {
    if (!Sudoku_IsFixed(s))
      return true;
  } while (Sudoku_Prev(s));

  return false;
}

static inline bool Sudoku_GotoNextFreeField(Sudoku *s) {
  do {
    if (!Sudoku_IsFixed(s))
      return true;
  } while (Sudoku_Next(s));

  return false;
}

static inline void Sudoku_GetRow(Sudoku *s, uint8_t *row) {
  for (size_t pos = 0; pos < s->size; pos++) {
    row[pos] = Sudoku_GetFieldAtPos(s, (s->pos / s->size) * s->size + pos);
  }
}

static inline void Sudoku_GetCol(Sudoku *s, uint8_t *col) {
  for (size_t pos = 0; pos < s->size; pos++) {
    col[pos] = Sudoku_GetFieldAtPos(s, pos * s->size + s->pos % s->size);
  }
}

static inline void Sudoku_GetBlock(Sudoku *s, uint8_t *block) {
  size_t block_start_row = s->pos / s->size / s->block_size * s->block_size;
  size_t block_start_col = s->pos % s->size / s->block_size * s->block_size;

  for (size_t r = 0; r < s->block_size; r++) {
    for (size_t c = 0; c < s->block_size; c++) {
      block[r * s->block_size + c] = Sudoku_GetFieldAtPos(
          s, s->size * (block_start_row + r) + block_start_col + c);
    }
  }
}

static inline bool Sudoku_BlockOk(Sudoku *s, uint8_t nr) {
  bool ok;
  uint8_t block[9] = {0};
  Sudoku_GetBlock(s, block);
  ok = !Array_Contains(block, s->size, nr);
  return ok;
}

static inline bool Sudoku_RowOk(Sudoku *s, uint8_t nr) {
  bool ok;
  uint8_t row[9] = {0};
  Sudoku_GetRow(s, row);
  ok = !Array_Contains(row, s->size, nr);
  return ok;
}

static inline bool Sudoku_ColOk(Sudoku *s, uint8_t nr) {
  bool ok;
  uint8_t col[9] = {0};
  Sudoku_GetCol(s, col);
  ok = !Array_Contains(col, s->size, nr);
  return ok;
}

static inline bool Sudoku_Ok(Sudoku *s, uint8_t nr) {
  return Sudoku_BlockOk(s, nr) && Sudoku_ColOk(s, nr) && Sudoku_RowOk(s, nr);
}

static inline bool Sudoku_PutValidNr(Sudoku *s) {
  uint8_t current_nr = Sudoku_GetFieldAtPos(s, s->pos);
  for (uint8_t nr = current_nr; nr < s->size + 1; nr++) {
    if (Sudoku_Ok(s, nr)) {
      Sudoku_Set(s, nr);
      return true;
    }
  }
  return false;
}

static bool Sudoku_SolveBacktracking(Sudoku *s) {
  bool found_solution = false;
  size_t num_solutions = 0;
  while (1) {
    if (Sudoku_IsEnd(s)) {
      found_solution = true;
      num_solutions++;
      if (num_solutions % 100 == 0) {
        Print_Clear();
        printf("Solutions: %zu\n", num_solutions);
        Sudoku_Print(s);
      }

      if (Sudoku_IsFixed(s)) {
        continue;
      }
      Sudoku_ClearCurrentField(s);
      Sudoku_Prev(s);
      Sudoku_GotoPrevFreeField(s);
    }

    if (Sudoku_IsFixed(s)) {
      Sudoku_Next(s);
      continue;
    }

    if (Sudoku_GotoNextFreeField(s)) {
      if (Sudoku_PutValidNr(s)) {
        Sudoku_Next(s);
        continue;
      } else {
        Sudoku_ClearCurrentField(s);
        if (!Sudoku_Prev(s)) {
          printf("Number of solutions: %zu\n", num_solutions);
          break;
        }
        if (!Sudoku_GotoPrevFreeField(s)) {
          printf("Number of solutions: %zu\n", num_solutions);
          break;
        }
      }
    }
  }

  return found_solution;
}

static void Sudoku_Free(Sudoku *s) {
  free(s->field);
  free(s->fixed);
  free(s);
  s = NULL;
}

int main() {
  Sudoku *s = Sudoku_New(3);
  Sudoku_Print(s);
  Sudoku_SolveBacktracking(s);
  Sudoku_Free(s);
}