#ifndef _SJTU_CPP_FINAL_CPU_HPP_
#define _SJTU_CPP_FINAL_CPU_HPP_

#include <cassert>
#include <vector>

#include "task.hpp"

using namespace std;

typedef unsigned int uint;

namespace sjtu {
// CPU base class, modifications is not allowed.
class CPU {
 protected:
  CPUState state;
  vector<Task> tasks;

 public:
  CPU() : tasks() { state = idle; }

  // Add a new task.
  int addTask(const Task &t) {
    tasks.push_back(t);
    return 1;
  }

  // Change the priority of one process, return 1 if success and return 0 if
  // fail.
  int changePriority(uint task_id, uint priority) {
    for (auto &task : tasks)
      if (task.task_id == task_id) {
        task.priority = priority;
        return 1;
      }
    return 0;
  }

  virtual pair<CPUState, uint> run() = 0;

  virtual ~CPU() = default;
};

// FCFS method based CPU.
class CPU_FCFS : public CPU {
  // TODO: complete the FCFS method.
 public:
  pair<CPUState, uint> run() override {
    bool has_opt = false;
    for (int i = 0; i < tasks.size(); i++) {
      if (tasks[i].time > 0) {
        has_opt = true;
        state = CPUState::busy;
        tasks[i].time--;
        return std::make_pair(CPUState::busy, tasks[i].task_id);
      }
    }
    state = CPUState::idle;
    return std::make_pair(CPUState::idle, 0);
  }
  ~CPU_FCFS() override = default;
};

// SRTF method based CPU.
class CPU_SRTF : public CPU {
  // TODO: complete the SRTF method.
 public:
  pair<CPUState, uint> run() override {
    bool has_opt = false;
    int least_time = -1;
    for (int i = 0; i < tasks.size(); i++) {
      if (tasks[i].time > 0) {
        has_opt = true;
        if (least_time == -1)
          least_time = tasks[i].time;
        else
          least_time =
              (tasks[i].time < least_time) ? tasks[i].time : least_time;
      }
    }
    if (!has_opt) {
      state = CPUState::idle;
      return std::make_pair(CPUState::idle, 0);
    }
    for (int i = 0; i < tasks.size(); i++) {
      if (tasks[i].time == least_time) {
        state = CPUState::busy;
        tasks[i].time--;
        return std::make_pair(CPUState::busy, tasks[i].task_id);
      }
    }
  }
  ~CPU_SRTF() override = default;
};

// priority method based CPU.
class CPU_PRIORITY : public CPU {
  // TODO: complete the priority method.
 public:
  pair<CPUState, uint> run() override {
    bool has_opt = false;
    int highest_pri = -1;
    for (int i = 0; i < tasks.size(); i++) {
      if (tasks[i].time > 0) {
        has_opt = true;
        if (highest_pri == -1)
          highest_pri = tasks[i].priority;
        else
          highest_pri = (tasks[i].priority < highest_pri) ? tasks[i].priority
                                                          : highest_pri;
      }
    }
    if (!has_opt) {
      state = CPUState::idle;
      return std::make_pair(CPUState::idle, 0);
    }
    for (int i = 0; i < tasks.size(); i++) {
      if (tasks[i].priority == highest_pri && tasks[i].time > 0) {
        state = CPUState::busy;
        tasks[i].time--;
        return std::make_pair(CPUState::busy, tasks[i].task_id);
      }
    }
  }
  ~CPU_PRIORITY() override = default;
};
}  // namespace sjtu

#endif