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

#include <errno.h>

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

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>


#include "stats.h"


extern BUFFER_TABLE *buffer_table;

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


#ifdef LINK

int istart = 0;

int obtain_data_buffer(int link_index)
{
    int i, j;
    unsigned int k=0;

        (*StatsMem[GETBUFFER1])++;
        (*StatsMem[GETBUFFER1 + ((link_index+1)*MAXCOUNTERS)])++;

    sprintf (message_buffer,"Entering obtain_data_buffer for link %d", link_index);
    report_message(MSG_TRACE);

//    start in buffer list where we last finished

        j = link_index*N_DATA_BUFFERS;
        for (i = istart; i < N_DATA_BUFFERS; i++) {
            if (buffer_table->buffer_status[j+i] == FREE) {
                buffer_table->buffer_status[j+i] = INUSE;
                buffer_table->buffers_free[link_index]--;

                sprintf (message_buffer,"Exiting obtain_data_buffer for link %d with buffer index %d",link_index, i);
                report_message(MSG_TRACE);

                istart = (istart+1) & (N_DATA_BUFFERS-1);
                return i;
            }
        }

//    not found a free buffer - try again from the list start

        istart = 0;
        j = link_index*N_DATA_BUFFERS;
        for (i = istart; i < N_DATA_BUFFERS; i++) {
            if (buffer_table->buffer_status[j+i] == FREE) {
                buffer_table->buffer_status[j+i] = INUSE;
                buffer_table->buffers_free[link_index]--;

                sprintf (message_buffer,"Exiting obtain_data_buffer for link %d with buffer index %d",link_index, i);
                report_message(MSG_TRACE);

                istart = (istart+1) & (N_DATA_BUFFERS-1);
                return i;
            }
        }

//    no free buffer at present - wait for one to become available

        (*StatsMem[NOBUFFER1])++;
        (*StatsMem[NOBUFFER1 + ((link_index+1)*MAXCOUNTERS)])++;

    for (;;) {

        sprintf (message_buffer,"No free data buffers for link %d in obtain_data_buffer", link_index);
        report_message(MSG_TRACE);

        (*StatsMem[NOBUFFER2])++;
        (*StatsMem[NOBUFFER2 + ((link_index+1)*MAXCOUNTERS)])++;

        usleep(20000);      /*   1/50 sec  */

        istart = 0;
        j = link_index*N_DATA_BUFFERS;
        for (i = istart; i < N_DATA_BUFFERS; i++) {
            if (buffer_table->buffer_status[j+i] == FREE) {
                buffer_table->buffer_status[j+i] = INUSE;
                buffer_table->buffers_free[link_index]--;

                sprintf (message_buffer,"Exiting obtain_data_buffer for link %d with buffer index %d",link_index, i);
                report_message(MSG_TRACE);

                istart = (istart+1) & (N_DATA_BUFFERS-1);
                return i;
            }
        }

    }

}
#endif


#ifdef MERGE
int obtain_data_buffer(int link_index)
{
    int i, j;

    sprintf (message_buffer,"Entering obtain_data_buffer for link %d", link_index);
//    report_message(MSG_TRACE);

        j = link_index*N_DATA_BUFFERS;
        for (i = 0; i < N_DATA_BUFFERS; i++) {
            if (buffer_table->buffer_status[j+i] == QUEUED) {
                buffer_table->buffer_status[j+i] = PROCESSING;

                sprintf (message_buffer,"Exiting obtain_data_buffer for link %d with buffer index %d",link_index, i);
                report_message(MSG_TRACE);

         (*StatsMem[GETBUFFER2])++;
         (*StatsMem[GETBUFFER2+((link_index+1)*MAXCOUNTERS)])++;

                return i;
            }
        }

//    no buffer at present

         (*StatsMem[NOBUFFER3])++;
         (*StatsMem[NOBUFFER3+((link_index+1)*MAXCOUNTERS)])++;

    sprintf (message_buffer,"No data buffer for link %d pending", link_index);
//    report_message(MSG_TRACE);

      return -1;
}
#endif

#ifdef LINK
int queue_data_buffer(int link_index, int i)
{

    int j;
    int rc;

    sprintf (message_buffer,"Entering queue_data_buffer for link %d index %d", link_index, i);
    report_message(MSG_TRACE);

    j = link_index*N_DATA_BUFFERS;
    if (buffer_table->buffer_status[j+i] == INUSE) {
        buffer_table->buffer_status[j+i] = QUEUED;
        sprintf (message_buffer, "Queued data buffer (%d) for link %d in queue_data_buffer", i, link_index);
        report_message(MSG_TRACE);


         (*StatsMem[QBUFF])++;
         (*StatsMem[QBUFF+((link_index+1)*MAXCOUNTERS)])++;

        rc = 0;
    } else {
        sprintf (message_buffer, "Attempt to queue invalid buffer (%d) for link %d %d in queue_data_buffer", i, link_index, buffer_table->buffer_status[j+i]);
        report_message(MSG_TRACE);

         (*StatsMem[QFAIL])++;
         (*StatsMem[QFAIL+((link_index+1)*MAXCOUNTERS)])++;

        rc = -1;
    }
    return rc;

}
#endif

#ifdef LINK
int release_data_buffer(int link_index, int i)
{
    int rc;
    int j;

    sprintf (message_buffer,"Entering release_data_buffer for link %d with buffer index %d", link_index, i);
    report_message(MSG_TRACE);

    j = link_index*N_DATA_BUFFERS;
    if (buffer_table->buffer_status[j+i] == DONE) {
        buffer_table->buffer_status[j+i] = FREE;
        buffer_table->buffers_free[link_index]++;
        sprintf (message_buffer, "Released data buffer (%d) in release_data_buffer", i);
        report_message(MSG_TRACE);

         (*StatsMem[RBUFF1])++;
         (*StatsMem[RBUFF2+((link_index+1)*MAXCOUNTERS)])++;

        rc = 0;
    } else {
        sprintf (message_buffer, "Attempt to release free buffer (%d) in release_data_buffer", i);
        report_message(MSG_TRACE);

         (*StatsMem[RFAIL1])++;
         (*StatsMem[RFAIL1+((link_index+1)*MAXCOUNTERS)])++;

        rc = -1;
    }

    sprintf (message_buffer,"Exiting release_data_buffer (index %d)", i);
    report_message(MSG_TRACE);
    return rc;
}
#endif

#ifdef LINK
int release_all_data_buffers(int link_index)
{
    int i,j;

    sprintf (message_buffer,"Entering release_all_data_buffers for link %d", link_index);
    report_message(MSG_TRACE);

    j = link_index*N_DATA_BUFFERS;
    buffer_table->buffers_free[link_index] = N_DATA_BUFFERS;              /* set all to free */
    for (i = 0; i < N_DATA_BUFFERS; i++) {
       buffer_table->buffer_status[j+i] = FREE;  /* set all to free */
    }

    sprintf (message_buffer,"Exiting release_all_data_buffers");
    report_message(MSG_TRACE);
    return 0;
}
#endif

#ifdef MERGE
int release_data_buffer(int link_index, int i)
{
    int rc;
    int j;

    sprintf (message_buffer,"Entering release_data_buffer for link %d with buffer index %d", link_index, i);
    report_message(MSG_TRACE);

    j = link_index*N_DATA_BUFFERS;
    if (buffer_table->buffer_status[j+i] == DONE) {
        buffer_table->buffer_status[j+i] = FREE;
        buffer_table->buffers_free[link_index]++;
        sprintf (message_buffer, "Released data buffer (%d) in release_data_buffer", i);
        report_message(MSG_TRACE);

         (*StatsMem[RBUFF2])++;
         (*StatsMem[RBUFF2+((link_index+1)*MAXCOUNTERS)])++;

        rc = 0;
    } else {
        sprintf (message_buffer, "Attempt to release free buffer (%d) in release_data_buffer", i);
        report_message(MSG_TRACE);

         (*StatsMem[RFAIL2])++;
         (*StatsMem[RFAIL2+((link_index+1)*MAXCOUNTERS)])++;

        rc = -1;
    }

    sprintf (message_buffer,"Exiting release_data_buffer (index %d)", i);
    report_message(MSG_TRACE);
    return rc;
}
#endif