#include "../header/SchrageAlgorithm.hpp"

#include <algorithm>
#include <iostream>
#include <queue>

int SchrageAlgorithm::performAlgorithm(Tasks&& tasksVector)
{
    // Tworzenie kolejek priorytetowych
    auto l1 = [] (const Task& lhs, const Task& rhs)
        {
            if (lhs.getAvailabilityTerm() > rhs.getAvailabilityTerm()) return true;
            if (rhs.getAvailabilityTerm() > lhs.getAvailabilityTerm()) return false;
            //if (lhs.getDeliveryTime() < rhs.getDeliveryTime()) return true;
            //if (lhs.getDeliveryTime() < rhs.getDeliveryTime()) return false;
            return false;
        };

    auto l2 = [] (const Task& lhs, const Task& rhs)
        {
            if (lhs.getDeliveryTime() < rhs.getDeliveryTime()) return true;
            if (lhs.getDeliveryTime() < rhs.getDeliveryTime()) return false;
            return false;
        };

    std::priority_queue<Task, std::vector<Task>, decltype(l1)> tasks(l1);
    std::priority_queue<Task, std::vector<Task>, decltype(l2)> readyTasks(l2);

    // przepisanie z vectora do kolejki
    for (auto task : tasksVector)
    {
        tasks.push(task);
    }

// tu sie zaczyna algorytm z psedokodu
    while (!tasks.empty() || !readyTasks.empty())
    {
        while(!tasks.empty() && tasks.top().getAvailabilityTerm() <= currentTerm)
        {
            readyTasks.push(tasks.top());
            tasks.pop();
        }

        if (readyTasks.empty())
        {
            currentTerm = tasks.top().getAvailabilityTerm();
        }
        else
        {
            Task t = readyTasks.top();
            readyTasks.pop();

            currentTerm = currentTerm + t.getOperationTime();
            int max = currentTerm + t.getDeliveryTime();

            if (max > deliveryTime)
            {
                deliveryTime = max;
            }
        }
    }
    return deliveryTime;
}