path: root/src/openvic-simulation/history/ProvinceHistory.cpp

#include "ProvinceHistory.hpp"

#include "openvic-simulation/DefinitionManager.hpp"
#include "openvic-simulation/economy/GoodDefinition.hpp"
#include "openvic-simulation/map/ProvinceDefinition.hpp"

using namespace OpenVic;
using namespace OpenVic::NodeTools;

ProvinceHistoryEntry::ProvinceHistoryEntry(ProvinceDefinition const& new_province, Date new_date)
   : HistoryEntry { new_date }, province { new_province } {}

ProvinceHistoryMap::ProvinceHistoryMap(ProvinceDefinition const& new_province) : province { new_province } {}

std::unique_ptr<ProvinceHistoryEntry> ProvinceHistoryMap::_make_entry(Date date) const {
   return std::unique_ptr<ProvinceHistoryEntry> { new ProvinceHistoryEntry { province, date } };
}

bool ProvinceHistoryMap::_load_history_entry(
   DefinitionManager const& definition_manager, ProvinceHistoryEntry& entry, ast::NodeCPtr root
) {
   BuildingTypeManager const& building_type_manager = definition_manager.get_economy_manager().get_building_type_manager();
   CountryDefinitionManager const& country_definition_manager = definition_manager.get_country_definition_manager();
   GoodDefinitionManager const& good_definition_manager =
      definition_manager.get_economy_manager().get_good_definition_manager();
   IdeologyManager const& ideology_manager = definition_manager.get_politics_manager().get_ideology_manager();
   TerrainTypeManager const& terrain_type_manager = definition_manager.get_map_definition().get_terrain_type_manager();

   using enum ProvinceInstance::colony_status_t;
   static const string_map_t<ProvinceInstance::colony_status_t> colony_status_map {
      { "0", STATE }, { "1", PROTECTORATE }, { "2", COLONY }
   };

   const auto set_core_instruction = [&entry](bool add) {
      return [&entry, add](CountryDefinition const& country) -> bool {
         const auto it = entry.cores.find(&country);
         if (it == entry.cores.end()) {
            // No current core instruction
            entry.cores.emplace(&country, add);
            return true;
         } else if (it->second == add) {
            // Desired core instruction already exists
            Logger::warning(
               "Duplicate attempt to ", add ? "add" : "remove", " core of country ", country.get_identifier(),
               " ", add ? "to" : "from", " province history of ", entry.get_province()
            );
            return true;
         } else {
            // Opposite core instruction exists
            entry.cores.erase(it);
            Logger::warning(
               "Attempted to ", add ? "add" : "remove", " core of country ", country.get_identifier(),
               " ", add ? "to" : "from", " province history of ", entry.get_province(),
               " after previously ", add ? "adding" : "removing", " it"
            );
            return true;
         }
      };
   };

   constexpr bool allow_empty_true = true;
   constexpr bool do_warn = true;

   return expect_dictionary_keys_and_default(
      [this, &definition_manager, &building_type_manager, &entry](
         std::string_view key, ast::NodeCPtr value) -> bool {
         // used for province buildings like forts or railroads
         BuildingType const* building_type = building_type_manager.get_building_type_by_identifier(key);
         if (building_type != nullptr) {
            if (building_type->is_in_province()) {
               return expect_uint<BuildingType::level_t>(
                  /* This is set to warn to prevent vanilla from always having errors because
                   * of a duplicate railroad entry in the 1861.1.1 history of Manchester (278). */
                  map_callback(entry.province_buildings, building_type, true)
               )(value);
            } else {
               Logger::error(
                  "Attempted to add state building \"", building_type, "\" at top scope of province history for ",
                  entry.get_province()
               );
               return false;
            }
         }

         return _load_history_sub_entry_callback(definition_manager, entry.get_date(), value, key, value);
      },
      "owner", ZERO_OR_ONE, country_definition_manager.expect_country_definition_identifier(
         assign_variable_callback_pointer_opt(entry.owner, true)
      ),
      "controller", ZERO_OR_ONE, country_definition_manager.expect_country_definition_identifier(
         assign_variable_callback_pointer_opt(entry.controller, true)
      ),
      "add_core", ZERO_OR_MORE, country_definition_manager.expect_country_definition_identifier(
         set_core_instruction(true)
      ),
      "remove_core", ZERO_OR_MORE, country_definition_manager.expect_country_definition_identifier(
         set_core_instruction(false)
      ),
      "colonial", ZERO_OR_ONE,
         expect_identifier(expect_mapped_string(colony_status_map, assign_variable_callback(entry.colonial))),
      "colony", ZERO_OR_ONE,
         expect_identifier(expect_mapped_string(colony_status_map, assign_variable_callback(entry.colonial))),
      "is_slave", ZERO_OR_ONE, expect_bool(assign_variable_callback(entry.slave)),
      "trade_goods", ZERO_OR_ONE,
         good_definition_manager.expect_good_definition_identifier_or_string(
            [&definition_manager, &entry](GoodDefinition const& rgo_good) ->bool {
               entry.rgo_production_type = definition_manager.get_economy_manager().get_production_type_manager().get_good_to_rgo_production_type()[rgo_good];
               return entry.rgo_production_type != nullptr;
               //we expect the good to have an rgo production type
               //Victoria 2 treats this as null, but clearly the modder wanted there to be a good
            },
            allow_empty_true, //could be explicitly setting trade_goods to null
            do_warn //could be typo in good identifier
         ),
      "life_rating", ZERO_OR_ONE, expect_uint<ProvinceInstance::life_rating_t>(assign_variable_callback(entry.life_rating)),
      "terrain", ZERO_OR_ONE, terrain_type_manager.expect_terrain_type_identifier(
         assign_variable_callback_pointer_opt(entry.terrain_type)
      ),
      "party_loyalty", ZERO_OR_MORE, [&ideology_manager, &entry](ast::NodeCPtr node) -> bool {
         Ideology const* ideology = nullptr;
         fixed_point_t amount = 0; /* PERCENTAGE_DECIMAL */

         bool ret = expect_dictionary_keys(
            "ideology", ONE_EXACTLY, ideology_manager.expect_ideology_identifier(
               assign_variable_callback_pointer(ideology)
            ),
            "loyalty_value", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(amount))
         )(node);
         if (ideology != nullptr) {
            ret &= map_callback(entry.party_loyalties, ideology)(amount);
         }
         return ret;
      },
      "state_building", ZERO_OR_MORE, [&building_type_manager, &entry](ast::NodeCPtr node) -> bool {
         BuildingType const* building_type = nullptr;
         uint8_t level = 0;

         bool ret = expect_dictionary_keys(
            "level", ONE_EXACTLY, expect_uint(assign_variable_callback(level)),
            "building", ONE_EXACTLY, building_type_manager.expect_building_type_identifier(
               assign_variable_callback_pointer(building_type)
            ),
            "upgrade", ZERO_OR_ONE, success_callback /* Doesn't appear to have an effect */
         )(node);
         if (building_type != nullptr) {
            if (!building_type->is_in_province()) {
               ret &= map_callback(entry.state_buildings, building_type)(level);
            } else {
               Logger::error(
                  "Attempted to add province building \"", building_type,
                  "\" to state building list of province history for ", entry.get_province()
               );
               ret = false;
            }
         }
         return ret;
      }
   )(root);
}

void ProvinceHistoryManager::reserve_more_province_histories(size_t size) {
   if (locked) {
      Logger::error("Failed to reserve space for ", size, " provinces in ProvinceHistoryManager - already locked!");
   } else {
      reserve_more(province_histories, size);
   }
}

void ProvinceHistoryManager::lock_province_histories(MapDefinition const& map_definition, bool detailed_errors) {
   std::vector<ProvinceDefinition> const& provinces = map_definition.get_province_definitions();

   std::vector<bool> province_checklist(provinces.size());
   for (auto [province, history_map] : mutable_iterator(province_histories)) {
      province_checklist[province->get_index() - 1] = true;

      history_map.sort_entries();
   }

   size_t missing = 0;
   for (size_t idx = 0; idx < province_checklist.size(); ++idx) {
      if (!province_checklist[idx]) {
         ProvinceDefinition const& province = provinces[idx];
         if (!province.is_water()) {
            if (detailed_errors) {
               Logger::warning("Province history missing for province: ", province.get_identifier());
            }
            missing++;
         }
      }
   }
   if (missing > 0) {
      Logger::warning("Province history is missing for ", missing, " provinces");
   }

   Logger::info("Locked province history registry after registering ", province_histories.size(), " items");
   locked = true;
}

bool ProvinceHistoryManager::is_locked() const {
   return locked;
}

ProvinceHistoryMap const* ProvinceHistoryManager::get_province_history(ProvinceDefinition const* province) const {
   if (province == nullptr) {
      Logger::error("Attempted to access history of null province");
      return nullptr;
   }
   decltype(province_histories)::const_iterator province_registry = province_histories.find(province);
   if (province_registry != province_histories.end()) {
      return &province_registry->second;
   } else {
      Logger::error("Attempted to access history of province ", province->get_identifier(), " but none has been defined!");
      return nullptr;
   }
}

ProvinceHistoryMap* ProvinceHistoryManager::_get_or_make_province_history(ProvinceDefinition const& province) {
   decltype(province_histories)::iterator it = province_histories.find(&province);
   if (it == province_histories.end()) {
      const std::pair<decltype(province_histories)::iterator, bool> result =
         province_histories.emplace(&province, ProvinceHistoryMap { province });
      if (result.second) {
         it = result.first;
      } else {
         Logger::error("Failed to create province history map for province ", province.get_identifier());
         return nullptr;
      }
   }
   return &it.value();
}

bool ProvinceHistoryManager::load_province_history_file(
   DefinitionManager const& definition_manager, ProvinceDefinition const& province, ast::NodeCPtr root
) {
   if (locked) {
      Logger::error(
         "Attempted to load province history file for ", province.get_identifier(),
         " after province history registry was locked!"
      );
      return false;
   }

   ProvinceHistoryMap* province_history = _get_or_make_province_history(province);
   if (province_history != nullptr) {
      return province_history->_load_history_file(definition_manager, root);
   } else {
      return false;
   }
}

bool ProvinceHistoryEntry::_load_province_pop_history(
   DefinitionManager const& definition_manager, ast::NodeCPtr root, bool *non_integer_size
) {
   PopManager const& pop_manager = definition_manager.get_pop_manager();
   RebelManager const& rebel_manager = definition_manager.get_politics_manager().get_rebel_manager();
   return pop_manager.expect_pop_type_dictionary_reserve_length(
      pops,
      [this, &pop_manager, &rebel_manager, non_integer_size](PopType const& pop_type, ast::NodeCPtr pop_node) -> bool {
         return pop_manager.load_pop_bases_into_vector(rebel_manager, pops, pop_type, pop_node, non_integer_size);
      }
   )(root);
}

bool ProvinceHistoryMap::_load_province_pop_history(
   DefinitionManager const& definition_manager, Date date, ast::NodeCPtr root, bool *non_integer_size
) {
   ProvinceHistoryEntry* entry = _get_or_make_entry(definition_manager, date);
   if (entry != nullptr) {
      return entry->_load_province_pop_history(definition_manager, root, non_integer_size);
   } else {
      return false;
   }
}

bool ProvinceHistoryManager::load_pop_history_file(
   DefinitionManager const& definition_manager, Date date, ast::NodeCPtr root, bool *non_integer_size
) {
   if (locked) {
      Logger::error("Attempted to load pop history file after province history registry was locked!");
      return false;
   }
   return definition_manager.get_map_definition().expect_province_definition_dictionary(
      [this, &definition_manager, date, non_integer_size](ProvinceDefinition const& province, ast::NodeCPtr node) -> bool {
         ProvinceHistoryMap* province_history = _get_or_make_province_history(province);
         if (province_history != nullptr) {
            return province_history->_load_province_pop_history(definition_manager, date, node, non_integer_size);
         } else {
            return false;
         }
      }
   )(root);
}