#pragma once
#include <vector>
#include <utility>
#include <string>
#include <random>

#define INV_WALL 0
#define INV_SPACE 1

#define WALL_VALUE 1
#define SPACE_VALUE 0

struct Point {
  size_t x = 0;
  size_t y = 0;
};

struct Room;

struct Room {
  size_t x = 0;
  size_t y = 0;
  size_t width = 0;
  size_t height = 0;
  Point entry;
  Point exit;
};

typedef std::vector<Point> PointList;
typedef std::vector<int> MatrixRow;
typedef std::vector<MatrixRow> Matrix;

void dump_map(const std::string &msg, Matrix &map);
void add_neighbors(Matrix &closed, size_t j, size_t i);

class Map {
  Matrix input_map_;
  Matrix walls_;
  Matrix paths_;
  std::vector<Room> rooms_;
  int limit_ = 0;
public:

  // make explicit
  Map(Matrix input_map, Matrix walls_map, int limit) :
    input_map_(input_map),
    walls_(walls_map), limit_(limit) {
  }

  // make random
  Map(size_t width, size_t height);

  // disable copying
  Map(Map &map) = delete;

  Matrix& paths() { return paths_; }
  Matrix& input_map() { return input_map_; }
  Matrix& walls() { return walls_; }
  int limit() { return limit_; }
  size_t width() { return walls_[0].size(); }
  size_t height() { return walls_.size(); }
  Room &room(size_t at) {
    return rooms_[at];
  }

  size_t room_count() {
    return rooms_.size();
  }

  void make_room(size_t origin_y, size_t origin_x, size_t width, size_t height);

  void add_door(Room &room);
  bool inmap(size_t x, size_t y);
  bool iswall(size_t x, size_t y);
  bool neighbors(Point &out, bool up);
  void generate();
  void place_rooms(Room &root);
  void make_paths();
  void partition_map(Room &cur, int depth);
  void set_target(Point &at, int value=0);
  void clear_target(Point &at);
  bool walk(Point &src, Point &target);
  void set_door(Room &room, int value);
  void dump();
};