/*
 * Copyright 2011-2015, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Axel Dörfler <axeld@pinc-software.de>
 *              Oliver Tappe <zooey@hirschkaefer.de>
 */


#include <JobQueue.h>

#include <set>

#include <Autolock.h>
#include <Job.h>

#include <JobPrivate.h>


namespace BSupportKit {

namespace BPrivate {


struct JobQueue::JobPriorityLess {
        bool operator()(const BJob* left, const BJob* right) const;
};


/*!     Sort jobs by:
                1. descending count of dependencies (only jobs without dependencies are
                   runnable)
                2. job ticket number (order in which jobs were added to the queue)
*/
bool
JobQueue::JobPriorityLess::operator()(const BJob* left, const BJob* right) const
{
        int32 difference = left->CountDependencies() - right->CountDependencies();
        if (difference < 0)
                return true;
        if (difference > 0)
                return false;

        return left->TicketNumber() < right->TicketNumber();
};


class JobQueue::JobPriorityQueue
        : public std::set<BJob*, JobPriorityLess> {
};


// #pragma mark -


JobQueue::JobQueue()
        :
        fLock("job queue"),
        fNextTicketNumber(1)
{
        fInitStatus = _Init();
}


JobQueue::~JobQueue()
{
        Close();
        delete fQueuedJobs;
}


status_t
JobQueue::InitCheck() const
{
        return fInitStatus;
}


status_t
JobQueue::AddJob(BJob* job)
{
        if (fQueuedJobs == NULL)
                return B_NO_INIT;

        BAutolock lock(&fLock);
        if (!lock.IsLocked())
                return B_ERROR;

        try {
                if (!fQueuedJobs->insert(job).second)
                        return B_NAME_IN_USE;
        } catch (const std::bad_alloc& e) {
                return B_NO_MEMORY;
        } catch (...) {
                return B_ERROR;
        }
        BJob::Private(*job).SetTicketNumber(fNextTicketNumber++);
        job->AddStateListener(this);
        if (job->IsRunnable())
                release_sem(fHaveRunnableJobSem);

        return B_OK;
}


status_t
JobQueue::RemoveJob(BJob* job)
{
        if (fQueuedJobs == NULL)
                return B_NO_INIT;

        BAutolock lock(&fLock);
        if (lock.IsLocked()) {
                try {
                        if (fQueuedJobs->erase(job) == 0)
                                return B_NAME_NOT_FOUND;
                } catch (...) {
                        return B_ERROR;
                }
                BJob::Private(*job).ClearTicketNumber();
                job->RemoveStateListener(this);
        }

        return B_OK;
}


void
JobQueue::JobSucceeded(BJob* job)
{
        BAutolock lock(&fLock);
        if (lock.IsLocked())
                _RequeueDependantJobsOf(job);
}


void
JobQueue::JobFailed(BJob* job)
{
        BAutolock lock(&fLock);
        if (lock.IsLocked())
                _RemoveDependantJobsOf(job);
}


BJob*
JobQueue::Pop()
{
        BJob* job;
        if (Pop(B_INFINITE_TIMEOUT, true, &job) == B_OK)
                return job;

        return NULL;
}


status_t
JobQueue::Pop(bigtime_t timeout, bool returnWhenEmpty, BJob** _job)
{
        BAutolock lock(&fLock);
        if (lock.IsLocked()) {
                while (true) {
                        JobPriorityQueue::iterator head = fQueuedJobs->begin();
                        if (head != fQueuedJobs->end()) {
                                if ((*head)->IsRunnable()) {
                                        *_job = *head;
                                        fQueuedJobs->erase(head);
                                        return B_OK;
                                }
                        } else if (returnWhenEmpty)
                                return B_ENTRY_NOT_FOUND;

                        // we need to wait until a job becomes available/runnable
                        status_t result;
                        do {
                                lock.Unlock();
                                result = acquire_sem_etc(fHaveRunnableJobSem, 1,
                                        B_RELATIVE_TIMEOUT, timeout);
                                if (!lock.Lock())
                                        return B_ERROR;
                        } while (result == B_INTERRUPTED);
                        if (result != B_OK)
                                return result;
                }
        }

        return B_ERROR;
}


size_t
JobQueue::CountJobs() const
{
        BAutolock locker(fLock);
        return fQueuedJobs->size();
}


void
JobQueue::Close()
{
        if (fHaveRunnableJobSem < 0)
                return;

        BAutolock lock(&fLock);
        if (lock.IsLocked()) {
                delete_sem(fHaveRunnableJobSem);
                fHaveRunnableJobSem = -1;

                if (fQueuedJobs != NULL) {
                        // get rid of all jobs
                        for (JobPriorityQueue::iterator iter = fQueuedJobs->begin();
                                iter != fQueuedJobs->end(); ++iter) {
                                delete (*iter);
                        }
                        fQueuedJobs->clear();
                }
        }
}


status_t
JobQueue::_Init()
{
        status_t result = fLock.InitCheck();
        if (result != B_OK)
                return result;

        fQueuedJobs = new (std::nothrow) JobPriorityQueue();
        if (fQueuedJobs == NULL)
                return B_NO_MEMORY;

        fHaveRunnableJobSem = create_sem(0, "have runnable job");
        if (fHaveRunnableJobSem < 0)
                return fHaveRunnableJobSem;

        return B_OK;
}


void
JobQueue::_RequeueDependantJobsOf(BJob* job)
{
        while (BJob* dependantJob = job->DependantJobAt(0)) {
                JobPriorityQueue::iterator found = fQueuedJobs->find(dependantJob);
                bool removed = false;
                if (found != fQueuedJobs->end()) {
                        try {
                                fQueuedJobs->erase(dependantJob);
                                removed = true;
                        } catch (...) {
                        }
                }
                dependantJob->RemoveDependency(job);
                if (removed) {
                        // Only insert a job if it was in our queue before
                        try {
                                fQueuedJobs->insert(dependantJob);
                                if (dependantJob->IsRunnable())
                                        release_sem(fHaveRunnableJobSem);
                        } catch (...) {
                        }
                }
        }
}


void
JobQueue::_RemoveDependantJobsOf(BJob* job)
{
        while (BJob* dependantJob = job->DependantJobAt(0)) {
                try {
                        fQueuedJobs->erase(dependantJob);
                } catch (...) {
                }

                if (dependantJob->State() != B_JOB_STATE_ABORTED) {
                        BJob::Private(*dependantJob).SetState(B_JOB_STATE_ABORTED);
                        BJob::Private(*dependantJob).NotifyStateListeners();
                }

                _RemoveDependantJobsOf(dependantJob);
                dependantJob->RemoveDependency(job);
                // TODO: we need some sort of ownership management
                delete dependantJob;
        }
}


}       // namespace BPrivate

}       // namespace BPackageKit