path: root/src/openvic-simulation/map/Province.cpp

#include "Province.hpp"

#include "openvic-simulation/history/ProvinceHistory.hpp"

using namespace OpenVic;
using namespace OpenVic::NodeTools;

Province::Province(
   std::string_view new_identifier, colour_t new_colour, index_t new_index
) : HasIdentifierAndColour { new_identifier, new_colour, true, false }, index { new_index },
   buildings { "buildings", false } {
   assert(index != NULL_INDEX);
}

Province::index_t Province::get_index() const {
   return index;
}

Region* Province::get_region() const {
   return region;
}

bool Province::get_on_map() const {
   return on_map;
}

bool Province::get_has_region() const {
   return has_region;
}

bool Province::get_water() const {
   return water;
}

TerrainType const* Province::get_terrain_type() const {
   return terrain_type;
}

Province::life_rating_t Province::get_life_rating() const {
   return life_rating;
}

Province::colony_status_t Province::get_colony_status() const {
   return colony_status;
}

Country const* Province::get_owner() const {
   return owner;
}

Country const* Province::get_controller() const {
   return controller;
}

std::vector<Country const*> const& Province::get_cores() const {
   return cores;
}

bool Province::is_slave() const {
   return slave;
}

bool Province::load_positions(BuildingManager const& building_manager, ast::NodeCPtr root) {
   return expect_dictionary_keys(
      "text_position", ZERO_OR_ONE, expect_fvec2(assign_variable_callback(positions.text)),
      "text_rotation", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(positions.text_rotation)),
      "text_scale", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(positions.text_scale)),
      "unit", ZERO_OR_ONE, expect_fvec2(assign_variable_callback(positions.unit)),
      "town", ZERO_OR_ONE, expect_fvec2(assign_variable_callback(positions.city)),
      "city", ZERO_OR_ONE, expect_fvec2(assign_variable_callback(positions.city)),
      "factory", ZERO_OR_ONE, expect_fvec2(assign_variable_callback(positions.factory)),
      "building_construction", ZERO_OR_ONE, expect_fvec2(assign_variable_callback(positions.building_construction)),
      "military_construction", ZERO_OR_ONE, expect_fvec2(assign_variable_callback(positions.military_construction)),
      "building_position", ZERO_OR_ONE, expect_dictionary_keys(
         "fort", ZERO_OR_ONE, expect_fvec2(assign_variable_callback(positions.fort)),
         "railroad", ZERO_OR_ONE, expect_fvec2(assign_variable_callback(positions.railroad)),
         "naval_base", ZERO_OR_ONE, expect_fvec2(assign_variable_callback(positions.navalbase))
      ),
      "building_rotation", ZERO_OR_ONE, expect_dictionary_keys(
         "fort", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(positions.fort_rotation)),
         "railroad", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(positions.railroad_rotation)),
         "naval_base", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(positions.navalbase_rotation)),
         "aeroplane_factory", ZERO_OR_ONE, success_callback /* see below */
      ),
      /* the below are esoteric clausewitz leftovers that either have no impact or whose functionality is lost to time */
      "spawn_railway_track", ZERO_OR_ONE, success_callback,
      "railroad_visibility", ZERO_OR_ONE, success_callback,
      "building_nudge", ZERO_OR_ONE, success_callback
   )(root);
}

bool Province::add_building(BuildingInstance&& building_instance) {
   return buildings.add_item(std::move(building_instance));
}

void Province::reset_buildings() {
   buildings.reset();
}

bool Province::expand_building(std::string_view building_type_identifier) {
   BuildingInstance* building = buildings.get_item_by_identifier(building_type_identifier);
   if (building == nullptr) {
      return false;
   }
   return building->expand();
}

Good const* Province::get_rgo() const {
   return rgo;
}

std::string Province::to_string() const {
   std::stringstream stream;
   stream << "(#" << std::to_string(index) << ", " << get_identifier() << ", 0x" << colour_to_hex_string() << ")";
   return stream.str();
}

bool Province::load_pop_list(PopManager const& pop_manager, ast::NodeCPtr root) {
   return expect_dictionary_reserve_length(pops,
      [this, &pop_manager](std::string_view pop_type_identifier, ast::NodeCPtr pop_node) -> bool {
         return pop_manager.load_pop_into_province(*this, pop_type_identifier, pop_node);
      }
   )(root);
}

bool Province::add_pop(Pop&& pop) {
   if (!get_water()) {
      pops.push_back(std::move(pop));
      return true;
   } else {
      Logger::error("Trying to add pop to water province ", get_identifier());
      return false;
   }
}

void Province::clear_pops() {
   pops.clear();
}

size_t Province::get_pop_count() const {
   return pops.size();
}

std::vector<Pop> const& Province::get_pops() const {
   return pops;
}

Pop::pop_size_t Province::get_total_population() const {
   return total_population;
}

/* REQUIREMENTS:
 * MAP-65, MAP-68, MAP-70, MAP-234
 */
void Province::update_pops() {
   total_population = 0;
   pop_type_distribution.clear();
   ideology_distribution.clear();
   culture_distribution.clear();
   religion_distribution.clear();
   for (Pop const& pop : pops) {
      total_population += pop.get_size();
      pop_type_distribution[&pop.get_type()] += pop.get_size();
      //ideology_distribution[&pop.get_???()] += pop.get_size();
      culture_distribution[&pop.get_culture()] += pop.get_size();
      religion_distribution[&pop.get_religion()] += pop.get_size();
   }
}

void Province::update_state(Date today) {
   for (BuildingInstance& building : buildings.get_items()) {
      building.update_state(today);
   }
   update_pops();
}

void Province::tick(Date today) {
   for (BuildingInstance& building : buildings.get_items()) {
      building.tick(today);
   }
}

Province::adjacency_t::adjacency_t(Province const* province, distance_t distance, flags_t flags)
   : province { province }, distance { distance }, flags { flags } {
   assert(province != nullptr);
}

Province::distance_t Province::adjacency_t::get_distance() const {
   return distance;
}

Province::flags_t Province::adjacency_t::get_flags() const {
   return flags;
}

bool Province::is_adjacent_to(Province const* province) {
   for (adjacency_t adj : adjacencies) {
      if (adj.province == province) {
         return true;
      }
   }
   return false;
}

bool Province::add_adjacency(Province const* province, distance_t distance, flags_t flags) {
   if (province == nullptr) {
      Logger::error("Tried to create null adjacency province for province ", get_identifier(), "!");
      return false;
   }

   if (is_adjacent_to(province)) {
      return false;
   }
   adjacencies.push_back({ province, distance, flags });
   return true;
}

std::vector<Province::adjacency_t> const& Province::get_adjacencies() const {
   return adjacencies;
}

void Province::_set_terrain_type(TerrainType const* type) {
   terrain_type = type;
}

void Province::apply_history_to_province(ProvinceHistoryMap const& history, Date date) {
   auto entries = history.get_entries(date);
   
   reset_buildings();

   for (const auto& entry : entries) {
      if (entry->get_life_rating()) life_rating = *entry->get_life_rating();
      if (entry->get_colonial()) colony_status = *entry->get_colonial();
      if (entry->get_rgo()) rgo = *entry->get_rgo();
      if (entry->get_terrain_type()) terrain_type = *entry->get_terrain_type();
      if (entry->get_owner()) owner = *entry->get_owner();
      if (entry->get_controller()) controller = *entry->get_controller();
      if (entry->get_slave()) slave = *entry->get_slave();
      for (const auto& core : entry->get_remove_cores()) {
         const auto existing_core = std::find(cores.begin(), cores.end(), core);
         if (existing_core != cores.end()) cores.erase(existing_core);
      }
      for (const auto& core : entry->get_add_cores()) {
         const auto existing_core = std::find(cores.begin(), cores.end(), core);
         if (existing_core == cores.end()) cores.push_back(core);
      }
      // TODO: rework province buildings
      for (const auto& building : entry->get_buildings()) {
         BuildingInstance* existing_entry = buildings.get_item_by_identifier(building.first->get_identifier());
         if (existing_entry != nullptr) {
            existing_entry->set_level(building.second);
         } else {
            BuildingInstance instance = { *building.first };
            instance.set_level(building.second);
            add_building(std::move(instance));
         }
      }
      // TODO: party loyalties for each POP when implemented on POP side
   }
}