#ifndef SLOTS_H
#define SLOTS_H

/*
	@author Manuel Jung, <mj@5tec.net>
*/

#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/recursive_mutex.hpp>
#include <boost/thread/condition.hpp>
#include <unicode/unistr.h>


#include "diver.h"
#include "myconnection.h"


struct query
{
    query(unsigned int id_,
          unsigned short pr_,
          unsigned short type_,
          unsigned short status_);
    virtual ~query();
    enum estatus{WAITING=0, WORKING=1, BUFFERED=2};

    unsigned int id;
    unsigned short pr;
    unsigned short type;
    unsigned short status;

    typedef boost::shared_ptr<query> pointer;
};

struct qoctopus : public query
{
    qoctopus(unsigned int id_,
             unsigned short pr_,
             unsigned short type_,
             unsigned short status_);
    virtual ~qoctopus();
    unsigned int ErrorCode;

    UnicodeString Url;
    std::string buf;
    typedef boost::shared_ptr<qoctopus> pointer;
};

    struct tid{};
    struct tpr{};
    struct ttype{};
    struct tseq{};
    struct tfree{};

    //Some Lists:
    //arm list
    //slot list

    //Queues:
    //arm queue
    //slot queue / buffer




struct query_rank_key:composite_key<
  query::pointer,
  member<query,unsigned short,&query::status>,
  member<query,unsigned short,&query::pr>,
  member<query,unsigned int,&query::id>
>{};


typedef multi_index_container<
  query::pointer,
  indexed_by<
    ordered_non_unique<
        query_rank_key
    #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
      ,composite_key_result_less<query_rank_key::result_type>
    #endif
    >,
    ordered_unique<
        tag<tid>,member<query,unsigned int,&query::id> >
    >
> queue_set;

class queue : public queue_set
{
public:
    typedef boost::shared_ptr<queue> pointer;
    queue(){};
    virtual ~queue(){};

    boost::mutex m;
};




/*
class queue : public queue_set
{
public:
    queue(){};
    virtual ~queue(){};
    void AddQuery(query::pointer Query);
    void RmQuery(query::pointer Query);
    void Upd(query::pointer Query);
    boost::mutex m_Queue;
    typedef boost::shared_ptr<queue> pointer;
};

typedef nth_index<queue,0>::type queue_by_rank;
typedef nth_index<queue,1>::type queue_by_id;
*/

class slot : public myconnection, public boost::enable_shared_from_this<slot>
{	//Metacrawler
public:
    slot(diver::pointer diver_tmp);
    virtual ~slot();

    // Locking envoirment
    boost::try_mutex m_idle;
    boost::condition cond_idle;

    bool stop;
    // ------------------

    typedef boost::shared_ptr<boost::thread> tpointer;

    virtual void Start();
    virtual void Call()=0;
    virtual void Stop();
    tpointer Split();
    bool IsIdle();

    enum etype{SHARK=0, WHALE=1, DOLPHIN=2};

    unsigned int id;

    query::pointer Query;
    tpointer Thread;
    typedef boost::shared_ptr<slot> pointer;

protected:
    diver::pointer diver_;
    diver::TCnv cnv;

};

#endif