#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/resource.h>
#include <sys/time.h>
#include <sys/stat.h>

#include <asn1def.h>
#include <asn1api.h>

#include "megaco.h"
#include "disp_megaco.h"

#define MAXBUFFERSIZE 10000
#define ITERATIONS 100000
#define DIRNAME "ber"
#define MAX_FILES 28

static char *file_list[] =
   {
   "msg01.bin",
   "msg02.bin",
   "msg03.bin",
   "msg04.bin",
   "msg05.bin",
   "msg06.bin",
   "msg07.bin",
   "msg08.bin",
   "msg09.bin",
   "msg10.bin",
   "msg11.bin",
   "msg12.bin",
   "msg13.bin",
   "msg14.bin",
   "msg15.bin",
   "msg16.bin",
   "msg17.bin",
   "msg18.bin",
   "msg19.bin",
   "msg20.bin",
   "msg21.bin",
   "msg22.bin",
   "msg23.bin",
   "msg24.bin",
   "msg25.bin",
   "msg26.bin",
   "msg27.bin",
   "msg28.bin",
   NULL
   };

typedef struct encoded_value_t
   {
   char   *description;
   int    length;
   int    xer_length;
   double etime;
   double dtime;
   double ftime;
   char *encoded;
   } encoded_value;

encoded_value *encoded_list[MAX_FILES];

typedef struct
   {
   long user;
   long syst;
   } TIMER;

void mark_time(TIMER *timer)
   {
   struct rusage start_usage;

   if (getrusage (RUSAGE_SELF, &start_usage) != 0)
      {
      perror ("getrusage");
      exit (1);
      }
   timer->syst = start_usage.ru_stime.tv_sec * 1000000 + start_usage.ru_stime.tv_usec;
   timer->user = start_usage.ru_utime.tv_sec * 1000000 + start_usage.ru_utime.tv_usec;
   }

long diff_usertime(TIMER *start, TIMER *finish)
   {
   return finish->user - start->user;
   }

unsigned char * decoder_output_buffer;
MegacoMessage__t * megaco_message_ptr;

int main(int argcount, char *arglist[])
   {
   decode_t d_scope;
   encode_t e_scope;
   size_t result;
 
   int iteration;
   FILE *fd;
   TIMER start, end;

   double ave_d = 0.0, ave_e = 0.0, ave_f = 0.0;

   typedef struct
      {
      void * value;
      size_t length;
      } Buf;
  
   Buf encoded_message;
   Buf encoded_message_new;

   int encoded_value_counter = 0, quantity_of_messages = 0;


   unsigned char  coding_buffer[MAXBUFFERSIZE];
   unsigned char  tmp_coding_buffer[MAXBUFFERSIZE];

/*     char * transfer = "xerBasic"; */
   char * transfer = "ber";
   encoded_value *enc;

   /* Load all messages in memory */
   while(file_list[encoded_value_counter])
      {
      FILE *fd;
      struct stat st;
      char path[MAXBUFFERSIZE];

      if(quantity_of_messages >= MAX_FILES)
         {
         fprintf(stderr, "Too many files specified\n");
         return 1;
         }
      
      if(strlen(DIRNAME) + strlen(file_list[encoded_value_counter]) + 2 > MAXBUFFERSIZE)
         {
         fprintf(stderr, "Too long pathname specified\n");
         return 1;
         }
      strcpy(path, DIRNAME);
      path[strlen(DIRNAME)] = '/';
      strcpy(&path[strlen(DIRNAME) + 1], file_list[encoded_value_counter]);

      if(!(fd = fopen(path,"rb")))
         {
         perror(path);
         encoded_value_counter++;
         continue;
         }
      if(!(enc = encoded_list[quantity_of_messages] = malloc(sizeof(encoded_value))))
         {
         fprintf(stderr, "Failed to allocate %u byte(s) of memory\n",
                 sizeof(encoded_value));
         return 1;
         }
      fstat(fileno(fd), &st);
      if(!(enc->encoded = malloc(st.st_size)))
         {
         fprintf(stderr, "Failed to allocate %lu byte(s) of memory\n", st.st_size);
         return 1;
         }
      
      /* Fill in the structure */
      enc->description = file_list[quantity_of_messages];
      enc->length = st.st_size;
      fread(enc->encoded, enc->length, 1, fd);

      fclose(fd);
      encoded_value_counter++;
      quantity_of_messages++;
      }

   if(!quantity_of_messages)
      {
      fprintf(stderr, "No valid messages found\n");
      return 1;
      }

   initialize_megaco();

   printf("  Decoder: ");
   fflush(stdout);
      
   /* decode only */
   for(encoded_value_counter = 0; encoded_value_counter < quantity_of_messages; encoded_value_counter++)
      {
      encoded_message.value  = (unsigned char *) encoded_list[encoded_value_counter]->encoded;
      encoded_message.length = encoded_list[encoded_value_counter]->length;

      if(transfer[0] == 'x')
         {
         decoder_output_buffer = "xerBasic.xls";
         /* Convert BER to XER */
         megaco_message_ptr = DecExec(encoded_message.value, encoded_message.length, MegacoMessage, "ber", &d_scope);
         if(megaco_message_ptr == NULL)
            {
            /* Error */
            printf("Error\n");
            exit(EXIT_FAILURE);
            }

         result = EncExec(tmp_coding_buffer, MAXBUFFERSIZE, MegacoMessage, megaco_message_ptr, "xerBasic", &e_scope);
         if(result == (size_t)(-1))
            {
            printf("Error during encoding\n");
            }

         encoded_message.value = tmp_coding_buffer;
         encoded_message.length = result;
         encoded_list[encoded_value_counter]->xer_length = result;
         DecFree(d_scope);
         EncFree(e_scope);
         }
      else
         {
         decoder_output_buffer = "ber.xls";
         }

      mark_time(&start);

      for(iteration = 1; iteration <= ITERATIONS; iteration++)
         {
         /* set message */	
         megaco_message_ptr = DecExec(encoded_message.value, encoded_message.length, MegacoMessage, transfer, &d_scope);
         if(megaco_message_ptr == NULL)
            {
            /* Error */
            printf("Error\n");
            exit(EXIT_FAILURE);
            }
         DecFree(d_scope);
         }
      mark_time(&end);
      encoded_list[encoded_value_counter]->dtime = diff_usertime(&start, &end) / (double)ITERATIONS;
      ave_d += encoded_list[encoded_value_counter]->dtime;
      printf(".");
      fflush(stdout);
      }
   printf("\t%6.1f microsec\n", ave_d / encoded_value_counter);

   printf("  Encoder: ");
   fflush(stdout);

   /* encode only */
   for(encoded_value_counter = 0; encoded_value_counter < quantity_of_messages; encoded_value_counter++)
      {
      encoded_message.value  = (unsigned char *) encoded_list[encoded_value_counter]->encoded;
      encoded_message.length = encoded_list[encoded_value_counter]->length;

      megaco_message_ptr = DecExec(encoded_message.value, encoded_message.length, MegacoMessage, "ber", &d_scope);
      if(megaco_message_ptr == NULL)
         {
         /* Error */
         printf("Error\n");
         exit(EXIT_FAILURE);
         }

      /* Display contents */
#if 0 /* <<<<< change constant to display the decoded messages */
      disp_MegacoMessage(*megaco_message_ptr);
#endif
      
      mark_time(&start);
      for(iteration = 1; iteration <= ITERATIONS; iteration++)
         {
         /* encode */
         result = EncExec(coding_buffer, MAXBUFFERSIZE, MegacoMessage, megaco_message_ptr, transfer, &e_scope);
         if(result == (size_t)(-1))
            {
            printf("Error during encoding\n");
            }
         EncFree(e_scope);
         }

      DecFree(d_scope);
      mark_time(&end);
      ave_e+=encoded_list[encoded_value_counter]->etime = diff_usertime(&start, &end) / (double)ITERATIONS;
      printf(".");
      fflush(stdout);
      }
   printf("\t%6.1f microsec\n", ave_e / encoded_value_counter);
   printf("  EncDec : ");
   fflush(stdout);

   /* decode + encode */
   for(encoded_value_counter = 0; encoded_value_counter < quantity_of_messages; encoded_value_counter++)
      {
      encoded_list[encoded_value_counter]->ftime = encoded_list[encoded_value_counter]->dtime +
         encoded_list[encoded_value_counter]->etime;
      ave_f += encoded_list[encoded_value_counter]->ftime;
      }

   printf("%6.1f microsec\n",
          ave_f / encoded_value_counter);

   /* Store results */
   if(!(fd=fopen((char *) decoder_output_buffer,"w")))
      {
      perror((char *) decoder_output_buffer);
      }
   else
      {
      int i;
      for(i = 0; i < encoded_value_counter; i++)
         {
         fprintf(fd, "\t%s",encoded_list[i]->description);
         }
      fprintf(fd, "\nSize");
      if(transfer[0] == 'x')
         {
         for(i = 0; i < encoded_value_counter; i++)
            {
            fprintf(fd, "\t%u", encoded_list[i]->xer_length);
            }
         }
      else
         {
         for(i = 0; i < encoded_value_counter; i++)
            {
            fprintf(fd, "\t%u", encoded_list[i]->length);
            }
         }
      fprintf(fd, "\nEncode");
      for(i = 0; i < encoded_value_counter; i++)
         {
         fprintf(fd, "\t%6.1f", encoded_list[i]->etime);
         }
      fprintf(fd, "\nDecode");
      for(i = 0; i < encoded_value_counter; i++)
         {
         fprintf(fd, "\t%6.1f", encoded_list[i]->dtime);
         }
      fprintf(fd, "\nEncDec");
      for(i = 0; i < encoded_value_counter; i++)
         {
         fprintf(fd, "\t%6.1f", encoded_list[i]->ftime);
         }
      fprintf(fd, "\n");
      fclose(fd);
      }

   printf("%u different messages were used, results stored in %s\n", encoded_value_counter, decoder_output_buffer);
  
   return 0;
   }