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

#include <time.h>

#include "dataspy.h"
#include "transfer.h"

//    24 byte data block header - used for data blocks in shared memory and data blocks on disc or tape.

typedef struct s_data_header {
    char header_id[8];
    int header_sequence;
    short  header_stream;
    short  header_DataWidth;
    short  header_MyEndian;
    short  header_DataEndian;
    int header_dataLen;
} DATA_HEADER ;


int convertFEE64toMBS(char *, int);
void checkFEE64DATAbuffer(char *, int);

void byteswop16(char*, int);
void byteswop32(char*, int);

int MBSBuffer[64*1024];     // maximum length is 256 Kbytes
int MBSBufferLen = 16 * 1024 * 4;      // default length is 64 Kbytes

unsigned long long TimeStampF = 0;
unsigned long long WRTimeF = 0;
unsigned long long MBSTimeF = 0;
unsigned long long LastMBSTimeF = 0;

unsigned int Time4863 = 0;
unsigned int Time2847 = 0;
unsigned int Time0027 = 0;

unsigned int WR4863 = 0;
unsigned int WR2847 = 0;
unsigned int WR0027 = 0;

int Verbose = 0;

void Usage(char *progname) {
    fprintf(stderr,"Usage\n%s -n server -t [delayticks] -p [port] -m [mode]\n",progname);
    fprintf(stderr,"\tserver is the IP address or name of destination\n");
    fprintf(stderr,"\tdelayticks is the delay (in millisecs) when looking for buffers\n");
    fprintf(stderr,"\tport is the TCP port to use\n");
    fprintf(stderr,"\tmode is the protocol transfer option\n");
    fprintf(stderr,"Defaults are (none); 6500; 4\n");
    exit(1);
}


int main(int argc, char **argv) {

    char Buffer[128*1024];
    int BufferLength;

    unsigned short *  Buffer16 = (unsigned short *)Buffer;
    unsigned int * Buffer32 = (unsigned int *)Buffer;

int DataLength;
int BufferSize = 64*1024;
DATA_HEADER data_header;

    DATA_HEADER * DataBlock;

    short MyEndian;
    short DataEndian;
    short DataWidth;
    int dataLen;

    char *TS_Server= NULL;
    int Port=6500;      /*  MBS port  */
    int NoBlock=0;
    unsigned int stream = 1;
    int s;
    int i, j, k, m;
    int id = 11001;

    unsigned short * p16;
    unsigned int * p32;
    unsigned char * p8;

    int DelayTicks=10;

    char spinner[4];
    int spin = 0;

    unsigned int MBS0015;
    unsigned int MBS1631;
    unsigned int MBS3247;
    unsigned int MBS4863;

    unsigned int MBSSubSystemID=0x00000200;

    int mbsbufferlen;  /*  length in ints  */
    int * mbsbufferptr;

    mbsbufferptr = MBSBuffer;
    mbsbufferlen = 0;

    int mbslen = 0;
    int eventcounter = 0 ;

    struct timespec time_request;

        spinner[0] = '-';      //  Note - initialised like this because of problems with GNU compiler
        spinner[1] = '\\';
        spinner[2] = '|';
        spinner[3] = '/';

    if (argc >1) {
        for(i=1;i <argc;i++) {
            if ( (argv[i][0] == '-') || (argv[i][0] == '/') ) {
                switch(tolower(argv[i][1])) {
                    case 'i':
                        id = atoi(argv[++i]);
                        break;
                    case 'n':
                        TS_Server = argv[++i];
                        break;
                    case 't':
                        DelayTicks = atoi(argv[++i]);
                        break;
                    case 'p':
                        Port = atoi(argv[++i]);
                        break;
                    case 'k':
                        NoBlock = atoi(argv[++i]);
                        break;
                    case 's':
                        MBSBufferLen = atoi(argv[++i])*1024;
                        break;
                    case 'v':
                        Verbose = atoi(argv[++i]);
                        break;
                    default:
                        Usage(argv[0]);
                        break;
                }
            }
            else
                Usage(argv[0]);
        }
    }

    if (TS_Server == NULL)  Usage(argv[0]);

//    (void) transferSetVerbose(Verbose > 1);
    (void) transferUseOverlap(0);
    (void) transferBlockMode(NoBlock);
    (void) transferNice(1);
    (void) transferEndian(1);

    (void) transferMode(4);   /*  MBS  */
    (void) transferBlockSize(MBSBufferLen);

    (void) transferPort(Port);
    (void) transferInit(TS_Server);
    printf ("Resetting communication with MBS server\n");

//    send MBS Start Data Token

     mbsbufferptr = MBSBuffer;
     *mbsbufferptr++ = 2;  /* length */
     *mbsbufferptr++ = 0x0001000a;
     *mbsbufferptr++ = 0x2500000e;    /* trigger = 14 */
      mbsbufferlen = 3;

     *mbsbufferptr++ = 0xffffffff;   /* end of block */
     mbsbufferlen++;


     if (Verbose > 1) printf("Sending Start Data Token %d\n",MBSBufferLen);
     s = transferTxData ((char *)MBSBuffer , stream, MBSBufferLen);
     if (Verbose > 1) printf("Done with code=%d\n",s);

    i = dataSpyOpen (id);
    printf ("open = %d\n", i);

    for (;;)
    {

/*    obtain a data buffer from shared memory. This will have a 24 byte header */

       DataLength = dataSpyRead (id, Buffer, BufferSize);
       if (Verbose > 2) printf("read done with code=%d\n",DataLength);

       if (DataLength > 0) {

           memcpy (data_header.header_id, (char*)&Buffer[sizeof(HEADER)-sizeof(DATA_HEADER)], sizeof(DATA_HEADER));

           MyEndian = Buffer16[8];
           DataEndian = Buffer16[9];
           DataLength = Buffer32[5];   /* the actual application data less headers  */

           if (Verbose > 0) printf("MyEndian = %d, DataEndian = %d, DataLength=%d\n",MyEndian, DataEndian, DataLength);

           BufferLength = DataLength;   /* the actual application data less headers  */
           if (Verbose) printf("buffer length=%d\n",BufferLength);
         
           DataBlock = (DATA_HEADER*) Buffer;
           dataLen = DataBlock->header_dataLen;

    if (Verbose > 1) {
        printf("\n\nBlock >>>\n");

        p32 = (unsigned int *)Buffer;

        for (j = 0; j <64;) {
           printf(" 0x%08x", p32[j]);
           j++;
           if ((j/8)*8 == j) printf("\n");
        }
        printf("\n");
    }

    if (Verbose > 0) printf(" Block length %d items\n", (dataLen-24)/8);

    DataEndian = DataBlock->header_DataEndian;
    DataWidth = DataBlock->header_DataWidth;
    dataLen = DataBlock->header_dataLen;

    if (Verbose > 1)  printf("Block endian %d: datawidth %d: datalen %d\n",DataEndian,DataWidth,dataLen);

           if (DataEndian != 1) {
               switch (DataBlock->header_DataWidth) {
                   case 2: 
                       byteswop16(Buffer, BufferLength);
                       break;
                   case 4: 
                       byteswop32(Buffer, BufferLength);
                       break;
                   default:
                       byteswop16(Buffer, BufferLength);
                       break;
               }
           }

           if (Verbose > 1) printf("check %d bytes\n",dataLen);

//           checkFEE64DATAbuffer(Buffer+sizeof(DATA_HEADER) , dataLen);

//           if (Verbose > 1) printf("convert %d bytes\n",dataLen);

           mbslen = convertMIDASTDRtoMBS (Buffer+sizeof(DATA_HEADER) , dataLen);

           if (Verbose > 1) printf("convert returned %d ints\n",mbslen);

           if (mbslen > 0) {
              if (Verbose > 1) printf("formatting %d ints\n",mbslen);

              if ((mbslen*4) > MBSBufferLen) {
                  printf("Warning formatting when %d > %d\n",mbslen*4 ,MBSBufferLen);
              }
	      if ( (long long )(MBSTimeF - LastMBSTimeF ) < 0 ) {
		printf ("MBS time: this 0x%016llx, Last 0x%016llx, diff 0x%016llx\n",MBSTimeF , LastMBSTimeF, ( MBSTimeF - LastMBSTimeF ));
		    printf(" Header id = %s \n" , DataBlock->header_id);
		    printf(" Header seq= %d \n" , DataBlock-> header_sequence);
		    printf(" Header stream= %d \n" , DataBlock->  header_stream);
		    printf(" Header Width = %d \n" , DataBlock->  header_DataWidth);
		    printf(" Header MyEndian = %d \n" , DataBlock->  header_MyEndian);
		    printf(" Header DataEndian = %d \n" , DataBlock->  header_DataEndian);
		    printf(" Header Len = %d \n" , DataBlock-> header_dataLen);

		Verbose = 2 ; // set to cause more diagnostics
	      }
              if (Verbose > 1) printf ("MBS time = 0x%016llx\n", MBSTimeF);
              if (Verbose > 0)  { 
			printf ("Last MBS time = 0x%016llx\n", LastMBSTimeF);
			printf ("This MBS time = 0x%016llx\n", MBSTimeF);
       			printf ("Difference                          => 0x%016llx \n\n", ( MBSTimeF - LastMBSTimeF ) );
//			if ( (long long )(MBSTimeF - LastMBSTimeF ) < 0 ) return(1) ;
	      }
	      LastMBSTimeF = MBSTimeF ;
              mbsbufferptr = &MBSBuffer[0];
              mbsbufferlen = 0;

              *mbsbufferptr++ = 0;  /* length  */
              *mbsbufferptr++ = 0x0001000a;
              *mbsbufferptr++ = 0x25000001;
              *mbsbufferptr++ = MBSSubSystemID;
              mbsbufferlen += 1;

              MBS0015 = (unsigned int) (MBSTimeF & 0x000000000000ffff);
              MBS1631 = (unsigned int) ((MBSTimeF >> 16) & 0x000000000000ffff);
              MBS3247 = (unsigned int) ((MBSTimeF >> 32) & 0x000000000000ffff);
              MBS4863 = (unsigned int) ((MBSTimeF >> 48) & 0x000000000000ffff);

              if (Verbose > 1) printf ("0x%08lx 0x%08lx 0x%08lx 0x%08lx\n", MBS0015, MBS1631, MBS3247, MBS4863);

              *mbsbufferptr++ = 0x03e10000 | MBS0015;
              *mbsbufferptr++ = 0x04e10000 | MBS1631;
              *mbsbufferptr++ = 0x05e10000 | MBS3247;
              *mbsbufferptr++ = 0x06e10000 | MBS4863;
              mbsbufferlen += 4;

              mbsbufferlen += mbslen;      /*  add in data payload  */
              mbsbufferptr += mbslen;

              *mbsbufferptr++ = 0xffffffff;    /*  end of block */
 /*             mbsbufferlen++; */

              MBSBuffer[0] = ( mbsbufferlen << 1 )  + 2 ; /*( mbslen  + 5 ) << 1 ;   /*  data length in ints ( now in 16 bit words) */

	      if ( Verbose > 1 ) { printf("mbslen = %08X , %d \n", mbslen,mbslen ); }
              if (mbsbufferlen*4 > MBSBufferLen) {
                  printf("Warning calling transferTxData when %d > %d\n",mbsbufferlen*4 ,MBSBufferLen);
              }

    if (Verbose > 1) {
        printf("Out >>>\n");
       p32 = (int *)&MBSBuffer[0];

        for (j = 0; j < 64;) {
           printf(" 0x%08x", p32[j]);
           j++;
           if ((j/8)*8 == j) printf("\n");
        }
        printf("\n");
    }
   if (Verbose > 1) {
        printf("Out last section >>>\n");
	k = mbsbufferlen + 3 ;
        p32 = (int *)&MBSBuffer[k];
	printf(" Last block value = %08X \n", *p32 );
        p32 = (int *)&MBSBuffer[0];

        for (j = k - 16; j < k + 16;) {
           printf(" 0x%08x", p32[j]);
           j++;
           if ((j/8)*8 == j) printf("\n");
        }
        printf("\n");
    }

              if (Verbose > 1) printf("Sending Data %d %d\n",MBSBufferLen, mbsbufferlen);
              s = transferTxData ((char *)&MBSBuffer[0] , stream, MBSBufferLen);
	      eventcounter++ ;
		if (Verbose > 1) {
			printf("Event Counter = %d \n",eventcounter );
			m=0 ;
			for ( k=0 ; k < 40 ; k++ ) {
				printf("%08X ",MBSBuffer[k]);
				if ( m == 7 ) { 
					printf("\n %04d : ",k) ;
					m=0 ;
				} else {
					m++ ;
				}
			}
		}
              if (Verbose > 1) printf("Done with code=%d\n",s);
	Verbose = 0 ;
       printf ("%c\b", spinner[spin]); fflush(NULL);
             if (++spin == 4) spin=0;

           }
       } else {
           if (DelayTicks) {
               time_request.tv_sec = DelayTicks/1000;
               time_request.tv_nsec = (DelayTicks - (time_request.tv_sec * 1000)) * 1000000;
               i = nanosleep(&time_request, NULL);
            }
       }
    }
}

void byteswop32(char* p, int l) 
{
    int len;
    char *ps;
    char *pd;
    char b0, b1, b2, b3;

   len = l/4;
   ps = p;
   pd = p;


   while (len > 0)
   {
       b0 = *ps++;
       b1 = *ps++;
       b2 = *ps++;
       b3 = *ps++;

       *pd++ = b3;
       *pd++ = b2;
       *pd++ = b1;
       *pd++ = b0;
   
       len--;
   }
}

void byteswop16(char* p, int l) 
{
    int len;
    char *ps;
    char *pd;
    char b0, b1;

   len = l/2;
   ps = p;
   pd = p;


   while (len > 0)
   {
       b0 = *ps++;
       b1 = *ps++;

       *pd++ = b1;
       *pd++ = b0;
   
       len--;
   }
}