#ifndef __RILREADWRITE_H__
#define __RILREADWRITE_H__
#include "util/process.h"
#include "util/queuebuf.h"
#include "rilmonitor.h"
// using process.h from cryptophone/library/engine/
typedef queuebuf<uint8_t> ByteQueue;
class RilReader : public process {
public:
    RilReader(rilmonitor& m, ByteQueue& q) : _m(m), _q(q), _bytecount(0)
    {
        start();
    }
    virtual ~RilReader()
    {
        debug("RilReader processed %d bytes\n", _bytecount);
        stop();
    }
    virtual const char *name() { return "RilReader"; }
    virtual void service()
    {
        ByteVector bv;
        _m.read(bv, 1);

        _bytecount+=bv.size();

        _q.write(&bv[0], bv.size());
    }
private:
    rilmonitor& _m;
    ByteQueue& _q;

    size_t _bytecount;
};
class RilWriter : public process {
public:
    RilWriter(rilmonitor& m, ByteQueue& q) : _m(m), _q(q), _bytecount(0)
    {
        start();
    }
    virtual ~RilWriter()
    {
        debug("RilWriter processed %d bytes\n", _bytecount);
    }
    virtual const char *name() { return "RilWriter"; }
    virtual void service()
    {
        ByteVector bv(256);
        size_t n= _q.read(&bv[0], 1, bv.size());
        bv.resize(n);

        _bytecount += n;

        _m.write(bv);
    }
private:
    rilmonitor& _m;
    ByteQueue& _q;

    size_t _bytecount;
};
class RilFlood : public process {
public:
    RilFlood(rilmonitor& m) : _m(m), _bytecount(0)
    {
        start();
    }
    virtual ~RilFlood()
    {
        debug("RilFlood processed %d bytes\n", _bytecount);
    }
    virtual const char *name() { return "RilFlood"; }
    virtual void service()
    {
        ByteVector bv(256);
        for (unsigned i=0 ; i<256 ; i++)
            bv[i]= i;

        _bytecount += 256;

        _m.write(bv);
    }
private:
    rilmonitor& _m;

    size_t _bytecount;
};
#endif