/****************************************************************************************************

RepRapFirmware - Webserver

This class serves web pages to the attached network.  These pages form the user's interface with the
RepRap machine.  It interprests returned values from those pages and uses them to Generate G Codes,
which it sends to the RepRap.  It also collects values from the RepRap like temperature and uses
those to construct the web pages.

It implements very very restricted PHP.  It can do:

   <?php print(myStringFunction()); ?>
   <?php if(myBooleanFunction()) print(myOtherStringFunction()); ?>
   <?php if(myOtherBooleanFunction()) echo 'Some arbitrarily long string of HTML including newlines up to this quote:'; ?>

Note that by printing a function that returns "" you can just call 
that function in this C++ code with no effect on the loaded web page.


-----------------------------------------------------------------------------------------------------

Version 0.1

13 February 2013

Adrian Bowyer
RepRap Professional Ltd
http://reprappro.com

Licence: GPL

****************************************************************************************************/

#include "RepRapFirmware.h"

Webserver::Webserver(Platform* p)
{
  //Serial.println("Webserver constructor"); 
  platform = p;
  lastTime = platform->time();
  writing = false;
  posting = false;
  postSeen = false;
  postLength = 0L;
  inPHPFile = false;
  initialisePHP();
  clientLineIsBlank = true;
  needToCloseClient = false;
  clientLinePointer = 0;
  clientLine[0] = 0;
  clientRequest[0] = 0;
  password = DEFAULT_PASSWORD;
  myName = DEFAULT_NAME;
  gotPassword = false;
  gcodeAvailable = false;
  gcodePointer = 0;
  sendTable = true;
  phpRecordPointer = 0;
  ignoreExtensions = IGNORE_FILE_EXTENSIONS;
}

boolean Webserver::Available()
{
  return gcodeAvailable;
}

byte Webserver::Read()
{
  byte c = gcodeBuffer[gcodePointer];
  if(!c)
  {
     gcodeAvailable = false;
     gcodePointer = 0;
     gcodeBuffer[gcodePointer] = 0;
  } else
    gcodePointer++;
  return c;
}


boolean Webserver::LoadGcodeBuffer(char* gc, boolean convertWeb)
{
  if(gcodeAvailable)
    return false;
  
  if(strlen(gc) > GCODE_LENGTH-1)
  {
    platform->Message(HOST_MESSAGE, "Webserver: GCode buffer overflow.\n");
    return false;  
  }
  
  int gcp = 0;
  gcodePointer = 0;
  gcodeBuffer[gcodePointer] = 0;
  
  char c;
  
  while(c = gc[gcp++])
  {
    if(c == '+' && convertWeb)
      c = ' ';
    if(c == '%'&& convertWeb)
    {
      c = 0;
      if(isalpha(gc[gcp]))
        c += 16*(gc[gcp] - 'A' + 10);
      else
        c += 16*(gc[gcp] - '0');
      gcp++;
      if(isalpha(gc[gcp]))
        c += gc[gcp] - 'A' + 10;
      else
        c += gc[gcp] - '0';
      gcp++;
    }
    gcodeBuffer[gcodePointer++] = c;
  }
  gcodeBuffer[gcodePointer] = 0;
  gcodePointer = 0;  
  
// We intercept two G Codes so we can deal with file manipulation.  That
// way things don't get out of sync.
  
/*  if(StringStartsWith(gc, "M28")) // Upload file?
  {
    uploadFile(&gc[4]);
    return;
  }*/
  
  if(StringStartsWith(gcodeBuffer, "M30")) // Delete file?
  {
    if(!platform->deleteFile(&gcodeBuffer[4]))
    {
      platform->Message(HOST_MESSAGE, "Unsuccsessful attempt to delete: ");
      platform->Message(HOST_MESSAGE, &gcodeBuffer[4]);
      platform->Message(HOST_MESSAGE, "\n");
    }
    gcodePointer = 0;
    gcodeBuffer[gcodePointer] = 0;
    gcodeAvailable = false;
    return true;
  }

// Otherwise, send them to the G Code interpreter

  gcodeAvailable = true;
  return true;
}

boolean Webserver::StringEndsWith(char* string, char* ending)
{
  int j = strlen(string);
  int k = strlen(ending);
  if(k > j)
    return false;
  
  return(!strcmp(&string[j - k], ending));
}

boolean Webserver::StringStartsWith(char* string, char* starting)
{ 
  int j = strlen(string);
  int k = strlen(starting);
  if(k > j)
    return false;
  
  for(int i = 0; i < k; i++)
    if(string[i] != starting[i])
      return false;
      
  return true;
}

void Webserver::CloseClient()
{
  writing = false;
  inPHPFile = false;
  initialisePHP();
  clientCloseTime = platform->time();
  needToCloseClient = true;   
}

char* Webserver::prependRoot(char* root, char* fileName)
{
  strcpy(scratchString, root);
  return strcat(scratchString, fileName);
}


void Webserver::SendFile(char* nameOfFileToSend)
{
//  Serial.print("Sending: ");
//  Serial.println(nameOfFileToSend);
  
  if(!gotPassword)
  {
    sendTable = false;
    nameOfFileToSend = PASSWORD_PAGE;
  } else
    sendTable = true;
    
  platform->SendToClient("HTTP/1.1 200 OK\n");
  
  if(StringEndsWith(nameOfFileToSend, ".png"))
    platform->SendToClient("Content-Type: image/png\n");
  else
    platform->SendToClient("Content-Type: text/html\n");
    
  platform->SendToClient("Connnection: close\n");
  
//          if(loadingImage)
//          {
//           platform->SendToHost("Cache-Control: max-age=3600\n");
//           Serial.println("Image requested");
//          }

  platform->SendToClient('\n');
  
//  if(InternalFile(nameOfFileToSend))
//    return;
  
  //Serial.print("File requested: ");
  //Serial.println(nameOfFileToSend);
  
  fileBeingSent = platform->OpenFile(prependRoot(platform->getWebDir(), nameOfFileToSend), false);
  if(fileBeingSent < 0)
  {
    sendTable = false;
    nameOfFileToSend = "html404.htm";
    fileBeingSent = platform->OpenFile(prependRoot(platform->getWebDir(), nameOfFileToSend), false);
  }
  
  inPHPFile = StringEndsWith(nameOfFileToSend, ".php");
  if(inPHPFile)
    initialisePHP();
  writing = true; 
}

void Webserver::WriteByte()
{
    unsigned char b;
    if(platform->Read(fileBeingSent, b))
      platform->SendToClient(b);
    else
    {     
      platform->Close(fileBeingSent);    
      CloseClient(); 
    }  
}


void Webserver::initialisePHP()
{
  phpTag[0] = 0;
  inPHPString = 0;
  phpPointer = 0;
  phpEchoing = false;
  phpIfing = false;
  phpPrinting = false;
  eatInput = false;
  recordInput = false;
  phpRecordPointer = 0;
  phpRecord[phpRecordPointer] = 0;
  ifWasTrue = true;
}

char Webserver::PHPParse(char* phpString)
{
  if(!strcmp(phpString, "if("))
    return PHP_IF;
    
  if(!strcmp(phpString, "echo"))
    return PHP_ECHO;   
  
  if(!strcmp(phpString, "print("))
    return PHP_PRINT;
  
  return NO_PHP;
}


boolean Webserver::printLinkTable() { boolean r = sendTable; sendTable = true; return r; }

boolean Webserver::callPHPBoolean(char* phpRecord)
{ 
  if(!strcmp(phpRecord, "gotPassword("))
    return gotPassword;
    
  if(!strcmp(phpRecord, "printLinkTable("))
    return printLinkTable();
    
  platform->Message(HOST_MESSAGE, "callPHPBoolean(): non-existent function - ");
  platform->Message(HOST_MESSAGE, phpRecord);
  platform->Message(HOST_MESSAGE, "\n");
  
  return true; // Best default
}

int Webserver::fileCount(char* list)
{
  int p = 0;
  int count = 0;
  while(list[p])
  {
    if(list[p] == FILE_LIST_SEPARATOR)
      count++;
    p++;
  }
  return count;
}

void Webserver::printGCodeTable(char* function)
{
  char* list = platform->FileList(platform->getGcodeDir());
  int count = fileCount(list);
  
  if(count <= 0)
  {
    platform->SendToClient("<br>No GCode files present.<br>");
    return;
  }
  
  int cols = (int)(sqrt((float)count)) + 1;
  int rows = count/cols + 1;
  
  platform->SendToClient("<table>");
  
  int k = 0;
  int p = 0;
  char* fileName;
  for(int i = 0; i < cols; i++)
  {
    platform->SendToClient("<tr>");
    for(int j = 0; j < rows; j++)
    {
      fileName = &list[p];
      while(list[p] != FILE_LIST_SEPARATOR)
        p++;
      list[p++] = 0;
      platform->SendToClient("<td>&nbsp;<button type=\"button\" onclick=\"return ");
      platform->SendToClient(function);
      platform->SendToClient("('");
      platform->SendToClient(prependRoot(platform->getGcodeDir(), fileName));
      platform->SendToClient("')\">");
      platform->SendToClient(fileName);
      platform->SendToClient("</button>&nbsp;</td>");
      k++;
      if(k >= count)
        break;
    }
    platform->SendToClient("</tr>");
    if(k >= count)
        break;
  }
  platform->SendToClient("</table>");
}

void Webserver::callPHPString(char* phpRecord)
{
  if(!strcmp(phpRecord, "getMyName("))
  {
    platform->SendToClient(myName);
    return;
  }
    
  if(!strcmp(phpRecord, "printGCodeTable("))
  {
    printGCodeTable("printFile");
    return;
  }  
 
  if(!strcmp(phpRecord, "deleteGCodeTable("))
  {
    printGCodeTable("deleteFile");
    return;
  } 
    
  if(!strcmp(phpRecord, "logout("))
  {
    gotPassword = false;
    platform->SendToClient("<meta http-equiv=\"REFRESH\" content=\"0;url=passwd.php\"></HEAD>");
    return;
  }
    
  platform->Message(HOST_MESSAGE, "callPHPString(): non-existent function - ");
  platform->Message(HOST_MESSAGE, phpRecord);
  platform->Message(HOST_MESSAGE, "\n"); 
}

void Webserver::ProcessPHPByte(char b)
{
  if(eatInput)
  {
    if(b == eatInputChar)  
      eatInput = false;
    return;
  }
  
  if(recordInput)
  {
    if(b == eatInputChar)
    {
      recordInput = false;
      phpRecordPointer = 0;
      return;
    }
    
    phpRecord[phpRecordPointer++] = b;
    if(phpRecordPointer >= PHP_TAG_LENGTH)
    {
      platform->Message(HOST_MESSAGE, "ProcessPHPByte: PHP record buffer overflow.\n");
      initialisePHP();
    }
    phpRecord[phpRecordPointer] = 0;
    return;
  }
  
  if(phpEchoing)
  {
     if(b != '\'')
     {
       if(ifwasTrue)
         platform->SendToClient(b);
     } else
     {
       initialisePHP();
       eatInput = true;
       eatInputChar = '>';
     }
     return;
  }
  
  if(phpIfing)
  {
    boolean ifWas = callPHPBoolean(phpRecord);
    initialisePHP();
    ifWasTrue = ifWas;
    inPHPString = 5;
    if(b != ')')
    {
      eatInput = true;
      eatInputChar = ')';
    }
    return;
  }
  
  if(phpPrinting)
  {
    callPHPString(phpRecord);
    initialisePHP();
    eatInput = true;
    eatInputChar = '>';    
    return;
  }  
  
  if(inPHPString >= 5)
  {
  // We are in a PHP expression
  
    if(isspace(b))
      return;    
    phpTag[phpPointer++] = b;
    phpTag[phpPointer] = 0;
    if(phpPointer >= PHP_TAG_LENGTH)
    {
      platform->Message(HOST_MESSAGE, "ProcessPHPByte: PHP buffer overflow: ");
      platform->Message(HOST_MESSAGE, phpTag);
      platform->Message(HOST_MESSAGE, "\n");
      initialisePHP();
      return;
    }
    
    switch(PHPParse(phpTag))
    {
    case PHP_ECHO:
      phpEchoing = true;
      eatInput = true;
      eatInputChar = '\'';
      break;
      
    case PHP_IF:
      phpIfing = true;
      recordInput = true;
      phpRecordPointer = 0;
      phpRecord[phpRecordPointer] = 0;
      eatInputChar = ')';
      break;
    
    case PHP_PRINT:
      phpPrinting = true;
      recordInput = true;
      phpRecordPointer = 0;
      phpRecord[phpRecordPointer] = 0;
      eatInputChar = ')';
      break;     
     
    default:
      break;
    }

    return; 
  }
  
  // We are not in a PHP expression
  
  phpTag[inPHPString] = b;
  
  switch(inPHPString)
  {
  case 0:
    if(b == '<')
    {
      inPHPString = 1;
    } else
    {
      phpTag[1] = 0;
      inPHPString = 0;
      platform->SendToClient(phpTag); 
    }       
    return;
    
  case 1:
    if(b == '?')
    {
      inPHPString = 2;
    } else
    {
      phpTag[2] = 0;
      inPHPString = 0;
      platform->SendToClient(phpTag); 
    }
    return;
    
  case 2:
    if(b == 'p')
    {
      inPHPString = 3;
    } else
    {
      phpTag[3] = 0;
      inPHPString = 0;
      platform->SendToClient(phpTag); 
    }
    return;  
  
  case 3:
    if(b == 'h')
    {
      inPHPString = 4;
    } else
    {
      phpTag[4] = 0;
      inPHPString = 0;
      platform->SendToClient(phpTag); 
    }
    return;

  case 4:
    if(b == 'p')
    {
      inPHPString = 5;
      phpTag[0] = 0;
      phpPointer = 0;
    } else
    {
      phpTag[5] = 0;
      inPHPString = 0;
      platform->SendToClient(phpTag); 
    }
    return;
  
  // Should never get here...
  
  default:
     platform->Message(HOST_MESSAGE, "ProcessPHPByte: PHP tag runout.");
     platform->SendToClient(b);
     initialisePHP();
  }   
}

void Webserver::WritePHPByte()
{
    unsigned char b;
    if(platform->Read(fileBeingSent, b))
      ProcessPHPByte(b);
    else
    {     
      platform->Close(fileBeingSent);
      initialisePHP();    
      CloseClient(); 
    }  
}


/*

Parse a string in clientLine[] from the user's web browser

Simple requests have the form:

GET /page2.htm HTTP/1.1
     ^  Start clientRequest[] at clientLine[5]; stop at the blank or...

...fancier ones with arguments after a '?' go:

GET /gather.asp?pwd=my_pwd HTTP/1.1
     ^ Start clientRequest[]
                ^ Start clientQualifier[]
*/

void Webserver::ParseClientLine()
{ 
  if(!StringStartsWith(clientLine, "GET"))
  {
    if(!StringStartsWith(clientLine, "POST"))
    {
      if(!StringStartsWith(clientLine, "Content-Length:"))
        return;
      else
      {
        if(!postSeen)
          platform->Message(HOST_MESSAGE, "Setting post length without POST request seen.");
        postLength = atol(&clientLine[16]);
        return;
      }
 
    } else
      postSeen = true;
  }
  
    
  Serial.print("HTTP request: ");
  Serial.println(clientLine);
  
  int i = 5;
  int j = 0;
  clientRequest[j] = 0;
  clientQualifier[0] = 0;
  while(clientLine[i] != ' ' && clientLine[i] != '?')
  {
    clientRequest[j] = clientLine[i];
    j++;
    i++;
  }
  clientRequest[j] = 0;
  if(clientLine[i] == '?')
  {
    i++;
    j = 0;
    while(clientLine[i] != ' ')
    {
      clientQualifier[j] = clientLine[i];
      j++;
      i++;      
    }
    clientQualifier[j] = 0;
  }

/*  Serial.print("Request:");
  Serial.println(clientRequest);
  Serial.print("Qualifier:");
  Serial.println(clientQualifier);  
*/  
  if(!clientRequest[0])
    strcpy(clientRequest, "control.php");
}

void Webserver::CheckPassword()
{
  if(!StringEndsWith(clientQualifier, password))
    return;
    
  gotPassword = true;
  strcpy(clientRequest, "control.php");
}
  

void Webserver::ParseQualifier()
{
  if(!clientQualifier[0])
    return;
    
  if(StringStartsWith(clientQualifier, "pwd="))
    CheckPassword();
  if(!gotPassword) //Doan work fur nuffink
    return;
    
  if(StringStartsWith(clientQualifier, "gcode="))
  {
    if(!LoadGcodeBuffer(&clientQualifier[6], true))
      platform->Message(HOST_MESSAGE, "Webserver: buffer not free!");
    //strcpy(clientRequest, "control.php");
  }
  
  if(StringStartsWith(clientQualifier, "upload="))
  {
    Serial.println("Got an upload request.");
  }
  
  
}



void Webserver::spin()
{
    
  if(writing)
  {
    if(inPHPFile)
      WritePHPByte();
    else
      WriteByte();
    return;         
  }
  
  if(platform->ClientStatus() & CONNECTED)
  {
    if (platform->ClientStatus() & AVAILABLE) 
    {
      char c = platform->ClientRead();
      Serial.write(c);      
      if(posting)
      {
        postLength--;
        if(postLength <= 0)
        {
          posting = false;
          postLength = 0;
          SendFile(clientRequest);
        }
        return;
      }

      // if you've gotten to the end of the line (received a newline
      // character) and the line is blank, the http request has ended,
      // so you can send a reply
      if (c == '\n' && clientLineIsBlank) 
      {
        clientLine[clientLinePointer] = 0;
        clientLinePointer = 0;
        ParseQualifier();
        if(postSeen)
        {
          posting = true;
          postSeen = false;
          return;
        }
        SendFile(clientRequest);
        clientRequest[0] = 0;
        return;
      }
      if (c == '\n') 
      {
        clientLine[clientLinePointer] = 0;
        ParseClientLine();
        // you're starting a new line
        clientLineIsBlank = true;
        clientLinePointer = 0;
      } else if (c != '\r') 
      {
        // you've gotten a character on the current line
        clientLineIsBlank = false;
        clientLine[clientLinePointer] = c;
        clientLinePointer++;
      }
    }
    //return;
  }  
   
  if (platform->ClientStatus() & CLIENT) 
  {
    if(needToCloseClient)
    {
      if(platform->time() - clientCloseTime < CLIENT_CLOSE_DELAY)
        return;
      needToCloseClient = false;  
      platform->DisconnectClient();
    }   
  }
}