//------------------------------------------------------------------------------
/*
    Copyright (c) 2011-2013, OpenCoin, Inc.
*/
//==============================================================================

#ifndef RIPPLE_JOBQUEUE_H_INCLUDED
#define RIPPLE_JOBQUEUE_H_INCLUDED

class JobQueue : private Workers::Callback
{
public:
    // Statistics on a particular JobType
    struct Count
    {
        Count () noexcept;
        explicit Count (JobType type) noexcept;

        JobType type;    // The type of Job these counts reflect
        int waiting;     // The number waiting
        int running;     // How many are running
        int deferred;    // Number of jobs we didn't signal due to limits
    };

    typedef std::map <JobType, Count> JobCounts;

    //--------------------------------------------------------------------------

    JobQueue ();

    ~JobQueue ();

    // VFALCO TODO make convenience functions that allow the caller to not 
    //             have to call bind.
    //
    void addJob (JobType type, const std::string& name, const FUNCTION_TYPE<void (Job&)>& job);

    int getJobCount (JobType t);        // Jobs waiting at this priority

    int getJobCountTotal (JobType t);   // Jobs waiting plus running at this priority

    int getJobCountGE (JobType t);      // All waiting jobs at or greater than this priority

    std::vector< std::pair<JobType, std::pair<int, int> > > getJobCounts (); // jobs waiting, threads doing

    void shutdown ();

    void setThreadCount (int c, bool const standaloneMode);

    // VFALCO TODO Rename these to newLoadEventMeasurement or something similar
    //             since they create the object.
    //
    LoadEvent::pointer getLoadEvent (JobType t, const std::string& name)
    {
        return boost::make_shared<LoadEvent> (boost::ref (mJobLoads[t]), name, true);
    }

    // VFALCO TODO Why do we need two versions, one which returns a shared
    //             pointer and the other which returns an autoptr?
    //          
    LoadEvent::autoptr getLoadEventAP (JobType t, const std::string& name)
    {
        return LoadEvent::autoptr (new LoadEvent (mJobLoads[t], name, true));
    }

    bool isOverloaded ();

    Json::Value getJson (int c = 0);

private:
    typedef boost::mutex JobLockType;
    typedef JobLockType::scoped_lock ScopedLockType;
    typedef std::set <Job> JobSet;

    void queueJob (Job const& job, ScopedLockType&);
    void getNextJob (Job& job, ScopedLockType&);
    void finishJob (Job const& job);

    void processTask ();

    static int getJobLimit (JobType type);

private:
    Workers m_workers;
    JobLockType mJobLock;
    uint64 mLastJob;
    JobSet mJobSet;
    LoadMonitor mJobLoads [NUM_JOB_TYPES];
    JobCounts mJobCounts;
};

#endif
