#ifndef __RILEVENTS_CALLSTATE_H__
#define __RILEVENTS_CALLSTATE_H__
enum {
    //CALLSTATE_IDLE, //  == DISCONNECTED
    CALLSTATE_INCOMING,
    CALLSTATE_RING=CALLSTATE_INCOMING,
    CALLSTATE_CONNECTING,       // == dialing, or answering
    CALLSTATE_CONNECTED,
    CALLSTATE_DISCONNECTED,
};
// todo: CALLCTRL::CALLSTATECHANGED //    ... this is an event without properties, it is always accompanied with CPI.

typedef waitvariable<int> callstate_waitvar;
// CALLCTRL::RING
class RingEventHandler : public eventhandler {
public:
    RingEventHandler(callstate_waitvar& var) : _var(var) { }
    virtual std::string name() const { return "RING"; }
    virtual DWORD code() const { return RIL_NOTIFY_RING; }
    virtual void handle(const void *data, size_t size) throw()
    {
        if (data==NULL) {
            debugt("RING\n");
        }
        else {
            checksize(data, size, sizeof(RILRINGINFO));
            debugt("%s: %s\n", name().c_str(), GetRingInfoString(reinterpret_cast<const RILRINGINFO*>(data)).c_str());
        }
        _var.set(CALLSTATE_RING);
    }
private:
    callstate_waitvar& _var;
};
// SUPSERVICE::CALLERID
class CallerIdEventHandler : public eventhandler {
public:
    virtual std::string name() const { return "CALLERID"; }
    virtual DWORD code() const { return RIL_NOTIFY_CALLERID; }
    virtual void handle(const void *data, size_t size) throw()
    {
        checksize(data, size, sizeof(RILREMOTEPARTYINFO));
        debugt("%s: %s\n", name().c_str(), GetRemotePartyInfoString(reinterpret_cast<const RILREMOTEPARTYINFO*>(data)).c_str());
    }
};
// CALLCTRL::DATASVCNEGOTIATED
//
// this event is triggered at the start of an incoming call
class DataServiceEventHandler : public eventhandler {
public:
    DataServiceEventHandler(callstate_waitvar& var) : _var(var) { }
    virtual std::string name() const { return "DATASVCNEGOTIATED"; }
    virtual DWORD code() const { return RIL_NOTIFY_DATASVCNEGOTIATED; }
    virtual void handle(const void *data, size_t size) throw()
    {
        checksize(data, size, sizeof(RILSERVICEINFO));
        debugt("%s: %s\n", name().c_str(), GetServiceInfoString(reinterpret_cast<const RILSERVICEINFO*>(data)).c_str());

        // the meaning of DATASVCNEGOTIATED depends on whether we have an outgoing call active.
        if (_var.get()==CALLSTATE_DISCONNECTED)
            _var.set(CALLSTATE_INCOMING);
        else if (_var.get()==CALLSTATE_CONNECTING)
            _var.set(CALLSTATE_CONNECTED);
    }
private:
    callstate_waitvar& _var;
};
// CALLCTRL::CONNECT
// note: for a video call you may get several 'CONNECT' events, with different calltypes
class ConnectEventHandler : public eventhandler {
public:
    ConnectEventHandler(callstate_waitvar& var) : _var(var) { }
    virtual std::string name() const { return "CONNECT"; }
    virtual DWORD code() const { return RIL_NOTIFY_CONNECT; }
    virtual void handle(const void *data, size_t size) throw()
    {
        checksize(data, size, sizeof(RILCONNECTINFO));
        debugt("%s: %s\n", name().c_str(), GetConnectInfoString(reinterpret_cast<const RILCONNECTINFO*>(data)).c_str());
        _var.set(CALLSTATE_CONNECTED);
    }
private:
    callstate_waitvar& _var;
};
// CALLCTRL::DISCONNECT
class DisconnectEventHandler : public eventhandler {
public:
    DisconnectEventHandler(callstate_waitvar& var) : _var(var) { }
    virtual std::string name() const { return "DISCONNECT"; }
    virtual DWORD code() const { return RIL_NOTIFY_DISCONNECT; }
    virtual void handle(const void *data, size_t size) throw()
    {
        checksize(data, size, sizeof(DWORD));
        debugt("%s: %s\n", name().c_str(), GetDisconnectInitString(*reinterpret_cast<const DWORD*>(data)).c_str());
        _var.set(CALLSTATE_DISCONNECTED);
    }
private:
    callstate_waitvar& _var;
};
// CALLCTRL::CALLPROGRESS
class CallProgressEventHandler : public eventhandler {
public:
    CallProgressEventHandler(callstate_waitvar& var) : _var(var) { }
    virtual std::string name() const { return "CALLPROGRESS"; }
    virtual DWORD code() const { return RIL_NOTIFY_CALLPROGRESSINFO; }
    virtual void handle(const void *data, size_t size) throw()
    {
        checksize(data, size, sizeof(RILCALLINFO));
        debugt("%s: %s\n", name().c_str(), GetCallInfoString(reinterpret_cast<const RILCALLINFO*>(data)).c_str());
        DWORD dwCpiStatus= reinterpret_cast<const RILCALLINFO*>(data)->dwStatus;
        if (dwCpiStatus==RIL_CPISTAT_NEW_INCOMING) _var.set(CALLSTATE_INCOMING);
        else if (dwCpiStatus==RIL_CPISTAT_CONNECTED) _var.set(CALLSTATE_CONNECTED);
        else if (dwCpiStatus==RIL_CPISTAT_DISCONNECTED) _var.set(CALLSTATE_DISCONNECTED);
        else if (dwCpiStatus==RIL_CPISTAT_NEW_OUTGOING) _var.set(CALLSTATE_CONNECTING);
    }
private:
    callstate_waitvar& _var;
};


#endif