#ifndef _IO_SNMP_H_
#define _IO_SNMP_H_

#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>

#define SINGLE_SESSION_API

#ifdef SINGLE_SESSION_API
  typedef void* HSNMP;
#endif


BOOL IoSnmpInit(void);
void IoSnmpTerminate(void);

#define SNMP_TIMEOUT        100         // snmp timeout until retry [ms]
#define SNMP_RETRIES        1

#define DEFAULT_READ_COMMUNITY   "public"
#define DEFAULT_WRITE_COMMUNITY  "private"

//-----------------------------------------------------------------------------
// CSnmpOid
//-----------------------------------------------------------------------------
//
class CSnmp {
  CRITICAL_SECTION m_criticalSection;
public:
  bool initialize(void);        // initialize SNMP library
  void terminate(void);         // call uninitialization functions
  //void enterCriticalSection(void);
  //void leaveCriticalSection(void);
  SOCmnString getReadCommunity(void) {return m_readCommunity;}
  SOCmnString getWriteCommunity(void) {return m_writeCommunity;}

protected:
  SOCmnString m_readCommunity;
  SOCmnString m_writeCommunity;
};


class CSnmpOid {
  size_t m_length;
  oid* m_poid;
  SOCmnString m_name;                           // only for debug
public:
  CSnmpOid(void);
  CSnmpOid(const char* name);
  ~CSnmpOid();
  oid* initOid(const char* name);               // convert textual oid -> oid list
  oid* initOid(const char* name,unsigned channelNumber);	// convert textual oid -> oid list
  virtual oid* getOid(void) {return m_poid;}            ///< return address of SNMP object identifier
  virtual size_t getOidLength(void) {return m_length;}  ///< return length of SNMP object identifier
  int compareOid(CSnmpOid* poid);               // compare this with other CSnmpOid, return 0 if identical
  SOCmnString getOidName(void) {return m_name;}   ///< return the textual name of the SNMP object identifier
};



// there are so much different date/time classes, so I use my own
// later it may be reasonable to use a different time resolution than 1 ms, but windows has got
// this resolution, so why convert to 1us or 100ns see-saw
class CTime {
  ULONG64 m_ms;
public:
  CTime() {};
  CTime(ULONG64 ms) : m_ms(ms) {}


  CTime operator-( CTime &other );

  void now(void);                                             // initialize with the actual time
  void setInfinite(void) {
    m_ms = (ULONG64)-1;
  }

  DWORD CTime::getRelativeTime(CTime& baseTime);

  const char* getString(void);

  void addMilliseconds(ULONG64 ms);                           // add milliseconds

  ULONG64 getMilliseconds(void) {
    return m_ms;}
};
inline CTime CTime::operator-(CTime &other ) {
/*  CTime diff;
  diff.m_ms = m_ms-other.m_ms;
  return diff;*/
  m_ms -= other.m_ms;
  return *this;
}


//-- getRelativeTime ----------------------------------------------------------
// Return the (DWORD) time difference of the CTime object and a reference time 
// (default: the actual time)
// Special conditions:
//   If the object is INFINITE or the time difference is greater than
//   (DWORD), (DWORD)-1 is returnded.
//   If the object is less than the reference time, 0 is returned
//
inline DWORD CTime::getRelativeTime(CTime& baseTime) {
  if(m_ms == (ULONG64)-1) return (DWORD)-1;
  if(m_ms < baseTime.m_ms) return 0;
  ULONG64 diff = m_ms-baseTime.m_ms;
  if(diff > (DWORD)-1) return (DWORD)-1;
  return (DWORD)diff;
}



inline const char* CTime::getString(void) {
  static char szDate[64];
  if(m_ms == (ULONG64)-1) sprintf(szDate,"INFINITE");
  else {
    DWORD ms = (DWORD)m_ms%1000;
    ULONG64 s = m_ms/1000;
    sprintf(szDate,"%I64d.%3.3d",s,ms);
  }
  return szDate;
}



inline void CTime::now(void) {
  _timeb timeb;
  _ftime(&timeb);
  m_ms = timeb.millitm+((ULONG64)timeb.time)*1000;
}
inline void CTime::addMilliseconds(ULONG64 ms) {
  m_ms += ms;
}

class CCrateRequest;

class CSnmpSession {
public:
  bool snmpOpen(IN LPCTSTR ipAddress);
  void snmpClose(void);

  bool snmpSend(void);
  bool snmpReceive(void);

  char* getIpAddress(void) {      // return the ip address string
    return m_ipAddress;}

	void sendSnmpGet(CSnmpOid* poid,SODaSRequest *pRequest);
  DWORD requestSelectEvent(void);          // generate SNMP select event
  char* getErrorString(void);						// get error string

	void completeRequests(WORD quality);		// complete all pending requests

	static int callback(int operation,struct snmp_session *pSession,int reqid,
    struct snmp_pdu *pdu,void *magic);


protected:
  SOCmnString m_ipAddress;              // ip address of the crate

public: // for test only
#ifdef SINGLE_SESSION_API
  HSNMP m_sessp;                        // snmp opaque pointer (single session API)
#endif
  struct snmp_session *m_session;       // snmp session pointer

//protected:
  fd_set m_fdset;                       // wirklich notwendig, oder kann man Speicher sparen ?
  int m_fds;			                      // not used in windows
//protected:


// we do have only one SNMP PDU at a time, but this request may contain many OPC requests
  const static unsigned maxVarBindings = 25;                // max. number of variable-bindings in one PDU
  CCrateRequest /*!!SODaSRequest*/ *m_requests[maxVarBindings];                 // the requests are stored here
protected:
	int m_requestId;																					// request ID of the actual PDU
public:
  //unsigned numVarBindings;                                  // number of variable bindings in the actual PDU
	unsigned m_numberOfPendingRequests;					              // number of transmitted requests, waiting for answer

  CTime m_timeoutAt;                                        // next timeout time of all pending requests
};





#endif // _IO_SNMP_H_