#include "worldbuilder.hpp"
#include "rand.hpp"
#include <fmt/core.h>

using namespace fmt;

inline int make_split(Room &cur, bool horiz) {
  size_t dimension = horiz ? cur.height : cur.width;
  int min = dimension / 4;
  int max = dimension - min;

  return Random::uniform<int>(min, max);
}

void WorldBuilder::set_door(Room &room, int value) {
  $map.$walls[room.entry.y][room.entry.x] = value;
  $map.$walls[room.exit.y][room.exit.x] = value;
}

void rand_side(Room &room, Point &door) {
  int rand_x = Random::uniform<int>(0, room.width - 1);
  int rand_y = Random::uniform<int>(0, room.height - 1);

  switch(Random::uniform<int>(0,3)) {
    case 0: // north
      door.x = room.x + rand_x;
      door.y = room.y-1;
      break;
    case 1: // south
      door.x = room.x + rand_x;
      door.y = room.y + room.height;
      break;
    case 2: // east
      door.x = room.x + room.width;
      door.y = room.y + rand_y;
      break;
    case 3: // west
      door.x = room.x - 1;
      door.y = room.y + rand_y;
      break;
    default:
      dbc::sentinel("impossible side");
  }
}

void WorldBuilder::add_door(Room &room) {
  rand_side(room, room.entry);
  rand_side(room, room.exit);
}

void WorldBuilder::partition_map(Room &cur, int depth) {
  if(cur.width >= 5 && cur.width <= 10 &&
      cur.height >= 5 && cur.height <= 10) {
    $map.$rooms.push_back(cur);
    return;
  }

  bool horiz = cur.width > cur.height ? false : true;
  int split = make_split(cur, horiz);
  Room left = cur;
  Room right = cur;

  if(horiz) {
    dbc::check(split > 0, "split is not > 0");
    dbc::check(split < int(cur.height), "split is too big!");
    left.height = size_t(split - 1);
    right.y = cur.y + split;
    right.height = size_t(cur.height - split);
  } else {
    dbc::check(split > 0, "split is not > 0");
    dbc::check(split < int(cur.width), "split is too big!");

    left.width = size_t(split-1);
    right.x = cur.x + split,
    right.width = size_t(cur.width - split);
  }

  if(depth > 0  && left.width > 5 && left.height > 5) {
    partition_map(left, depth-1);
  }

  if(depth > 0 && right.width > 5 && right.height > 5) {
    partition_map(right, depth-1);
  }
}

void WorldBuilder::generate() {
  Room root{
    .x = 0,
    .y = 0,
    .width = $map.$width,
    .height = $map.$height
  };

  partition_map(root, 10);
  place_rooms(root);

  for(size_t i = 0; i < $map.$rooms.size() - 1; i++) {
    Room &src = $map.$rooms[i];
    Room &target = $map.$rooms[i+1];
    $map.set_target(target.entry);
    bool found = dig_tunnel(src.exit, target.entry);
    if(!found) {
      println("ROOM NOT FOUND!");
    }
    $map.clear_target(target.entry);
  }

  Room &src = $map.$rooms.back();
  Room &target = $map.$rooms.front();

  $map.set_target(target.entry);
  dig_tunnel(src.exit, target.entry);
  $map.clear_target(target.entry);

  for(size_t y = 0; y < $map.$height; ++y) {
    for(size_t x = 0; x < $map.$width; ++x) {
      $map.$walls[y][x] = !$map.$walls[y][x];
    }
  }
}

void WorldBuilder::make_room(size_t origin_x, size_t origin_y, size_t w, size_t h) {
  $map.INVARIANT();
  dbc::pre("y out of bounds", origin_y + h < $map.$height);
  dbc::pre("x out of bounds", origin_x + w < $map.$width);

  for(size_t y = origin_y; y < origin_y + h; ++y) {
    for(size_t x = origin_x; x < origin_x + w; ++x) {
      $map.$walls[y][x] = INV_SPACE;
    }
  }
}


void WorldBuilder::place_rooms(Room &cur) {
  for(auto &cur : $map.$rooms) {
    cur.x += 2;
    cur.y += 2;
    cur.width -= 4;
    cur.height -= 4;
    add_door(cur);
    set_door(cur, INV_SPACE);
    make_room(cur.x, cur.y, cur.width, cur.height);
  }
}

bool WorldBuilder::dig_tunnel(Point &src, Point &target) {
  Matrix &paths = $map.paths();
  Matrix &walls = $map.walls();

  walls[src.y][src.x] = INV_WALL;
  walls[target.y][target.x] = INV_WALL;

  // for the walk this needs to be walls since it's inverted?
  dbc::check(walls[src.y][src.x] == INV_WALL,
      "src room has a wall at exit door");
  dbc::check(walls[target.y][target.x] == INV_WALL,
      "target room has a wall at entry door");

  $map.make_paths();
  bool found = false;
  Point out{src.x, src.y};
  int count = 0;

  do {
    walls[out.y][out.x] = INV_SPACE;
    found = $map.neighbors(out, true);

    if(paths[out.y][out.x] == 0) {
      walls[out.y][out.x] = INV_SPACE;
      return true;
    }
  } while(found && out.x > 0 && out.y > 0 && ++count < 100);

  return false;
}