path: root/src/openvic-simulation/politics/Rule.cpp

#include "Rule.hpp"

#include "openvic-simulation/economy/BuildingType.hpp"
#include "openvic-simulation/utility/TslHelper.hpp"

using namespace OpenVic;
using namespace OpenVic::NodeTools;

Rule::Rule(std::string_view new_identifier, rule_group_t new_group, index_t new_index)
  : HasIdentifier { new_identifier }, HasIndex { new_index }, group { new_group } {}

RuleSet::RuleSet(rule_group_map_t&& new_rule_groups) : rule_groups { std::move(new_rule_groups) } {}

bool RuleSet::trim_and_resolve_conflicts(bool log) {
   bool ret = true;
   for (auto [group, rule_map] : mutable_iterator(rule_groups)) {
      if (Rule::is_mutually_exclusive_group(group)) {
         Rule const* primary_rule = nullptr;
         for (auto const& [rule, value] : rule_map) {
            if (value) {
               if (primary_rule == nullptr) {
                  primary_rule = rule;
               } else {
                  if (primary_rule->get_index() < rule->get_index()) {
                     primary_rule = rule;
                  }
                  ret = false;
               }
            }
         }
         if (log) {
            for (auto const& [rule, value] : rule_map) {
               if (value) {
                  if (rule != primary_rule) {
                     Logger::error(
                        "Conflicting mutually exclusive rule: ", rule, " superceeded by ", primary_rule, " - removing!"
                     );
                  }
               } else {
                  Logger::warning("Disabled mutually exclusive rule: ", rule, " - removing!");
               }
            }
         }
         rule_map.clear();
         if (primary_rule != nullptr) {
            rule_map.emplace(primary_rule, true);
         }
      }
   }
   return ret;
}

size_t RuleSet::get_rule_group_count() const {
   return rule_groups.size();
}

size_t RuleSet::get_rule_count() const {
   size_t ret = 0;
   for (auto const& [group, rule_map] : rule_groups) {
      ret += rule_map.size();
   }
   return ret;
}

void RuleSet::clear() {
   rule_groups.clear();
}

bool RuleSet::empty() const {
   for (auto const& [group, rule_map] : rule_groups) {
      if (!rule_map.empty()) {
         return false;
      }
   }

   return true;
}

RuleSet::rule_map_t const& RuleSet::get_rule_group(Rule::rule_group_t group, bool* successful) const {
   const rule_group_map_t::const_iterator it = rule_groups.find(group);
   if (it != rule_groups.end()) {
      if (successful != nullptr) {
         *successful = true;
      }
      return it->second;
   }
   if (successful != nullptr) {
      *successful = false;
   }
   static const rule_map_t empty_map {};
   return empty_map;
}

bool RuleSet::get_rule(Rule const* rule, bool* successful) const {
   if (rule == nullptr) {
      Logger::error("Invalid rule - null!");
      return false;
   }
   rule_map_t const& rule_map = get_rule_group(rule->get_group());
   const rule_map_t::const_iterator it = rule_map.find(rule);
   if (it != rule_map.end()) {
      if (successful != nullptr) {
         *successful = true;
      }
      return it->second;
   }
   if (successful != nullptr) {
      *successful = false;
   }
   return Rule::is_default_enabled(rule->get_group());
}

bool RuleSet::has_rule(Rule const* rule) const {
   if (rule == nullptr) {
      Logger::error("Invalid rule - null!");
      return false;
   }
   return get_rule_group(rule->get_group()).contains(rule);
}

bool RuleSet::set_rule(Rule const* rule, bool value) {
   if (rule == nullptr) {
      Logger::error("Invalid rule - null!");
      return false;
   }
   rule_groups[rule->get_group()][rule] = value;
   return true;
}

RuleSet& RuleSet::operator|=(RuleSet const& right) {
   for (auto const& [group, rule_map] : right.rule_groups) {
      for (auto const& [rule, value] : rule_map) {
         rule_groups[group][rule] |= value;
      }
   }
   return *this;
}

RuleSet RuleSet::operator|(RuleSet const& right) const {
   RuleSet ret = *this;
   return ret |= right;
}

bool RuleManager::add_rule(std::string_view identifier, Rule::rule_group_t group) {
   if (identifier.empty()) {
      Logger::error("Invalid rule identifier - empty!");
      return false;
   }
   return rules.add_item({ identifier, group, rule_group_sizes[group]++ });
}

bool RuleManager::setup_rules(BuildingTypeManager const& building_type_manager) {
   bool ret = true;

   using enum Rule::rule_group_t;

   static const ordered_map<Rule::rule_group_t, std::vector<std::string_view>> hardcoded_rules {
      { ECONOMY, {
         "expand_factory", "open_factory", "destroy_factory", "pop_build_factory", "pop_expand_factory", "pop_open_factory",
         "can_subsidise", "factory_priority", "delete_factory_if_no_input", "build_factory_invest", "expand_factory_invest",
         "open_factory_invest", "build_railway_invest", "pop_build_factory_invest", "pop_expand_factory_invest",
         "pop_open_factory_invest", "can_invest_in_pop_projects", "allow_foreign_investment"
      } },
      { CITIZENSHIP, { "primary_culture_voting", "culture_voting", "all_voting" } },
      { SLAVERY, { "slavery_allowed" } },
      { UPPER_HOUSE, { "same_as_ruling_party", "rich_only", "state_vote", "population_vote" } },
      { VOTING, {
         "largest_share" /* First Past the Post */,
         "dhont" /* Jefferson Method */,
         "sainte_laque" /* Proportional Representation */
      } }
   };

   size_t rule_count = building_type_manager.get_building_type_types().size();
   for (auto const& [group, rule_list] : hardcoded_rules) {
      rule_count += rule_list.size();
   }
   reserve_more_rules(rule_count);

   for (auto const& [group, rule_list] : hardcoded_rules) {
      for (std::string_view const& rule : rule_list) {
         ret &= add_rule(rule, group);
      }
   }

   for (std::string const& type : building_type_manager.get_building_type_types()) {
      std::string build_rule_string = "build_";
      if (type != "infrastructure") {
         build_rule_string += type;
      } else {
         build_rule_string += "railway";
      }
      ret &= add_rule(build_rule_string, ECONOMY);
   }

   lock_rules();

   return ret;
}

node_callback_t RuleManager::expect_rule_set(callback_t<RuleSet&&> ruleset_callback) const {
   return [this, ruleset_callback](ast::NodeCPtr root) -> bool {
      RuleSet ruleset;
      bool ret = expect_dictionary(
         [this, &ruleset](std::string_view rule_key, ast::NodeCPtr rule_value) -> bool {
            Rule const* rule = get_rule_by_identifier(rule_key);
            if (rule != nullptr) {
               return expect_bool(
                  [&ruleset, rule](bool value) -> bool {
                     /* Wrapped in a lambda function so that the rule group is only initialised
                      * if the value bool is successfully parsed. */
                     return map_callback(ruleset.rule_groups[rule->get_group()], rule)(value);
                  }
               )(rule_value);
            } else {
               Logger::error("Invalid rule identifier: ", rule_key);
               return false;
            }
         }
      )(root);
      ret &= ruleset.trim_and_resolve_conflicts(true);
      ret &= ruleset_callback(std::move(ruleset));
      return ret;
   };
}

namespace OpenVic { // so the compiler shuts up (copied from Modifier.cpp)
   std::ostream& operator<<(std::ostream& stream, RuleSet const& value) {
      for (auto const& [group, rule_map] : value.rule_groups) {
         for (auto const& [rule, value] : rule_map) {
            stream << rule << ": " << (value ? "yes" : "no") << "\n";
         }
      }
      return stream;
   }
}