// g++ FcgiFrontEndTest1.C FcgiFrontEnd.C ../shared/MiscSupport.C

// This is similar to FcgiFrontEndTest1.C but I'm trying to check for multiple connections at the same time.

#include <set>
#include <iostream>
#include <fstream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

#include "FcgiFrontEnd.h"

//static std::fstream logFile;
static std::ostream &logFile = std::cout;

static int externalSocket;

static FcgiFrontEnd *frontEnd;

class MyActions : public FcgiExternalActions
{
public:
  void newResponderRequest(FcgiRequestId id,
			   PropertyList const &params,
			   std::string stdin);
  void abort(FcgiRequestId id);
  void assertionFailed(std::string message);
  void debugInformation(std::string message);
  void sendBytes(std::string);
};

bool checkInput()
{
  char buffer[1024];
  ssize_t result = read(externalSocket, buffer, 1024);
  if (result < 0)
    {
      if (errno == EAGAIN)
	{
	  logFile<<"No input available.\n";
	}
      else
	{
	  logFile<<"unexpected error in input "<<errorString()
		 <<"\n";
	  logFile.flush();
	  exit(98);
	}
    }
  else if (result == 0)
    {
      logFile<<"Read 0 bytes.  End of file?\n";
      return false;
    }
  else
    {
      logFile<<"read "<<result<<" bytes.";
      frontEnd->bytesReceived(std::string(buffer, result));
    }
  return true;
}

void MyActions::newResponderRequest(FcgiRequestId id,
				    PropertyList const &params,
				    std::string stdin)
{
  logFile<<"newResponderRequest id="<<id<<"\n";
  frontEnd->setHeader(id, "Content-Type", "text/plain");
  for (PropertyList::const_iterator it = params.begin();
       it != params.end();
       it++)
    {
      frontEnd->sendBody(id, it->first + " => " + it->second + ", ");
      if (!checkInput())
	{
	  // This idea is correct, but it's not enough.  When we see an eof on
	  // the socket, we need to stop sending any output to the socket.
	  // That's not just the line below, but the standard end of message
	  // stuff.
	  break;
	}
      sleep(1);
    }
  frontEnd->sendBody(id, "=================================\r\n");
  frontEnd->close(id, 0);
  logFile.flush();
}

void MyActions::abort(FcgiRequestId id)
{
  logFile<<"abort requested, id="<<id<<"\n";
  logFile.flush();
  frontEnd->sendBody(id, "Aborted on user request.\r\n");
  frontEnd->close(id, 0);
}

void MyActions::assertionFailed(std::string message)
{
  logFile<<"assertion failed:  "<<message<<"\n";
  logFile.flush();
}

void MyActions::debugInformation(std::string message)
{
  logFile<<"debug information:  "<<message<<"\n";
  logFile.flush();
}

void MyActions::sendBytes(std::string b)
{
  logFile<<"sendBytes-toserver("<<urlEncode(b)<<")\n";
  char const *start = b.data();
  int remaining = b.size();
  while (remaining > 0)
    {
      ssize_t result = write(externalSocket, start, remaining);
      if (result < 0)
	{
	  logFile<<errorString()<<"\nwriting in sendBytes()\n";
	  logFile.flush();
	  exit(99);
	}
      remaining -= result;
      if (remaining)
	{
	  logFile<<"Retrying write.  Sent "<<result<<" bytes.  "<<remaining<<" remain.\n";
	  logFile.flush();
	  if (result == 0)
	    {
	      sleep(1);
	    }
	}
    }
}
  
int main(int argc, char **argv)
{
  //logFile.open("/tmp/fcgi.log", std::ios_base::out | std::ios_base::app);
  logFile<<"============================================\nStarting\n";
  logFile.flush();
  MyActions actions;
  frontEnd = new FcgiFrontEnd(&actions);
  int mainSocket = socket(PF_INET, SOCK_STREAM, 0);
  if (mainSocket == -1)
    {
      perror("socket()");
      exit(102);
    }
  // http://hea-www.harvard.edu/~fine/Tech/addrinuse.html
  int on=1;
  setsockopt(mainSocket, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
  struct sockaddr_in my_addr;
  my_addr.sin_family = AF_INET;
  my_addr.sin_port = htons(1234); // listening on port 1234.
  my_addr.sin_addr.s_addr = INADDR_ANY;
  int bind_result = bind(mainSocket, (sockaddr*)&my_addr, sizeof(my_addr));
  if (bind_result)
    {
      perror("bind()");
      exit(103);
    }
  int listen_result = listen(mainSocket, 1024);
  if (listen_result)
    {
      perror("listen()");
      exit(104);
    }
  while (true)
    {
      logFile<<"Listening for new socket.\n";
      externalSocket = accept(mainSocket, NULL, 0);
      if (externalSocket == -1)
	{
	  perror("accept");
	  exit(105);
	}
      fcntl(externalSocket, F_SETFL, O_NONBLOCK);
      while (true)
	{
	  char buffer[1024];
	  ssize_t result = read(externalSocket, buffer, 1024);
	  if (result < 0)
	    {
	      if (errno == EAGAIN)
		{
		  logFile<<"waiting\n";
		  sleep(1);
		}
	      else
		{
		  logFile<<errorString()
			 <<"\nread\n";
		  logFile.flush();
		  exit(98);
		}
	    }
	  else if (result == 0)
	    {
	      logFile<<"Read 0 bytes.  End of file?\n";
	      break;
	    }
	  else
	    {
	      frontEnd->bytesReceived(std::string(buffer, result));
	    }
	}
      close(externalSocket);
    }
}