class TeamTasks {
public:
    const TasksInfo& GetPersonTasksInfo(const string& person) const {
        return tasks.at(person);
    }

    void AddNewTask(const string& person) {
            tasks[person][TaskStatus::NEW]++;
    }

    tuple<TasksInfo, TasksInfo> PerformPersonTasks(const string& person, int task_count) {
        auto p = tasks.find(person);
        /*if (p == tasks.end()) {
            throw invalid_argument("Person does not exist: " + person);
        }*/
        int counter = 0;
        TasksInfo updated;
        TasksInfo notUpdated = p->second;

        if (task_count > 0) {
            for (auto& t : p->second) {
                switch (t.first) {
                case TaskStatus::NEW:
                    while (counter < task_count && t.second > 0) {
                        counter++;
                        t.second--;
                        notUpdated[TaskStatus::NEW]--;
                        p->second[TaskStatus::IN_PROGRESS]++;
                        updated[TaskStatus::IN_PROGRESS]++;
                    }
                    break;
                case TaskStatus::IN_PROGRESS:
                    while (counter < task_count && t.second > 0) {
                        counter++;
                        t.second--;
                        notUpdated[TaskStatus::IN_PROGRESS]--;
                        p->second[TaskStatus::TESTING]++;
                        updated[TaskStatus::TESTING]++;
                    }
                    break;
                case TaskStatus::TESTING:
                    while (counter < task_count && t.second > 0) {
                        counter++;
                        t.second--;
                        notUpdated[TaskStatus::TESTING]--;
                        p->second[TaskStatus::DONE]++;
                        updated[TaskStatus::DONE]++;
                    }
                    break;
                }
                if (counter == task_count)
                    break;
            }
        }

        if (p->second[TaskStatus::NEW] <= 0)
            p->second.erase(TaskStatus::NEW);
        if (p->second[TaskStatus::IN_PROGRESS] <= 0)
            p->second.erase(TaskStatus::IN_PROGRESS);
        if (p->second[TaskStatus::TESTING] <= 0)
            p->second.erase(TaskStatus::TESTING);
        if (p->second[TaskStatus::DONE] <= 0)
            p->second.erase(TaskStatus::DONE);

        if (notUpdated[TaskStatus::NEW] <= 0)
            notUpdated.erase(TaskStatus::NEW);
        if (notUpdated[TaskStatus::IN_PROGRESS] <= 0)
            notUpdated.erase(TaskStatus::IN_PROGRESS);
        if (notUpdated[TaskStatus::TESTING] <= 0)
            notUpdated.erase(TaskStatus::TESTING);
        if (notUpdated[TaskStatus::DONE] <= 0)
            notUpdated.erase(TaskStatus::DONE);

        return make_tuple(updated, notUpdated);
    }

private:
    map<string, TasksInfo> tasks;
};