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

#include <stdlib.h> /* getenv, exit */
#include <signal.h>
#include <errno.h>
#include <unistd.h>

#include <sys/types.h>

#include "common.h"
#include "message.h"
#include "buffer.h"

#include "stats.h"
#include "netvar.h"

//    this tasks process ID and its master process ID 

pid_t mypid; 
pid_t Masterpid;
pid_t Mergepid;
pid_t Linkpid[NUMlinks];

//    Shared Memory Key to use

key_t  shmkey = SHMKEY;

//    address of shared data area

void * shm_dataarea;

//    address of shared buffer area

void * shm_bufferarea[NUMlinks];

//    Shared tables held in the shared memory segment

STATUS_TABLE *status_table;

BUFFER_TABLE *buffer_table;

//    table of data link threads

LINK_TABLE *link_table[NUMlinks];

int * StatsMem[NUMCOUNTERS];
int * RatesMem[NUMCOUNTERS];

//    some program options

int data_buffer_size = TRANSFER_BUFFER_SIZE;
int server_options = 0;

int LinkNum = 0;
int verbose = 0;

int *LinkStatus;   /* &link_table[LinkNum]->link_status  */
int *LinkState;    /* &link_table[LinkNum]->link_state  */
int *LinkCtrl;   /* &link_table[LinkNum]->link_ctrl  */
int *LinkActive;   /* &link_table[LinkNum]->link_isActive  */

int Tcp_Port[MAXPORTS];
int SocketConnected[MAXPORTS];
int TransferSize[MAXPORTS];
int BlockSequence[MAXPORTS];
int Done[MAXPORTS];
char * data_buffer[MAXPORTS];
char * input_buffer;
int ReadEnable[MAXPORTS];
int ACKneeded [MAXPORTS];

int Length[MAXPORTS];
int Endian[MAXPORTS];

void link_server(int);
void link_init(int);
void stats_init();

void Usage(char *progname) {
    fprintf(stderr,"Usage\n%s -p [port] - i [IDs]\n",progname);
    fprintf(stderr,"\tport is the base TCP port to use (default 11001)\n");
    fprintf(stderr,"\tIDs is the number of data streams to handle (default 1)\n");
    exit(1);
}

//    data link interface

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

   int i=0;
   int j;
   int size;
   int index;

   mypid = getpid();
   Masterpid = getppid();

   msg_init();
   sig_init();

   report_version();

//    defaults for configuration information which may be supplied via the command line

   shmkey = SHMKEY;    /* set default value */
   Tcp_Port[0] = MERGE_TCP_PORT;

//    command line arguments

    if (argc >1) {
        for(i=1;i <argc;i++) {
            if ( (argv[i][0] == '-') || (argv[i][0] == '/') ) {
                switch(argv[i][1]) {
                    case 'p':
                        Tcp_Port[0] = atoi(argv[++i]);
                        break;
                    case 'i':
                        LinkNum = atoi(argv[++i]);
                        break;
                    case 'm':
                        Mergepid = atoi(argv[++i]);
                        break;
                    case 'v':
                        verbose = 1;
                        if ((i+1) < argc && argv[i+1][0] != '-') verbose = atoi(argv[++i]);
                        break;
                    default:
                        Usage(argv[0]);
                        break;
                }
            }
            else
                Usage(argv[0]);
        }
    }

   for (i=0; i<MAXPORTS; i++) Tcp_Port[i]=Tcp_Port[0]+i;

   sprintf(message_buffer, "Configuration: index = %d, SHM key=%d, TCP port base = %d", LinkNum, shmkey, Tcp_Port[LinkNum]);
   report_message(MSG_INFORMATION);

//    map shared memory segment containing control tables

   size = sizeof(STATUS_TABLE) +
          sizeof(BUFFER_TABLE) +
          (NUMlinks * sizeof(LINK_TABLE));
   shm_dataarea = alloc_data_area(shmkey, size);

//    setup addresses of data tables within the shared memory 

    status_table = (STATUS_TABLE *) shm_dataarea;
    status_table->buffer_table_offset = sizeof(STATUS_TABLE);
    status_table->link_table_offset[LinkNum] = sizeof(STATUS_TABLE) + sizeof(BUFFER_TABLE) 
                  + (LinkNum * sizeof(LINK_TABLE));

    status_table->master_pid = Masterpid;

   msg_logging_level = status_table->msg_logging_level;
   msg_reporting_level = status_table->msg_reporting_level;
   server_options = status_table->server_options;

//    allocate single local input buffer on the heap
   size = ((DATA_BUFFER_SIZE * 1024) * 1) + sizeof(BUFFER_HEADER);
   input_buffer = malloc(size);
   sprintf(message_buffer, "Allocated %lu bytes for local input buffer", (unsigned long int)size);
   report_message(MSG_INFORMATION);

//    map shared memory segment containing data buffers
   size = ((TRANSFER_BUFFER_SIZE * 1024) * N_DATA_BUFFERS) + sizeof(BUFFER_HEADER);
   shm_bufferarea[LinkNum] = alloc_data_area(shmkey+1+LinkNum, size);

//    initialise buffer table

    buffer_table = (BUFFER_TABLE *) ((char*) status_table + status_table->buffer_table_offset);
    buffer_table->buffer_baseaddress[LinkNum] = (char*) shm_bufferarea[LinkNum] + sizeof(BUFFER_HEADER);

//    initialise link table

   link_table[LinkNum] = (LINK_TABLE *) ((char *) status_table + status_table->link_table_offset[LinkNum]);
   link_table[LinkNum]->link_status = INUSE;
   link_table[LinkNum]->link_pid = mypid;

    LinkStatus = (int*) &link_table[LinkNum]->link_status;
    *LinkStatus= IDLE;
    LinkState = (int*) &link_table[LinkNum]->link_state;
    *LinkState= IDLE;
    LinkCtrl = (int*) &link_table[LinkNum]->link_ctrl;
    *LinkCtrl= IDLE;
    LinkActive = (int*) &link_table[LinkNum]->link_isActive;
    *LinkActive= IDLE;

/*    lastly statistics array  */

    stats_init();

//    start execution

    link_server(LinkNum);

   exit(0);
}