#include "factory/core/project.h"
#include <algorithm>
#include <array>
#include <set>
#include <stdexcept>

namespace factory {
bool Project::contains(Position p) const {
  return p.x >= 0 && p.y >= 0 && p.x < width && p.y < height;
}
Tile Project::tile(Position p) const {
  if (!contains(p))
    return Tile::Wall;
  return tiles.at(static_cast<std::size_t>(p.y) * static_cast<std::size_t>(width) +
                  static_cast<std::size_t>(p.x));
}
void Project::setTile(Position p, Tile value) {
  if (!contains(p))
    throw std::out_of_range("Position outside map");
  tiles.at(static_cast<std::size_t>(p.y) * static_cast<std::size_t>(width) +
           static_cast<std::size_t>(p.x)) = value;
}
bool Project::traversable(Position p) const {
  const auto value = tile(p);
  return contains(p) && value != Tile::Floor && value != Tile::Wall;
}
std::vector<Position> Project::neighbors(Position p) const {
  std::vector<Position> result;
  for (const auto delta : std::array<Position, 4>{{{1, 0}, {0, 1}, {-1, 0}, {0, -1}}}) {
    Position next{p.x + delta.x, p.y + delta.y};
    if (traversable(next))
      result.push_back(next);
  }
  return result;
}
int Project::roadCount() const { return static_cast<int>(std::ranges::count(tiles, Tile::Road)); }
std::vector<std::string> Project::validate() const {
  std::vector<std::string> errors;
  if (width < 3 || height < 3 || width > 128 || height > 128 ||
      tiles.size() != static_cast<std::size_t>(width) * static_cast<std::size_t>(height)) {
    errors.emplace_back("Map dimensions must be 3..128 and match the tile count");
    return errors;
  }
  if (name.empty() || name.size() > 200)
    errors.emplace_back("Project needs a name of 1..200 bytes");
  if (tickLimit < 1 || tickLimit > 1000000)
    errors.emplace_back("Tick limit must be 1..1000000");
  if (roadBudget < 0 || roadCount() > roadBudget)
    errors.emplace_back("Road budget exceeded");
  if (vehicleBudget < 1 || vehicleBudget > 50 || vehicles.empty() ||
      vehicles.size() > static_cast<std::size_t>(vehicleBudget))
    errors.emplace_back("Vehicle budget must allow 1..50 vehicles");
  if (orders.empty() || orders.size() > 10000)
    errors.emplace_back("Add 1..10000 delivery orders");
  std::set<int> ids;
  std::set<Position> homes;
  for (const auto& vehicle : vehicles) {
    if (vehicle.id < 1 || !ids.insert(vehicle.id).second || !homes.insert(vehicle.home).second ||
        !traversable(vehicle.home))
      errors.emplace_back("Vehicles need unique IDs and distinct traversable home cells");
  }
  ids.clear();
  for (const auto& order : orders) {
    if (order.id < 1 || !ids.insert(order.id).second || order.pickup == order.delivery ||
        !contains(order.pickup) || !contains(order.delivery)) {
      errors.emplace_back("Orders need unique IDs and distinct valid endpoints");
      continue;
    }
    const auto pickup = tile(order.pickup), delivery = tile(order.delivery);
    if ((pickup != Tile::Source && pickup != Tile::Storage) ||
        (delivery != Tile::Sink && delivery != Tile::Storage))
      errors.emplace_back("Orders must connect source/storage to sink/storage");
  }
  return errors;
}
std::string tileName(Tile value) {
  constexpr std::array names{"floor", "road", "wall", "source", "storage", "sink"};
  return names.at(static_cast<std::size_t>(value));
}
Tile tileFromName(const std::string& name) {
  for (int i = 0; i < 6; ++i) {
    const auto value = static_cast<Tile>(i);
    if (tileName(value) == name)
      return value;
  }
  throw std::invalid_argument("Unknown tile: " + name);
}
} // namespace factory
