Strategy.cpp

#include "Strategy.hpp"

Strategy::Strategy(const std::vector<std::string_view> & lines)
{
  if (!util::doIfNameMatch(std::regex("Strategy : ((incremental)|(sequential))"), lines[0], [this](auto sm)
  {type = sm[1] == "sequential" ? Type::Sequential : Type::Incremental;}))
  util::myThrow(fmt::format("Invalid strategy identifier '{}'", lines[0]));

  for (unsigned int i = 1; i < lines.size(); i++)
  {
    auto splited = util::split(lines[i], ' ');
    std::pair<std::string, std::string> key;
    std::string value;

    if (splited.size() == 2)
    {
      key = std::pair<std::string,std::string>(splited[0], "");
      value = splited[1];
      defaultCycle.emplace_back(value);
    }
    else if (splited.size() == 3)
    {
      key = std::pair<std::string,std::string>(splited[0], splited[1]);
      value = splited[1];
    }
    else
      util::myThrow(fmt::format("Invalid strategy line '{}'", lines[i]));

    if (edges.count(key))
      util::myThrow(fmt::format("Edge {} {} defined twice", key.first, key.second));
    edges[key] = value;
    isDone[key.first] = false;
  }

  if (edges.empty())
    util::myThrow("Strategy is empty");
  defaultCycle.pop_back();
  std::reverse(defaultCycle.begin(), defaultCycle.end());

  for (auto & s : defaultCycle)
    fmt::print("{}\n", s);
}

std::pair<std::string, int> Strategy::getMovement(const Config & c, const std::string & transition)
{
  if (c.stateIsDone())
    isDone[c.getState()] = true;

  while (defaultCycle.size() && isDone[defaultCycle.back()])
    defaultCycle.pop_back();

  if (type == Type::Sequential)
    return getMovementSequential(c, transition);

  return getMovementIncremental(c, transition);
}

std::pair<std::string, int> Strategy::getMovementSequential(const Config & c, const std::string & transition)
{
  auto foundSpecific = edges.find(std::make_pair(c.getState(), transition));
  auto foundGeneric = edges.find(std::make_pair(c.getState(), ""));

  std::string target;

  if (foundSpecific != edges.end())
    target = foundSpecific->second;
  else if (foundGeneric != edges.end())
    target = foundGeneric->second;

  if (target.empty())
    util::myThrow(fmt::format("no suitable movement found for current state '{}' and transition '{}'", c.getState(), transition));

  if (!c.stateIsDone())
    return {c.getState(), (c.getState() == target) && edges.size() > 1 ? 0 : 1};

  if (!isDone[target])
    return {target, -c.getWordIndex()};

  return endMovement;
}

std::pair<std::string, int> Strategy::getMovementIncremental(const Config & c, const std::string & transition)
{
  auto foundSpecific = edges.find(std::make_pair(c.getState(), transition));
  auto foundGeneric = edges.find(std::make_pair(c.getState(), ""));

  std::string target;

  if (foundSpecific != edges.end())
    target = foundSpecific->second;
  else if (foundGeneric != edges.end())
    target = foundGeneric->second;

  if (target.empty())
    util::myThrow(fmt::format("no suitable movement found for current state '{}' and transition '{}'", c.getState(), transition));

  if (!isDone[target])
    return {target, target == defaultCycle.back() ? 1 : 0};

  if (defaultCycle.empty())
    return endMovement;

  return {defaultCycle.back(), 1};
}