#include "common.h"
#include <stdint.h>
#include <vector>

namespace aoc2022 {

struct monkey_map {
  int start;
  line_view line;

  void print() const noexcept {
    for (int i = 0; i < start; i++) {
      printf(" ");
    }
    const char* p = line.line;
    for (size_t i = 0; i < line.length; i++) {
      printf("%c", *(p + i));
    }
    printf("\n");
  }

  monkey_map(const char* p) {
    const char* p0 = p;
    while (*p == ' ')
      p++;
    start = p - p0;
    p0 = p;
    while (*p == '.' || *p == '#')
      p++;
    line = {p0, p};
  }
};

struct trace_map {
  char* p = nullptr;

  trace_map(const monkey_map& m) {
    p = (char*)malloc(m.start + m.line.length + 1);
    for (int i = 0; i < m.start; i++) {
      *(p + i) = ' ';
    }
    for (size_t i = 0; i < m.line.length; i++) {
      *(p + m.start + i) = *(m.line.line + i);
    }
    *(p + m.start + m.line.length) = '\n';
  }

  void print() const noexcept {
    char* px = p;
    while (true) {
      printf("%c", *px);
      if (*px == '\n')
        break;
      px++;
    }
  }
};

// Facing is 0 for right (>), 1 for down (v), 2 for left (<), and 3 for up (^)
enum facing {
  right,
  down,
  left,
  up,
};

struct route {
  bool is_step = true;
  char lr;
  union {
    int steps = 0;
    facing f;
  } ins;

  void print(facing* f) const noexcept {
    if (is_step) {
      printf("%d", ins.steps);
    } else {
      switch (*f) {
      case right:
        printf("%c", ins.f == up ? 'L' : 'R');
        break;
      case down:
        printf("%c", ins.f == left ? 'R' : 'L');
        break;
      case left:
        printf("%c", ins.f == up ? 'R' : 'L');
        break;
      case up:
        printf("%c", ins.f == left ? 'L' : 'R');
        break;
      }
      *f = ins.f;
    }
  }

  route(const char** pp, facing* ff) {
    const char* p = *pp;
    if (*p >= '0' && *p <= '9') {
      while (*p >= '0' && *p <= '9') {
        ins.steps = ins.steps * 10 + *p - '0';
        p++;
      }
      *pp = p;
    } else {
      is_step = false;
      lr = *p;
      switch (*p) {
      case 'L': {
        switch (*ff) {
        case right:
          *ff = up;
          ins.f = up;
          break;
        case down:
          *ff = right;
          ins.f = right;
          break;
        case left:
          *ff = down;
          ins.f = down;
          break;
        case up:
          *ff = left;
          ins.f = left;
          break;
        }
      } break;
      case 'R': {
        switch (*ff) {
        case right:
          *ff = down;
          ins.f = down;
          break;
        case down:
          *ff = left;
          ins.f = left;
          break;
        case left:
          *ff = up;
          ins.f = up;
          break;
        case up:
          *ff = right;
          ins.f = right;
          break;
        }
      } break;
      default:
        break;
      }
      *pp = p + 1;
    }
  }
};

struct cube_map {
  // constexpr static int size = 4;
  constexpr static int size = 50;
  struct {
    cube_map* m;
    facing f;
  } sides[4]; // right, down, left, up

  int x;
  int y;
};

std::pair<int64_t, int64_t> day22(line_view);
} // namespace aoc2022