#include <owl/gdiobjec.h>
#include <owl/dc.h>

#include "grafico.h"
#include <dos.h>

#include "cgi.h"
#include <conio.h>
#include "interf.h"
#include "color.hpp"
#include "imgstore.hpp"

/*
    Este programa e um CGI ( 32 Bits - OWL ) que le os dados das bases de dados
    geradas pelo programa monitor e traca os graficos


    Calculo para trafego
    ___________________________________________________________________________


                     TaxaMaximaPlaca (Bit/s)
    TrafegoMaximo = ----------------------- * 60
                               8

    TaxaPlaca= 10.000.000 Bits / s => 1.250.000 Bytes/Seg

    Em um minuto temos 60 * 1.250.000 = 75.000.000 Bytes/Minuto = 75 Mb / Minuto

    => 5 Minutos teremos : 375 Mb Transmitidos com carga maxima (100%)

    100 % -------------> 375.000.000
     50 % -------------> X


         50 * 375.000.000
     X = ---------------- = 187.500.000
               100

    ou seja com carga de 50% teremos um trafego de aproximadamente 187.5 Mb em
    5 minutos
*/
ImgStore* LoadBMPFile( const string &fn,rgb **);
//-------------------------------------------------------------------------
WriteGIF( ImgStore& img, rgb *pal, char *fn );
//-------------------------------------------------------------------------
// CgiScript é uma classe que manipula os dados recebidos (provenientes de um
// servidor HTTP chamado FOLKWEB - este servidor utiliza arquivos .INI para
// repassar as informações recebidas do cliente) em um programa CGI.
class  cPlotadorGrafico : public CgiScript {
protected :
   ImgStore  *imgmap;      // image bitmap

public:
	cPlotadorGrafico(int argC, char** argV) : CgiScript(argC, argV,2048) {}
	const   char* GetTitle() { return "Grafico resultado da monitoracao da rede"; }
	virtual void  WriteBody();
           bool  SalvarBmp(const string &nomeArquivo,TBitmap &bitmap);
           bool  BmpToGif(const string &nomeBMP);
};
//-------------------------------------------------------------------------
bool cPlotadorGrafico::SalvarBmp(const string &nomeArquivo,TBitmap &bitmap){
	TDib *dib= new TDib(bitmap);
	bool ret= dib->WriteFile(nomeArquivo.c_str()) ;
	delete dib;
	return ret ;
}
//-------------------------------------------------------------------------
void cPlotadorGrafico::WriteBody(){
   CData IPNumber;
   int hora;
   int vez;

   sOcorrenciaDia dadosDia;

   // Instanciamos um grafico com resolucao de  800x400
   cGraficoLinha *grafico= new cGraficoLinha(TPoint(800,400),
                                             "Resultados", // Titulo
                                             "Tempo (min)",
                                             "Total de Bytes",
                                             cGraficoLinha::eExpandir);

   int totMaquinas=0,
       hVarTrafego;
   long maiorTrafego= 0;
   string maqMaiorTrafego;
   long maiorPico= 0;
   string maqMaiorPico;

   cArquivoInterface dadosInterface;
   date data;
 	getdate(&data);

   CDictionaryIterator i(dictionary);
   int ind= 1;
   while(i){
      long totTrafego= 0;
      randomize();
      IPNumber =i.Current();
     // Selecionamos a proxima interface !
      out << "<BR>IP = " << IPNumber.Value() ;
      dadosInterface.InformarInterface(IPNumber.Value());

      // Recuperamos os valores (Trafego/Erros)
      dadosInterface.RetOcorrenciasDia(data.da_day,
													data.da_mon ,
                                       data.da_year,
                                       dadosDia);

      // Criamos uma Variavel no grafico e recurepamos o 'Handle' desta variavel...
      hVarTrafego= grafico->CriarVariavel(IPNumber.Value(), // Titulo
                                          TColor(ind)       // Cor
                                          );
      ind+= 40;

      totMaquinas++;
      // varre cada uma da ocorrencias em um dia ( 24 Horas )
      for(hora=0; hora < 24 ; hora++) {
         // Como fizemos uma amostragem a cada 5 minutos teremos 12 amostragens /  hora
         for(vez=0;vez < 12 ; vez++) {
            grafico->IncluirPonto(hVarTrafego,dadosDia.Ocorrencia[hora][vez].Trafego);
            totTrafego+= dadosDia.Ocorrencia[hora][vez].Trafego;
            if( dadosDia.Ocorrencia[hora][vez].Trafego > maiorPico ){
               maiorPico= dadosDia.Ocorrencia[hora][vez].Trafego;
               maqMaiorPico= IPNumber.Value();
            }
            // se o trafego em 5 minutos ultrapassar 50% da capacidade da placa
            // avisamos...

            if( dadosDia.Ocorrencia[hora][vez].Trafego > 187250000L )
               out << "-------------------------------------------------------------------------<BR>"
                      "Interface : " << IPNumber.Value() << " ultrapassou o limiar dos 50% de carga<BR>"
                      "Horario   : " << hora << ":" << (vez * 5) << "<BR>"
                      "Carga     : " << dadosDia.Ocorrencia[hora][vez].Trafego << "Mb<BR>"
                      "-------------------------------------------------------------------------<BR><BR>";
         }
      }
      if( totTrafego > maiorTrafego ) {
         maiorTrafego= totTrafego;
         maqMaiorTrafego= IPNumber.Value();
      }

      i++; // vamos para a proxima interface ...
   }
   // Tracamos o grafico
   grafico->TracarGrafico();
   TBitmap *mapaBits=grafico->RetornarBitmap();
   if(mapaBits != NULL){
      //Salvamos o grafico no formato BMP e ...
      char nomeArquivo[32];
      sprintf(nomeArquivo,"%02d%c%c",data.da_year,(char)('z'-data.da_mon),(char)('A'+ data.da_day));
      string nomeGif=string(nomeArquivo) + ".gif";
      strcat(nomeArquivo,".bmp");
      SalvarBmp(nomeArquivo,*mapaBits);

      delete grafico ;
      // Convertemos o mesmo para GIF !!!!
      // Aqui o melhor seria gravar diretamente como GIF, porem nao conseguimos alterar
      // a rotina que grava um GIF para manipular um HBITMAP (Por enquanto !!)
      if( BmpToGif(nomeArquivo) == true ){
         unlink(nomeArquivo); // apagamos o arquivo .BMP

         // Acabamos de montar a pagina de resposta....
         out << "<BR>\n<CENTER><H1>Resultados</H1>"
                "</CENTER>\n"
                "<IMG SRC=\"" << nomeGif << "\">\n"
                "<BR><FONT SIZE= +2>Número de máquinas analisadas : " << totMaquinas << "\n"
                "<BR>Maior trafego na maquina " << maqMaiorTrafego << "\n" <<
                "<BR>Maior pico : " << maiorPico/300 << " Byte/s na maquina " << maqMaiorPico << "\n" <<
                "</FONT>";
      }else
         out << "<BR>\n<CENTER><H1>ERRO NA GERACAO DO GRAFICO !</H1>";
   }
}
//-------------------------------------------------------------------------
// Le um arquivo no formato BMP e grava como GIF
bool cPlotadorGrafico::BmpToGif(const string &nomeBMP){
   rgb *pallete;
   imgmap=LoadBMPFile(nomeBMP,&pallete);
   if(imgmap != NULL){
      string nome= nomeBMP;
      size_t pos= nome.find(".");
      if(pos)
         nome = nome.remove(pos+1);

      nome += "gif";

      WriteGIF(*imgmap,pallete,(char*)nome.c_str());
      return true ;
   } else
      return false ;
}
//-------------------------------------------------------------------------
// Funcao Principal 
int OwlMain(int nArg,char *args[]){
	cPlotadorGrafico graph(nArg,args); // Instancia um objeto que manipula o CGI ..
   graph.Run(); // e executa o mesmo...
   return 1;
}