slot.cpp

#include "fields/slot.h"

#include <iostream>
#include <string>
#include <vector>
#include "fields/is_minor.h"
#include "global.h"

Time::Time(unsigned hours, unsigned minutes) {
  this->hours = hours;
  this->minutes = minutes;
}

Time::Time(std::string time) {
  this->hours = std::stoul(time.substr(0, 2));
  this->minutes = std::stoul(time.substr(3, 5));
}

Time &Time::operator=(const Time &other) {
  this->hours = other.hours;
  this->minutes = other.minutes;
  return *this;
}

bool Time::operator==(const Time &other) {
  return (this->hours == other.hours) && (this->minutes == other.minutes);
}

bool Time::operator<(const Time &other) {
  if (this->hours == other.hours) {
    return this->minutes < other.minutes;
  } else {
    return this->hours < other.hours;
  }
}

bool Time::operator<=(const Time &other) {
  return (*this < other) || (*this == other);
}

bool Time::operator>=(const Time &other) { return !(*this < other); }

bool Time::operator>(const Time &other) { return !(*this <= other); }

std::string Time::getTimeString() {
  return std::to_string(hours) + ":" + std::to_string(minutes);
}

bool Time::isMorningTime() {
  if (hours >= 0 && hours < 13) {
    return true;
  }
  return false;
}

SlotElement::SlotElement(Time &startTime, Time &endTime, Day day)
    : startTime(startTime), endTime(endTime) {
  this->day = day;
}

bool SlotElement::isIntersecting(SlotElement &other) {
  if (this->day != other.day) {
    return false;
  }
  if (this->startTime < other.startTime) {
    return !(this->endTime <= other.startTime);
  } else if (this->startTime > other.startTime) {
    return !(this->startTime >= other.endTime);
  }
  return true;
}

bool SlotElement::isMorningSlotElement() { return startTime.isMorningTime(); }

Slot::Slot(std::string name, IsMinor isMinor,
           std::vector<SlotElement> slotElements)
    : isMinor(isMinor) {
  this->name = name;
  this->slotElements = slotElements;
}

bool Slot::operator==(const Slot &other) { return (this->name == other.name); }

bool Slot::isIntersecting(Slot &other) {
  for (unsigned i = 0; i < slotElements.size(); i++) {
    for (unsigned j = 0; j < other.slotElements.size(); j++) {
      if (slotElements[i].isIntersecting(other.slotElements[j])) {
        return true;
      }
    }
  }
  return false;
}

void Slot::addSlotElements(SlotElement slotElement) {
  slotElements.push_back(slotElement);
}

FieldType Slot::getType() { return FieldType::slot; }

bool Slot::isMinorSlot() {
  return isMinor.getMinorType() == MinorType::isMinorCourse;
}

std::string Slot::getTypeName() { return "Slot"; }

std::string Slot::getName() { return name; }

bool Slot::isMorningSlot() {
  for (unsigned i = 0; i < slotElements.size(); i++) {
    if (!slotElements[i].isMorningSlotElement()) {
      return false;
    }
  }
  return true;
}