#include <iostream>
#include <vector>
#include <tuple>
#include <string>
#include <experimental/map>
#include <utility>

using namespace std;

// Перечислимый тип для статуса задачи
enum class TaskStatus {
  NEW,          // новая
  IN_PROGRESS,  // в разработке
  TESTING,      // на тестировании
  DONE          // завершена
};

// Объявляем тип-синоним для map<TaskStatus, int>,
// позволяющего хранить количество задач каждого статуса
using TasksInfo = map<TaskStatus, int>;

class TeamTasks {
public:
  // Получить статистику по статусам задач конкретного разработчика
  const TasksInfo& GetPersonTasksInfo(const string& person) const{
    return TasksPerPerson.at(person);
  }

  // Добавить новую задачу (в статусе NEW) для конкретного разработчитка
  void AddNewTask(const string& person){
    ++TasksPerPerson[person][TaskStatus::NEW];
  }

  // Обновить статусы по данному количеству задач конкретного разработчика
  tuple<TasksInfo, TasksInfo> PerformPersonTasks(
      const string& person, int task_count){
        TasksInfo Old = TasksPerPerson[person];
        TasksInfo Updated = TasksPerPerson[person];
        int not_done = Updated[TaskStatus::NEW] + Updated[TaskStatus::IN_PROGRESS] +
                      Updated[TaskStatus::TESTING];
        if(task_count > not_done){
          task_count = not_done;
        }
        vector<pair<int,int>> changes(4);
        for(int i = 0; i < 3; ++i){
          if(Updated[TaskStatus(i)] > task_count){
            Updated[TaskStatus(i)] -= task_count;
            changes[i].second -= task_count;
            changes[i+1].first += task_count;
            Updated[TaskStatus(i+1)] += task_count;
            break;
          } else {
            task_count -= Updated[TaskStatus(i)];
            changes[i].second -= task_count;
            changes[i+1].first += task_count;
            Updated[TaskStatus(i)] = 0;
            Updated[TaskStatus(i+1)] += task_count;
          }
        }
        TasksInfo Untouched;
        TasksInfo Touched;
        for(int i = 0; i < 4; ++i){
          int res = changes[i].first + changes[i].second;
          if(res == 0){
            Touched[TaskStatus(i)] = changes[i].first;
            Untouched[TaskStatus(i)] = changes[i].first;
          } else if(res < 0){
            Untouched[TaskStatus(i)] = Updated[TaskStatus(i)];
            Touched[TaskStatus(i)] = 0;
          } else {
            Untouched[TaskStatus(i)] = 0;
            Touched[TaskStatus(i)] = Updated[TaskStatus(i)];
          }
        }

        for (auto *map : {&Touched, &Untouched, &Updated})
          std::experimental::erase_if(*map, [](const auto &x){return x.second == 0;});

        TasksPerPerson[person] = Updated;

        return tie(Touched,Untouched); /*tie(Updated, Old);*/
      }
private:
    map<string, TasksInfo> TasksPerPerson;
};

void PrintTasksInfo(TasksInfo tasks_info) {
  /*
  cout << tasks_info[TaskStatus::NEW] << " new tasks" <<
      ", " << tasks_info[TaskStatus::IN_PROGRESS] << " tasks in progress" <<
      ", " << tasks_info[TaskStatus::TESTING] << " tasks are being tested" <<
      ", " << tasks_info[TaskStatus::DONE] << " tasks are done" << endl;
  */
  string names[4] {"new","in_progress","testing","done"};

  for (const auto &it : tasks_info)
    cout << names[int(it.first)] << "=" << it.second << " ";
  cout << '\n';
}

int main() {
  TeamTasks tasks;
  auto AddNewTasks = [&](string name, int count)
  {
    while (count-- > 0)
      tasks.AddNewTask(name);
    cout << "--------\n";
  };
  auto PerformPersonTasks = [&](string name, int count)
  {
    auto [a,b] = tasks.PerformPersonTasks(name, count);
    PrintTasksInfo(a);
    cout << "---\n";
    PrintTasksInfo(b);
    cout << "--------\n";
  };
  auto GetPersonTasksInfo = [&](string name)
  {
    PrintTasksInfo(tasks.GetPersonTasksInfo(name));
    cout << "--------\n";
  };

  AddNewTasks("Alice", 5);
  PerformPersonTasks("Alice", 5);
  PerformPersonTasks("Alice", 5);
  PerformPersonTasks("Alice", 1);
  AddNewTasks("Alice", 5);
  PerformPersonTasks("Alice", 2);
  GetPersonTasksInfo("Alice");
  PerformPersonTasks("Alice", 4);
  GetPersonTasksInfo("Alice");

  return 0;
  for (int i = 0; i < 5; ++i) {
    tasks.AddNewTask("Alice");
  }
  PrintTasksInfo(tasks.GetPersonTasksInfo("Alice"));

  TasksInfo updated_tasks, untouched_tasks;

  tie(updated_tasks, untouched_tasks) =
      tasks.PerformPersonTasks("Alice", 5);
  /*cout << "Updated Alice tasks: ";
  PrintTasksInfo(updated_tasks);
  cout << "Untouched Alice tasks: ";
  PrintTasksInfo(untouched_tasks);*/
  cout << "Result: ";
  PrintTasksInfo(tasks.GetPersonTasksInfo("Alice"));

  tie(updated_tasks, untouched_tasks) =
      tasks.PerformPersonTasks("Alice", 5);
  /*cout << "Updated Ivan's tasks: ";
  PrintTasksInfo(updated_tasks);
  cout << "Untouched Ivan's tasks: ";
  PrintTasksInfo(untouched_tasks);
  cout << "Result: ";*/
  PrintTasksInfo(tasks.GetPersonTasksInfo("Alice"));

  tie(updated_tasks, untouched_tasks) =
      tasks.PerformPersonTasks("Alice", 1);
  PrintTasksInfo(tasks.GetPersonTasksInfo("Alice"));
  return 0;
}