#include "HTTPResponse.hpp"

#include <Arduino.h>
#include "lwip/sockets.h"

namespace httpsserver {

HTTPResponse::HTTPResponse(ConnectionContext * con):
  _con(con) {

  // Default status code is 200 OK
  _statusCode = 200;
  _statusText = "OK";
  _headerWritten = false;
  _isError = false;

  _responseCacheSize = con->getCacheSize();
  _responseCachePointer = 0;
  if (_responseCacheSize > 0) {
    HTTPS_LOGD("Creating buffered response, size: %d", _responseCacheSize);
    _responseCache = new byte[_responseCacheSize];
  } else {
    HTTPS_LOGD("Creating non-buffered response");
    _responseCache = NULL;
  }
}

HTTPResponse::~HTTPResponse() {
  if (_responseCache != NULL) {
    delete[] _responseCache;
  }
  _headers.clearAll();
}

void HTTPResponse::setStatusCode(uint16_t statusCode) {
  _statusCode = statusCode;
}

void HTTPResponse::setStatusText(std::string const &statusText) {
  _statusText = statusText;
}

uint16_t HTTPResponse::getStatusCode() {
  return _statusCode;
}

std::string HTTPResponse::getStatusText() {
  return _statusText;
}

void HTTPResponse::setHeader(std::string const &name, std::string const &value) {
  _headers.set(new HTTPHeader(name, value));
}

std::string HTTPResponse::getHeader(std::string const &name) {
  HTTPHeader * h = _headers.get(name);
  if (h != NULL) {
    return h->_value;
  } else {
    return std::string();
  }
}

bool HTTPResponse::isHeaderWritten() {
  return _headerWritten;
}

bool HTTPResponse::isResponseBuffered() {
  return _responseCache != NULL;
}

void HTTPResponse::finalize() {
  if (isResponseBuffered()) {
    drainBuffer();
  }
}

/**
 * Writes a string to the response. May be called several times.
 */
void HTTPResponse::printStd(const std::string &str) {
  write((uint8_t*)str.c_str(), str.length());
}

/**
 * Writes bytes to the response. May be called several times.
 */
size_t  HTTPResponse::write(const uint8_t *buffer, size_t size) {
  if(!isResponseBuffered()) {
    printHeader();
  }
  return writeBytesInternal(buffer, size);
}

/**
 * Writes a single byte to the response.
 */
size_t  HTTPResponse::write(uint8_t b) {
  if(!isResponseBuffered()) {
    printHeader();
  }
  byte ba[] = {b};
  return writeBytesInternal(ba, 1);
}

/**
 *  If not already done, writes the header.
 */
void HTTPResponse::printHeader() {
  if (!_headerWritten) {
    HTTPS_LOGD("Printing headers");

    // Status line, like: "HTTP/1.1 200 OK\r\n"
    std::string statusLine = "HTTP/1.1 " + intToString(_statusCode) + " " + _statusText + "\r\n";
    printInternal(statusLine, true);

    // Each header, like: "Host: myEsp32\r\n"
    std::vector<HTTPHeader *> * headers = _headers.getAll();
    for(std::vector<HTTPHeader*>::iterator header = headers->begin(); header != headers->end(); ++header) {
      printInternal((*header)->print()+"\r\n", true);
    }
    printInternal("\r\n", true);

    _headerWritten=true;
  }
}

/**
 * This method can be called to cancel the ongoing transmission and send the error page (if possible)
 */
void HTTPResponse::error() {
  _con->signalRequestError();
}

void HTTPResponse::printInternal(const std::string &str, bool skipBuffer) {
  writeBytesInternal((uint8_t*)str.c_str(), str.length(), skipBuffer);
}

size_t HTTPResponse::writeBytesInternal(const void * data, int length, bool skipBuffer) {
  if (!_isError) {
    if (isResponseBuffered() && !skipBuffer) {
      // We are buffering ...
      if(length <= _responseCacheSize - _responseCachePointer) {
        // ... and there is space left in the buffer -> Write to buffer
        size_t end = _responseCachePointer + length;
        size_t i = 0;
        while(_responseCachePointer < end) {
          _responseCache[_responseCachePointer++] = ((byte*)data)[i++];
        }
        // Returning skips the SSL_write below
        return length;
      } else {
        // .., and the buffer is too small. This is the point where we switch from
        // caching to streaming
        if (!_headerWritten) {
          setHeader("Connection", "close");
        }
        drainBuffer(true);
      }
    }

    return _con->writeBuffer((byte*)data, length);
  } else {
    return 0;
  }
}

void HTTPResponse::drainBuffer(bool onOverflow) {
  if (!_headerWritten) {
    if (_responseCache != NULL && !onOverflow) {
      _headers.set(new HTTPHeader("Content-Length", intToString(_responseCachePointer)));
    }
    printHeader();
  }

  if (_responseCache != NULL) {
    HTTPS_LOGD("Draining response buffer");
    // Check for 0 as it may be an overflow reaction without any data that has been written earlier
    if(_responseCachePointer > 0) {
      // FIXME: Return value?
      _con->writeBuffer((byte*)_responseCache, _responseCachePointer);
    }
    delete[] _responseCache;
    _responseCache = NULL;
  }
}

} /* namespace httpsserver */