#include <owl\owlpch.h>
#pragma hdrstop

#include <string.h>
#include <stdio.h>
#include <ctype.h>

#include "cse.h"
#include "monit.h"
#include "winmib.h"

#include "monsnmp.h"
#include "rotinas.h"

#include "grafico.h"

#define WSA_HIVERSION			1					/* WinSock DLL version */
#define WSA_LOVERSION			1
#define WM_WSA_NOTIFICATION	WM_APP_USER+1
#define WM_WSNMPTST_DUMPNEXT	WM_APP_USER+2
//-------------------------------------------------------------------------
cGraficoLinha *gl=NULL;

//-------------------------------------------------------------------------
class cMonitorSNMP : public TApplication {
public:
   cMonitorSNMP();
   virtual ~cMonitorSNMP();
   virtual void InitMainWindow();

   DECLARE_RESPONSE_TABLE(cMonitorSNMP);
};
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
HSNMP_SESSION snmpSession;
//-------------------------------------------------------------------------
class cJanelaPrinc : public TFrameWindow {
private :
   TIArrayAsVector<cMonitorInterface> Interfaces;
   TIArrayAsVectorIterator<cMonitorInterface> *Iter;

public:
   cJanelaPrinc(const string &titulo);
   ~cJanelaPrinc();

   void CmTestar();
   void CmEncerrar();

   LRESULT CmNotificacao(WPARAM, LPARAM lParam);
   LRESULT CmTimer(WPARAM, LPARAM lParam);

   virtual void Paint(TDC& dc, bool b, TRect&r );
   virtual bool Create();
   CSE_STATUS   ReadMibList(char *strMibList);

   DECLARE_RESPONSE_TABLE(cJanelaPrinc);
};
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
DEFINE_RESPONSE_TABLE1(cMonitorSNMP, TApplication)
END_RESPONSE_TABLE;
//-------------------------------------------------------------------------
DEFINE_RESPONSE_TABLE1(cJanelaPrinc, TFrameWindow)
    EV_COMMAND(CM_ARQUIVOTESTE,CmTestar),
    EV_COMMAND(CM_ENCERRAR_MONITOR,CmEncerrar),
    EV_MESSAGE(WM_WSA_NOTIFICATION,CmNotificacao),
    EV_MESSAGE(WM_TIMER,CmTimer),
END_RESPONSE_TABLE;
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
cMonitorSNMP::cMonitorSNMP():TApplication() {
}
//-------------------------------------------------------------------------
cMonitorSNMP::~cMonitorSNMP() {
}
//-------------------------------------------------------------------------
void cMonitorSNMP::InitMainWindow() {
   cJanelaPrinc *jan= new cJanelaPrinc("Gerenciamento da Rede");
   SetMainWindow(jan);
}
//-------------------------------------------------------------------------
CSE_STATUS cJanelaPrinc::ReadMibList(char *strMibList){
	char *begin;
	char *end;
	for (begin=strMibList; begin!=NULL && *begin!=0; begin=end) {
		MIB_STATUS status;
		end = strchr(begin,';');
		if (end!=NULL) {
			*end=0;
		}
		status = MibReadDef(begin);
		if (status==MIB_FAILURE)
         return CSE_FAILURE ;
			//CseLogPrintf(hwnd, "\nMibReadDef(%s) returned MIB_FAILURE", begin);

		if (end!=NULL)
			*(end++) = ';';
	}
	return CSE_SUCCESS;
}
//-------------------------------------------------------------------------
cJanelaPrinc::cJanelaPrinc(const string &nome) :
                               TFrameWindow(0,nome.c_str()),
                               Interfaces(5,0,5) {
   AssignMenu(MENU_1);
	static WSADATA wsaData;
   Iter= NULL;

   if (WSAStartup(MAKEWORD(WSA_LOVERSION,WSA_HIVERSION), (LPWSADATA)&wsaData)!=0) {
      ::MessageBox(NULL,
            "Can't initialize WINSOCK.DLL",
            "Error in Windows SNMP Test Program",
            MB_OK|MB_ICONSTOP);
      return;
   }
   if (HIBYTE(wsaData.wVersion)<WSA_HIVERSION ||
         (HIBYTE(wsaData.wVersion)==WSA_HIVERSION && LOBYTE(wsaData.wVersion)<WSA_LOVERSION)) {
      ::MessageBox(NULL,
            "This program requires a WINSOCK.DLL of version 1.1 (or higher)",
            "Error in Windows SNMP Test Program",
            MB_OK|MB_ICONSTOP);
      WSACleanup(); // terminate WINSOCK.DLL
      return;
   }

   MibStartup();
}
//-------------------------------------------------------------------------
#define isENTER( ch ) ( ch == '\n' || ch == '\r' )

char GetToken( FILE *arquivo, char *buffer , int *ult ) {
   int ch ;
   int pos=0;
	// Primeiro devemos pular todos os espacos e ENTER`s....
   do {
		ch= fgetc( arquivo );
   } while( ch != EOF && ( ch == '\r' || ch=='\n' || isspace( ch ))) ;

	while( ch != EOF ){
		if( ch == ';'){
			while( (ch= fgetc( arquivo )) != EOF && ( ch != '\n' ));
			if( ch != EOF ){
				do {
					ch=fgetc( arquivo );
				} while( ch != EOF &&  isspace( ch ) );
				continue ;
			}
		}

		if( ch != EOF && (( !isENTER(ch) && !isspace(ch) && ch != ':' && ch !=',') )){
			buffer[ pos++ ]= ch ;
			buffer[ pos ]= '\0' ;
		} else{
			*ult= ch;
			strupr( buffer );
			return( ch != EOF );
		}
		ch= fgetc( arquivo );
	}
	return( ch != EOF );
}
//-------------------------------------------------------------------------
bool cJanelaPrinc::Create(){
   TFrameWindow::Create();

   if(ReadMibList("root.def;mib2.def;rmon.def") == CSE_FAILURE )
      MessageBox("Erro na leitura da Mib\nNao encontrei um dos arquivos : root.def/mib2.def/rmon.def","Erro",MB_OK|MB_ICONEXCLAMATION);

	SNMPAPI_STATUS nStatus;
	SMI_UINT32 nMajorVersion;
	SMI_UINT32 nMinorVersion;
	SMI_UINT32 nLevel;
	SMI_UINT32 nTranslateMode;
	SMI_UINT32 nRetransmitMode;

	nStatus = SnmpStartup(
					&nMajorVersion,
					&nMinorVersion,
					&nLevel,
					&nTranslateMode,
					&nRetransmitMode);
	if(nStatus != SNMPAPI_FAILURE)
      snmpSession= SnmpOpen(HWindow, WM_WSA_NOTIFICATION);
   SetTimer(1,5000 /* 5 segundos */);

   FILE *arq= fopen("maquinas","r");
   int c, ok= 1;
   char maquina[64], ip[64];

   while(GetToken(arq,maquina,&c) == 1 && ok == 1)
      if( (ok=GetToken(arq,ip,&c)) == 1)
         Interfaces.Add( new cMonitorInterface(maquina,ip) );

   fclose(arq);
   Iter= new TIArrayAsVectorIterator<cMonitorInterface>(Interfaces);
   return true ;
}
//-------------------------------------------------------------------------
bool SalvarBmp(const string &nomeArquivo,TBitmap &bitmap){
	::MessageBox(NULL,"Gravando...","ERRO",MB_OK);
	TDib *dib= new TDib(bitmap);
	bool ret= dib->WriteFile(nomeArquivo.c_str()) ;
	delete dib;
	return ret ;
}
//------------------------------------------------------------------------------
TBitmap *CarregarBmp(const string &nome){
	TDib *dib=new TDib(nome.c_str());
	TBitmap *bitmap= new TBitmap(TScreenDC(), *dib);
   delete dib ;
   return bitmap ;
}
//------------------------------------------------------------------------------
cJanelaPrinc::~cJanelaPrinc() {
   delete Iter;
}
//-------------------------------------------------------------------------
void cJanelaPrinc::Paint(TDC& dc, bool b, TRect&r){
}
//-------------------------------------------------------------------------
void cJanelaPrinc::CmTestar() {
}
//-------------------------------------------------------------------------
LRESULT cJanelaPrinc::CmNotificacao(WPARAM, LPARAM lParam) {
	if (WSAGETSELECTEVENT(lParam) & FD_READ) {
      HSNMP_PDU pdu;
      HSNMP_ENTITY srcEntity;
      HSNMP_CONTEXT context;

      pdu= SnmpRecvMsg(snmpSession, &srcEntity, &context);
      SNMPAPI_STATUS nStatus = (SNMPAPI_STATUS)pdu;
      if(nStatus != SNMPAPI_FAILURE) {
	      struct in_addr in;
      	char host_number[3+1+3+1+3+1+3+1];
	      SnmpEntityToStr(srcEntity, sizeof(host_number), host_number);
         in.s_addr= inet_addr(host_number);
         TIArrayAsVectorIterator<cMonitorInterface> iter(Interfaces);
         while( iter ) {
            iter.Current()->TratarResposta(in,pdu);
            iter++;
         }
      }
      SnmpFreePdu(pdu);
      SnmpFreeContext(context);
      SnmpFreeEntity(srcEntity);
   }
   return 1L;
}
//-------------------------------------------------------------------------
LRESULT cJanelaPrinc::CmTimer(WPARAM, LPARAM) {
   if( Iter )
      if( *Iter ) {
         Iter->Current()->Executar();
         (*Iter)++;
      } else
         Iter->Restart();
   return 1L;
}
//-------------------------------------------------------------------------
void cJanelaPrinc::CmEncerrar() {
	PostQuitMessage(0);
}
//-------------------------------------------------------------------------
int OwlMain (int , char* []){
   try {
      cMonitorSNMP app;
      return app.Run();
   }
   catch (xmsg& x) {
		::MessageBox(0, x.why().c_str(), "Exceçao", MB_OK);
   }
   return -1;
}
//-------------------------------------------------------------------------