path: root/tools/datapacker/container.cpp

#include "container.h"

#include <iostream>

#include "util/naming.h"

namespace com::fourisland::lingo2_archipelago {

uint64_t Container::FindOrAddMap(std::string map_name) {
  auto it = map_id_by_name_.find(map_name);

  if (it == map_id_by_name_.end()) {
    uint64_t new_id = all_objects_.maps_size();
    Map* map = all_objects_.add_maps();
    map->set_id(new_id);
    map->set_name(map_name);

    map_id_by_name_[map_name] = new_id;

    return new_id;
  } else {
    return it->second;
  }
}

uint64_t Container::FindOrAddRoom(std::optional<std::string> map_name,
                                  std::string room_name,
                                  std::optional<std::string> map_fallback) {
  if (!map_name) {
    if (!map_fallback) {
      std::cout << "No map name provided for " << room_name << std::endl;
      map_name = "global";
    } else {
      map_name = map_fallback;
    }
  }

  auto& map_container = room_id_by_map_room_names_[*map_name];
  auto it = map_container.find(room_name);
  if (it == map_container.end()) {
    uint64_t new_id = all_objects_.rooms_size();
    Room* room = all_objects_.add_rooms();
    room->set_id(new_id);
    room->set_map_id(FindOrAddMap(*map_name));
    room->set_name(room_name);

    map_container[room_name] = new_id;

    return new_id;
  } else {
    return it->second;
  }
}

uint64_t Container::FindOrAddPainting(
    std::optional<std::string> map_name, std::optional<std::string> room_name,
    std::string painting_name, std::optional<std::string> map_fallback,
    std::optional<std::string> room_fallback) {
  if (!map_name) {
    if (!map_fallback) {
      std::cout << "No map name provided for " << painting_name << std::endl;
      map_name = "global";
    } else {
      map_name = map_fallback;
    }
  }

  if (!room_name) {
    if (!room_fallback) {
      std::cout << "No room name provided for " << painting_name << std::endl;
      room_name = "global";
    } else {
      room_name = room_fallback;
    }
  }

  auto& room_container =
      painting_id_by_map_room_painting_names_[*map_name][*room_name];
  auto it = room_container.find(painting_name);
  if (it == room_container.end()) {
    uint64_t new_id = all_objects_.paintings_size();
    PaintingData* painting = all_objects_.add_paintings();
    painting->set_id(new_id);
    painting->set_room_id(FindOrAddRoom(map_name, *room_name, std::nullopt));
    painting->set_name(painting_name);

    room_container[painting_name] = new_id;

    return new_id;
  } else {
    return it->second;
  }
}

uint64_t Container::FindOrAddPort(std::optional<std::string> map_name,
                                  std::optional<std::string> room_name,
                                  std::string port_name,
                                  std::optional<std::string> map_fallback,
                                  std::optional<std::string> room_fallback) {
  if (!map_name) {
    if (!map_fallback) {
      std::cout << "No map name provided for " << port_name << std::endl;
      map_name = "global";
    } else {
      map_name = map_fallback;
    }
  }

  if (!room_name) {
    if (!room_fallback) {
      std::cout << "No room name provided for " << port_name << std::endl;
      room_name = "global";
    } else {
      room_name = room_fallback;
    }
  }

  auto& room_container = port_id_by_map_room_port_names_[*map_name][*room_name];
  auto it = room_container.find(port_name);
  if (it == room_container.end()) {
    uint64_t new_id = all_objects_.ports_size();
    Port* port = all_objects_.add_ports();
    port->set_id(new_id);
    port->set_room_id(FindOrAddRoom(map_name, *room_name, std::nullopt));
    port->set_name(port_name);

    room_container[port_name] = new_id;

    return new_id;
  } else {
    return it->second;
  }
}

uint64_t Container::FindOrAddPanel(std::optional<std::string> map_name,
                                   std::optional<std::string> room_name,
                                   std::string panel_name,
                                   std::optional<std::string> map_fallback,
                                   std::optional<std::string> room_fallback) {
  if (!map_name) {
    if (!map_fallback) {
      std::cout << "No map name provided for " << panel_name << std::endl;
      map_name = "global";
    } else {
      map_name = map_fallback;
    }
  }

  if (!room_name) {
    if (!room_fallback) {
      std::cout << "No room name provided for " << panel_name << std::endl;
      room_name = "global";
    } else {
      room_name = room_fallback;
    }
  }

  auto& room_container =
      panel_id_by_map_room_panel_names_[*map_name][*room_name];
  auto it = room_container.find(panel_name);
  if (it == room_container.end()) {
    uint64_t new_id = all_objects_.panels_size();
    PanelData* panel = all_objects_.add_panels();
    panel->set_id(new_id);
    panel->set_room_id(FindOrAddRoom(map_name, *room_name, std::nullopt));
    panel->set_name(panel_name);

    room_container[panel_name] = new_id;

    return new_id;
  } else {
    return it->second;
  }
}

uint64_t Container::FindOrAddLetter(std::string key, bool level2) {
  std::string letter_name = GetLetterName(key, level2);

  auto it = letter_id_by_name_.find(letter_name);
  if (it == letter_id_by_name_.end()) {
    uint64_t new_id = all_objects_.letters_size();
    Letter* letter = all_objects_.add_letters();
    letter->set_id(new_id);
    letter->set_key(key);

    if (level2) {
      letter->set_level2(level2);
    }

    letter_id_by_name_[letter_name] = new_id;

    return new_id;
  } else {
    return it->second;
  }
}

uint64_t Container::FindLetterByName(std::string letter_name) {
  auto it = letter_id_by_name_.find(letter_name);
  if (it == letter_id_by_name_.end()) {
    std::cout << "Could not find letter by name: " << letter_name << std::endl;
    exit(2);
  } else {
    return it->second;
  }
}

uint64_t Container::FindOrAddEnding(std::string ending_name) {
  auto it = ending_id_by_name_.find(ending_name);
  if (it == ending_id_by_name_.end()) {
    uint64_t new_id = all_objects_.endings_size();
    Ending* ending = all_objects_.add_endings();
    ending->set_id(new_id);
    ending->set_name(ending_name);

    ending_id_by_name_[ending_name] = new_id;

    return new_id;
  } else {
    return it->second;
  }
}

uint64_t Container::FindOrAddMastery(std::optional<std::string> map_name,
                                     std::optional<std::string> room_name,
                                     std::string mastery_name,
                                     std::optional<std::string> map_fallback,
                                     std::optional<std::string> room_fallback) {
  if (!map_name) {
    if (!map_fallback) {
      std::cout << "No map name provided for " << mastery_name << std::endl;
      map_name = "global";
    } else {
      map_name = map_fallback;
    }
  }

  if (!room_name) {
    if (!room_fallback) {
      std::cout << "No room name provided for " << mastery_name << std::endl;
      room_name = "global";
    } else {
      room_name = room_fallback;
    }
  }

  auto& room_container =
      mastery_id_by_map_room_mastery_names_[*map_name][*room_name];
  auto it = room_container.find(mastery_name);
  if (it == room_container.end()) {
    uint64_t new_id = all_objects_.masteries_size();
    Mastery* mastery = all_objects_.add_masteries();
    mastery->set_id(new_id);
    mastery->set_room_id(FindOrAddRoom(map_name, *room_name, std::nullopt));
    mastery->set_name(mastery_name);

    room_container[mastery_name] = new_id;

    return new_id;
  } else {
    return it->second;
  }
}

uint64_t Container::FindOrAddKeyholder(
    std::optional<std::string> map_name, std::optional<std::string> room_name,
    std::string keyholder_name, std::optional<std::string> map_fallback,
    std::optional<std::string> room_fallback) {
  if (!map_name) {
    if (!map_fallback) {
      std::cout << "No map name provided for " << keyholder_name << std::endl;
      map_name = "global";
    } else {
      map_name = map_fallback;
    }
  }

  if (!room_name) {
    if (!room_fallback) {
      std::cout << "No room name provided for " << keyholder_name << std::endl;
      room_name = "global";
    } else {
      room_name = room_fallback;
    }
  }

  auto& room_container =
      keyholder_id_by_map_room_keyholder_names_[*map_name][*room_name];
  auto it = room_container.find(keyholder_name);
  if (it == room_container.end()) {
    uint64_t new_id = all_objects_.keyholders_size();
    KeyholderData* keyholder = all_objects_.add_keyholders();
    keyholder->set_id(new_id);
    keyholder->set_room_id(FindOrAddRoom(map_name, *room_name, std::nullopt));
    keyholder->set_name(keyholder_name);

    room_container[keyholder_name] = new_id;

    return new_id;
  } else {
    return it->second;
  }
}

uint64_t Container::FindOrAddDoor(std::optional<std::string> map_name,
                                  std::string door_name,
                                  std::optional<std::string> map_fallback) {
  if (!map_name) {
    if (!map_fallback) {
      std::cout << "No map name provided for " << door_name << std::endl;
      map_name = "global";
    } else {
      map_name = map_fallback;
    }
  }

  auto& map_container = door_id_by_map_door_names_[*map_name];
  auto it = map_container.find(door_name);
  if (it == map_container.end()) {
    uint64_t new_id = all_objects_.doors_size();
    Door* door = all_objects_.add_doors();
    door->set_id(new_id);
    door->set_map_id(FindOrAddMap(*map_name));
    door->set_name(door_name);

    map_container[door_name] = new_id;

    return new_id;
  } else {
    return it->second;
  }
}

uint64_t Container::FindOrAddProgressive(std::string prog_name) {
  auto it = progressive_id_by_name_.find(prog_name);

  if (it == progressive_id_by_name_.end()) {
    uint64_t new_id = all_objects_.progressives_size();
    Progressive* progressive = all_objects_.add_progressives();
    progressive->set_id(new_id);
    progressive->set_name(prog_name);

    progressive_id_by_name_[prog_name] = new_id;

    return new_id;
  } else {
    return it->second;
  }
}

uint64_t Container::FindOrAddDoorGroup(std::string group_name) {
  auto it = door_group_id_by_name_.find(group_name);

  if (it == door_group_id_by_name_.end()) {
    uint64_t new_id = all_objects_.door_groups_size();
    DoorGroup* door_group = all_objects_.add_door_groups();
    door_group->set_id(new_id);
    door_group->set_name(group_name);

    door_group_id_by_name_[group_name] = new_id;

    return new_id;
  } else {
    return it->second;
  }
}

void Container::AddConnection(const Connection& connection) {
  *all_objects_.add_connections() = connection;
}

}  // namespace com::fourisland::lingo2_archipelago