// g++ FcgiFrontEndTest.C FcgiFrontEnd.C ../ax_alert_server/XmlSupport.C ../shared/MiscSupport.C

// This simple test dumps all of it's input back to the user, like php_info().

#include <iostream>
#include <fstream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#include "../ax_alert_server/XmlSupport.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);
};

void MyActions::newResponderRequest(FcgiRequestId id,
				    PropertyList const &params,
				    std::string stdin)
{
  logFile<<"newResponderRequest id="<<id<<"\n";
  frontEnd->setHeader(id, "Content-Type", "text/xml");
  XmlNode body;
  body.properties["id"] = ntoa(id);
  XmlNode &p = body["params"];
  for (PropertyList::const_iterator it = params.begin();
       it != params.end();
       it++)
    {
      XmlNode &param = p[-1];
      param.properties["name"] = it->first;
      param.properties["value"] = it->second;
    }
  body.properties["stdin"] = stdin;
  frontEnd->sendBody(id, body.asString());
  //logFile<<"frontEnd->sendBody("<<id<<",'"<<body.asString()<<"')\n";
  frontEnd->close(id, 0);
  logFile.flush();
}

void MyActions::abort(FcgiRequestId id)
{
  logFile<<"abort requested, id="<<id<<"\n";
  logFile.flush();
}

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);
	}
      while (true)
	{
	  char buffer[1024];
	  ssize_t result = read(externalSocket, buffer, 1024);
	  if (result < 0)
	    {
	      logFile<<errorString()
		     <<"\nread\n";
	      logFile.flush();
	      exit(98);
	    }
	  if (result == 0)
	    {
	      logFile<<"Read 0 bytes.  End of file?\n";
	      break;
	    }
	  frontEnd->bytesReceived(std::string(buffer, result));
	}
      close(externalSocket);
    }
}