/*
 * Copyright 2011-2015, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Oliver Tappe <zooey@hirschkaefer.de>
 *              Rene Gollent <rene@gollent.com>
 */


#include <Job.h>

#include <Errors.h>


namespace BSupportKit {


BJobStateListener::~BJobStateListener()
{
}


void
BJobStateListener::JobStarted(BJob* job)
{
}


void
BJobStateListener::JobProgress(BJob* job)
{
}


void
BJobStateListener::JobSucceeded(BJob* job)
{
}


void
BJobStateListener::JobFailed(BJob* job)
{
}


void
BJobStateListener::JobAborted(BJob* job)
{
}


// #pragma mark -


BJob::BJob(const BString& title)
        :
        fTitle(title),
        fState(B_JOB_STATE_WAITING_TO_RUN),
        fTicketNumber(0xFFFFFFFFUL)
{
        if (fTitle.Length() == 0)
                fInitStatus = B_BAD_VALUE;
        else
                fInitStatus = B_OK;
}


BJob::~BJob()
{
}


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


const BString&
BJob::Title() const
{
        return fTitle;
}


BJobState
BJob::State() const
{
        return fState;
}


status_t
BJob::Result() const
{
        return fResult;
}


const BString&
BJob::ErrorString() const
{
        return fErrorString;
}


uint32
BJob::TicketNumber() const
{
        return fTicketNumber;
}


void
BJob::_SetTicketNumber(uint32 ticketNumber)
{
        fTicketNumber = ticketNumber;
}


void
BJob::_ClearTicketNumber()
{
        fTicketNumber = 0xFFFFFFFFUL;
}


void
BJob::SetErrorString(const BString& error)
{
        fErrorString = error;
}


status_t
BJob::Run()
{
        if (fState != B_JOB_STATE_WAITING_TO_RUN)
                return B_NOT_ALLOWED;

        fState = B_JOB_STATE_STARTED;
        NotifyStateListeners();

        fState = B_JOB_STATE_IN_PROGRESS;
        fResult = Execute();
        Cleanup(fResult);

        fState = fResult == B_OK
                ? B_JOB_STATE_SUCCEEDED
                : fResult == B_CANCELED
                        ? B_JOB_STATE_ABORTED
                        : B_JOB_STATE_FAILED;
        NotifyStateListeners();

        return fResult;
}


void
BJob::Cleanup(status_t /*jobResult*/)
{
}


status_t
BJob::AddStateListener(BJobStateListener* listener)
{
        return fStateListeners.AddItem(listener) ? B_OK : B_ERROR;
}


status_t
BJob::RemoveStateListener(BJobStateListener* listener)
{
        return fStateListeners.RemoveItem(listener) ? B_OK : B_ERROR;
}


status_t
BJob::AddDependency(BJob* job)
{
        if (fDependencies.HasItem(job))
                return B_ERROR;

        if (fDependencies.AddItem(job) && job->fDependantJobs.AddItem(this))
                return B_OK;

        return B_ERROR;
}


status_t
BJob::RemoveDependency(BJob* job)
{
        if (!fDependencies.HasItem(job))
                return B_ERROR;

        if (fDependencies.RemoveItem(job) && job->fDependantJobs.RemoveItem(this))
                return B_OK;

        return B_ERROR;
}


bool
BJob::IsRunnable() const
{
        return fDependencies.IsEmpty();
}


int32
BJob::CountDependencies() const
{
        return fDependencies.CountItems();
}


BJob*
BJob::DependantJobAt(int32 index) const
{
        return fDependantJobs.ItemAt(index);
}


void
BJob::SetState(BJobState state)
{
        fState = state;
}


void
BJob::NotifyStateListeners()
{
        int32 count = fStateListeners.CountItems();
        for (int i = 0; i < count; ++i) {
                BJobStateListener* listener = fStateListeners.ItemAt(i);
                if (listener == NULL)
                        continue;
                switch (fState) {
                        case B_JOB_STATE_STARTED:
                                listener->JobStarted(this);
                                break;
                        case B_JOB_STATE_IN_PROGRESS:
                                listener->JobProgress(this);
                                break;
                        case B_JOB_STATE_SUCCEEDED:
                                listener->JobSucceeded(this);
                                break;
                        case B_JOB_STATE_FAILED:
                                listener->JobFailed(this);
                                break;
                        case B_JOB_STATE_ABORTED:
                                listener->JobAborted(this);
                                break;
                        default:
                                break;
                }
        }
}


}       // namespace BPackageKit