#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/signal.h>
#include <netinet/in.h>
#include <netdb.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include "1xdaemon.h"
#include "logging.h"

int msgSock    = -1;
int serverSock = -1;

int sa_length  =  0;
struct sockaddr_in caller;
const int MSGBUFMAX = 512;

void sig_pipe(int signum)
{
  xlogf(DEBUG_NORMAL, "SIGPIPE\n");
  signal(SIGPIPE, sig_pipe);
}

int serverSockInit()
{
  // For socket related calls.
  int sockErr = 0;

  // Mode, addr, and port data for our socket
  struct sockaddr_in sa;

  sa.sin_family = AF_INET;
  sa.sin_addr.s_addr = htonl(INADDR_ANY);
  sa.sin_port   = htons(10240);

  //Register for SIGPIPE so we can recover from broken pipes
  signal(SIGPIPE, sig_pipe);

  // We're ready to begin authentication... set up a socket for a client frontend to connect to:
  serverSock = socket(AF_INET, SOCK_STREAM, 0);

  // Check for errors in the socket creation
  if(serverSock == -1) {
    xlogf(DEBUG_NORMAL, "An error occured while attempting to setup the client socket in 1xdriver.c\nError: %d\n", errno);
  } else {
    int sockOpts = fcntl(serverSock, F_GETFL, 0);
    // Set our socket to non-blocking
    sockErr = fcntl(serverSock, F_SETFL, sockOpts | O_NONBLOCK);
    if(sockErr == -1) {
      xlogf(DEBUG_NORMAL, "An error occured while attempting to set non-blocking mode in 1xdriver.c\nError: %d\n", errno);
    } else {
      sockErr = bind(serverSock, (struct sockaddr *)&sa, sizeof(sa));
      if(sockErr == -1) {
        xlogf(DEBUG_NORMAL, "An error occured while attempting to bind socket in 1xdriver.c\nError: %d\n", errno);
      } else {
        sa_length = sizeof(sa);
        sockErr = listen(serverSock, 1);
        if(sockErr == -1){
          xlogf(DEBUG_NORMAL, "An error occured while attempting to listen on socket in 1xdriver.c\nError: %d\n", errno);
        } else {
          xlogf(DEBUG_NORMAL, "Server Socket Initialized.\n");
        }
      }
    }
  }

  return serverSock;
}

void lower_str(char *instr)
{
  int i;
  
  for (i=0; i<=strlen(instr); i++)
    {
      instr[i] = tolower(instr[i]);
    }
}

// Process any messages we have recieved.
int process_message(char *msgBuf)
{
  char *setget, *remainder;
  char *setme = "set", *getme = "get", *status = "stat";

  setget = (char *)malloc(strlen(msgBuf));  // This is more than we should need, but it should be safe.
  
  remainder = (char *)malloc(strlen(msgBuf));

  sscanf(msgBuf, "%s %s",setget, remainder);

  lower_str(setget);
  lower_str(remainder);

  xlogf(DEBUG_NORMAL, "Got set/get type : %s  --  With %s left over.\n", setget, remainder);

  if (strncmp(setget, setme, 3) == 0)
    {
      printf("We should now do a set!\n");
    } else if (strncmp(setget, getme, 3) == 0)
      {
	printf("We should now do a get!\n");
      } else if (strncmp(setget, status, 4) == 0)
	{
	  printf("Status request!\n");
	}
  
}

int handleMessages()
{
  char msgBuffer[MSGBUFMAX];
  int read_status = -1;
  int write_status = -1;

  if(msgSock == -1)
    {
      msgSock = accept(serverSock, (struct sockaddr *)&caller, &sa_length);
    }
  
  if(msgSock == -1)
    {
      if(errno != EWOULDBLOCK)
	{
	  xlogf(DEBUG_NORMAL, "An error occured on accept in 1xdriver.c\n%d\n", errno);
	}
    }
  else
    {
      bzero(msgBuffer, MSGBUFMAX);
      
      if((read_status = recv(msgSock, msgBuffer, sizeof(msgBuffer), 0)) < 0)
	{
	  if(errno != EWOULDBLOCK)
	    {
	      xlogf(DEBUG_NORMAL, "An error occured in read() in 1xdriver.c\n%d\n", errno);
	    }
	}
      else if(read_status == 0)
	{
	  bzero(msgBuffer, MSGBUFMAX);
	  strcpy(msgBuffer, "?");
	  write_status = send(msgSock, msgBuffer, sizeof(msgBuffer), 0);
	  if(write_status == -1)
	    {
	      if(errno == EPIPE || errno == ECONNRESET) // Our client connection is broken
		{
		  close(msgSock);
		  msgSock = -1;
		}
	    }
	}
      else
	{
	  xlogf(DEBUG_NORMAL, "Message: %s", msgBuffer);
	  process_message(msgBuffer);
	  bzero(msgBuffer, MSGBUFMAX);
	  strcpy(msgBuffer, "ACK\n");
	  send(msgSock, msgBuffer, sizeof(msgBuffer), 0);
	}
    }  
  return 0;  // To keep the compiler from complaining.
}