#include <string>
#include <iostream>
#include <map>

#include "../main/MiscSupport.h"

class HttpInput
{
public:
  enum RequestType { hrtUnknown, 
		     hrtGet, 
		     hrtPost, 
		     hrtPut, 
		     hrtHead } requestType;
  std::string uri;
  std::string versionString;
  std::map< std::string, std::string > headers;
  std::string body;
  HttpInput() :
    requestType(hrtUnknown)
  {
  }
};


class HttpInputHelper
{
public:
  enum HttpState { hsAwaitingInitialRequestLine,
		   hsAwaitingHeaders,
		   hsAwaitingBodyWhole,
		   hsAwaitingBodyChunkedSize,
		   hsAwaitingBodyChuckedData,
		   hsAwaitingFooters,
		   hsReadComplete,
		   hsError } state;
  std::string lastHeader;
  HttpInputHelper() :
    state(hsAwaitingInitialRequestLine)
  {
  }
};

static bool getLine(std::string &newLine, std::string &buffer)
{
  int split = buffer.find('\n');
  if (split == buffer.npos)
    {
      newLine.clear();
      return false;
    }
  newLine = buffer.substr(0, split);
  buffer.erase(0, split+1);
  int length = newLine.length();
  if (length && (newLine[length - 1] == '\r'))
    {
      newLine.erase(length - 1);
    }
  return true;
}

static void readHttp(HttpInput &httpInput, 
		     HttpInputHelper &httpInputHelper,
		     std::string &buffer)
{
  HttpInputHelper::HttpState &state = httpInputHelper.state;
  while (true)
    {
      switch (state)
	{
	case  HttpInputHelper::hsAwaitingInitialRequestLine:
	  {
	    std::string initialRequestLine;
	    if (!getLine(initialRequestLine, buffer))
	      {
		return;
	      }
	    int break1 = initialRequestLine.find(' ');
	    if (break1 == initialRequestLine.npos)
	      {
		state = HttpInputHelper::hsError;
		return;
	      }
	    std::string requestType = initialRequestLine.substr(0, break1);
	    initialRequestLine.erase(0, break1+1);
	    if (requestType == "GET")
	      {
		httpInput.requestType = HttpInput::hrtGet;
	      }
	    else if (requestType == "POST")
	      {
		httpInput.requestType = HttpInput::hrtPost;
	      }
	    else if (requestType == "PUT")
	      {
		httpInput.requestType = HttpInput::hrtPut;
	      }
	    else if (requestType == "HEAD")
	      {
		httpInput.requestType = HttpInput::hrtHead;
	      }
	    else
	      {
		httpInput.requestType = HttpInput::hrtUnknown;
	      }
	    std::cout<<"requestType = '"
		     <<requestType
		     <<"' "
		     <<((int) httpInput.requestType)
		     <<'\n';
	    int break2 = initialRequestLine.rfind(' ');
            if (break2 == initialRequestLine.npos)
              {
                state = HttpInputHelper::hsError;
                return;
              }
	    httpInput.uri = initialRequestLine.substr(0, break2);
	    std::cout<<"uri = '"
		     <<httpInput.uri
		     <<"'\n";
            initialRequestLine.erase(0, break2+1);
	    httpInput.versionString = initialRequestLine;
	    std::cout<<"version = '"
		     <<httpInput.versionString
		     <<"'\n";
	    state = HttpInputHelper::hsAwaitingHeaders;
	    break;
	  }
	case HttpInputHelper::hsAwaitingHeaders:
	  {
	    std::string newHeader;
	    if (!getLine(newHeader, buffer))
	      {
		return;
	      }
	    if (newHeader.empty())
	      {
		state = HttpInputHelper::hsAwaitingBody;
		break;
	      }
	    if ((newHeader[0] == ' ') || (newHeader[0] == '\t'))
	      {
		if (httpInputHelper.lastHeader.empty())
		  {
		    state = HttpInputHelper::hsError;
		    return;
		  }
		else 
		  {
		    int break1 = newHeader.find_first_not_of(" \t");
		    newHeader.erase(0, break1);
		    httpInput.headers[httpInputHelper.lastHeader] += 
		      ' ' + newHeader;
		    std::cout<<"header '"
			     <<httpInputHelper.lastHeader
			     <<"' = '"
			     <<httpInput.headers[httpInputHelper.lastHeader]
			     <<"'\n";
		    break;
		  }
	      }
            int break1 = newHeader.find(':');
            if (break1 == newHeader.npos)
              {
                state = HttpInputHelper::hsError;
                return;
              }
	    std::string headerName = newHeader.substr(0, break1);
            newHeader.erase(0, break1+1);
	    int break2 = newHeader.find_first_not_of(' ');
	    if (break2 != newHeader.npos)
	      {
		newHeader.erase(0, break2);
	      }
	    int break3 = newHeader.find_last_not_of(' ');
	    if (break3 != newHeader.npos)
	      {
		newHeader.erase(break3+1);
	      }
	    httpInputHelper.lastHelper = headerName;
	    httpInput.headers[headerName] = newHeader;
	    std::cout<<"header '"
		     <<headerName
		     <<"' = '"
		     <<newHeader
		     <<"'\n";
	    break;
	  }
	case HttpInputHelper::hsAwaitingBody:
	  {
	    if (getProperty(httpInput.headers, "Transfer-Encoding", "") =="chunked")
	      {
		state = HttpInputHelper::hsAwaitingBodyChunkedSize;
		break;
	      }
	    else if ()
	      {
                state = HttpInputHelper::hsAwaitingBodyWhole;
                break;
	      }
	    else
	      {
		state = HttpInputHelper::hsReadComplete;
		return;
	      }
	  }
	case HttpInputHelper::hsAwaitingBodyWhole:
	case HttpInputHelper::hsAwaitingBodyChunkedSize:
	case HttpInputHelper::hsAwaitingBodyChuckedData:
	case HttpInputHelper::hsAwaitingFooters:
	case HttpInputHelper::hsReadComplete:
	case HttpInputHelper::hsError:
	  return;
	}
    }
}


int main(int argc, char *argv[])
{
  std::string buffer;
  HttpInput httpInput;
  HttpInputHelper httpInputHelper;
  while (std::cin)
    {
      std::cout<<"== "
	       <<((int)httpInputHelper.state)
	       <<" ====================\n";
      char line[256];
      std::cin.getline(line, 255);
      buffer += line;
      buffer += "\r\n";
      readHttp(httpInput, httpInputHelper, buffer);
    }
}