#include "socket.h"
#include <sys/time.h>

#ifdef TCP_DEBUG      
#include "debug.h"
#endif

/* Linked list of allocated socket descriptors */
SockIdList globalSockets = NULL;

/* Initialize flag */
int globalInit = 0;

mClient *client;

/*----------  RMP process operations ---------------------------*
/* Routine to be executed once LEFT_GROUP event arrives */
void leftGroup(mRMPEvent *e) {
  if (e != NULL) {
    cout << "Left All Groups" << endl;

#ifdef FLOW_CONTROL_DEBUG
    dumpStats(cout);
#endif /* FLOW_CONTROL_DEBUG */
    
    exit(0);
  }
}

void leaveGroup(int sig)
{
  if (sig == SIGINT || sig == SIGHUP) {
    mRMP::leaveAll(NULL, 0);
    puts("LEAVING GROUP\n");
    DisconnectAllSocket();
  }
}

int
RMPInit()
{
  SIGNAL_CALL(SIGHUP,leaveGroup);
  SIGNAL_CALL(SIGINT,leaveGroup); 
  
  mRMP::init(EVENT_DRIVEN);

  client = new mClient();
  globalInit = 1;
}

/*------------  SockList Operations --------------------------- */
SockIdList
GetEntryBySID(int sockId) {
  SockIdList current;

  CRITICALSTART();
  current = globalSockets;
  while (current) {
    if (current->sd == sockId)
      break;
    current = current->next;
  }
  CRITICALSTOP();

  return current;
}

SockIdList
GetEntryByGroup(char *groupName)
{
  SockIdList tmp;

  CRITICALSTART();
  tmp= globalSockets;
  while(tmp){
    if((tmp->group != NULL) &&
       !strcmp(tmp->group->returnRMPGroup()->returnGroupName(), groupName))
      return tmp;
    tmp = tmp->next;
  }
  CRITICALSTOP();
  return (SockIdList)NULL;
}

int
DeleteEntryBySID(int sockId) {

  CRITICALSTART();
  SockIdList current = globalSockets;
  SockIdList prev = globalSockets;
  
  while (current) {
    if (current->sd == sockId) {
      prev->next = current->next;
      free(current);
      return 1;
    }
    prev = current;
    current = current->next;
  }
  CRITICALSTOP();
  return 0;
}

void DisconnectAllSocket() 
{
  CRITICALSTART();
  SockIdList entry = globalSockets;
  while(entry) {
    entry->state = NOT_CONNECTED;
    entry = entry->next;
  }
  CRITICALSTOP();
}

int LastSocketGroup(int sock)
{
  SockIdList sockEntry, tmp;
  mRMPGroup *grp;
  
  sockEntry = GetEntryBySID(sock);

  CRITICALSTART();
  grp = sockEntry->group;
  tmp = globalSockets;
  while(tmp) {
    if((tmp->group != NULL) &&
       !strcmp(tmp->group->returnRMPGroup()->returnGroupName(), grp->returnGroupName()) &&
       (tmp->sd != sock))
      return 0;
    tmp = tmp->next;
  }
  CRITICALSTOP();
  return 1;
}
		
int OutOfRange(QOS option)
{
  switch(option) {
  case QOS_UNRELIABLE:
  case QOS_UNORDERED:
  case QOS_SOURCE_ORDERED:
  case QOS_CAUSAL_ORDERED:
  case QOS_TOTALLY_ORDERED:
  case QOS_K_RESILIENT:
  case QOS_MAJORITY_RESILIENT:
  case QOS_TOTALLY_RESILIENT:
    return 1;
    break;
  default:
    return 0;
    break;
  }
}

int NotTimeOut(struct timeval timeout, struct timeval start)
{
  static struct timeval current;
  static struct timezone tz;
  long delay, timeout_len;

  gettimeofday(&current, (void*)&tz);
  delay=(current.tv_sec-start.tv_sec)*1000000 +
    (current.tv_usec-start.tv_usec);
  timeout_len = timeout.tv_sec*1000000 + timeout.tv_usec;
  if(delay >= timeout_len) return 0;
  else return 1;
}