/*
* Copyright (c) 2013-2017, The PurpleI2P Project
*
* This file is part of Purple i2pd project and licensed under BSD3
*
* See full license text in LICENSE file at top of project tree
*/

#include <algorithm>
#include <utility>
#include "util.h"
#include "HTTP.h"
#include <ctime>

namespace i2p {
namespace http {
  const std::vector<std::string> HTTP_METHODS = {
    "GET", "HEAD", "POST", "PUT", "PATCH",
    "DELETE", "OPTIONS", "CONNECT"
  };
  const std::vector<std::string> HTTP_VERSIONS = {
    "HTTP/1.0", "HTTP/1.1"
  };

  inline bool is_http_version(const std::string & str) {
    return std::find(HTTP_VERSIONS.begin(), HTTP_VERSIONS.end(), str) != std::end(HTTP_VERSIONS);
  }

  inline bool is_http_method(const std::string & str) {
    return std::find(HTTP_METHODS.begin(), HTTP_METHODS.end(), str) != std::end(HTTP_METHODS);
  }

  void strsplit(const std::string & line, std::vector<std::string> &tokens, char delim, std::size_t limit = 0) {
    std::size_t count = 0;
    std::stringstream ss(line);
    std::string token;
    while (1) {
      count++;
      if (limit > 0 && count >= limit)
        delim = '\n'; /* reset delimiter */
      if (!std::getline(ss, token, delim))
        break;
      tokens.push_back(token);
    }
  }

  static std::pair<std::string, std::string> parse_header_line(const std::string& line) 
  {
    std::size_t pos = 0;
    std::size_t len = 2; /* strlen(": ") */
    std::size_t max = line.length();
    if ((pos = line.find(": ", pos)) == std::string::npos)
      return std::make_pair("", "");
    while ((pos + len) < max && isspace(line.at(pos + len)))
      len++;
    return std::make_pair(line.substr(0, pos), line.substr(pos + len));
  }

  void gen_rfc1123_date(std::string & out) {
    std::time_t now = std::time(nullptr);
    char buf[128];
    std::strftime(buf, sizeof(buf), "%a, %d %b %Y %H:%M:%S GMT", std::gmtime(&now));
    out = buf;
  }

  bool URL::parse(const char *str, std::size_t len) {
    std::string url(str, len ? len : strlen(str));
    return parse(url);
  }

  bool URL::parse(const std::string& url) {
    std::size_t pos_p = 0; /* < current parse position */
    std::size_t pos_c = 0; /* < work position */
    if(url.at(0) != '/' || pos_p > 0) {
      std::size_t pos_s = 0;
      /* schema */
      pos_c = url.find("://");
      if (pos_c != std::string::npos) {
        schema = url.substr(0, pos_c);
        pos_p = pos_c + 3;
      }
      /* user[:pass] */
      pos_s = url.find('/', pos_p); /* find first slash */
      pos_c = url.find('@', pos_p); /* find end of 'user' or 'user:pass' part */
      if (pos_c != std::string::npos && (pos_s == std::string::npos || pos_s > pos_c)) {
        std::size_t delim = url.find(':', pos_p);
        if (delim != std::string::npos && delim < pos_c) {
          user = url.substr(pos_p, delim - pos_p);
          delim += 1;
          pass = url.substr(delim, pos_c - delim);
        } else {
          user = url.substr(pos_p, pos_c - pos_p);
        }
        pos_p = pos_c + 1;
      }
      /* hostname[:port][/path] */
      pos_c = url.find_first_of(":/", pos_p);
      if (pos_c == std::string::npos) {
        /* only hostname, without post and path */
        host = url.substr(pos_p, std::string::npos);
        return true;
      } else if (url.at(pos_c) == ':') {
        host = url.substr(pos_p, pos_c - pos_p);
        /* port[/path] */
        pos_p = pos_c + 1;
        pos_c = url.find('/', pos_p);
        std::string port_str = (pos_c == std::string::npos)
          ? url.substr(pos_p, std::string::npos)
          : url.substr(pos_p, pos_c - pos_p);
        /* stoi throws exception on failure, we don't need it */
        for (char c : port_str) {
          if (c < '0' || c > '9')
            return false;
          port *= 10;
          port += c - '0';
        }
        if (pos_c == std::string::npos)
          return true; /* no path part */
        pos_p = pos_c;
      } else {
        /* start of path part found */
        host = url.substr(pos_p, pos_c - pos_p);
        pos_p = pos_c;
      }
    }

    /* pos_p now at start of path part */
    pos_c = url.find_first_of("?#", pos_p);
    if (pos_c == std::string::npos) {
      /* only path, without fragment and query */
      path = url.substr(pos_p, std::string::npos);
      return true;
    } else if (url.at(pos_c) == '?') {
      /* found query part */
      path = url.substr(pos_p, pos_c - pos_p);
      pos_p = pos_c + 1;
      pos_c = url.find('#', pos_p);
      if (pos_c == std::string::npos) {
        /* no fragment */
        query = url.substr(pos_p, std::string::npos);
        return true;
      } else {
        query = url.substr(pos_p, pos_c - pos_p);
        pos_p = pos_c + 1;
      }
    } else {
      /* found fragment part */
      path = url.substr(pos_p, pos_c - pos_p);
      pos_p = pos_c + 1;
    }

    /* pos_p now at start of fragment part */
    frag = url.substr(pos_p, std::string::npos);
    return true;
  }

  bool URL::parse_query(std::map<std::string, std::string> & params) {
    std::vector<std::string> tokens;
    strsplit(query, tokens, '&');

    params.clear();
    for (const auto& it : tokens) {
      std::size_t eq = it.find ('=');
      if (eq != std::string::npos) {
        auto e = std::pair<std::string, std::string>(it.substr(0, eq), it.substr(eq + 1));
        params.insert(e);
      } else {
        auto e = std::pair<std::string, std::string>(it, "");
        params.insert(e);
      }
    }
    return true;
  }

  std::string URL::to_string() {
    std::string out = "";
    if (schema != "") {
      out = schema + "://";
      if (user != "" && pass != "") {
        out += user + ":" + pass + "@";
      } else if (user != "") {
        out += user + "@";
      }
      if (port) {
        out += host + ":" + std::to_string(port);
      } else {
        out += host;
      }
    }
    out += path;
    if (query != "")
      out += "?" + query;
    if (frag != "")
      out += "#" + frag;
    return out;
  }

	bool URL::is_i2p() const
	{
		return host.rfind(".i2p") == ( host.size() - 4 );
	}

  void HTTPMsg::add_header(const char *name, std::string & value, bool replace) {
    add_header(name, value.c_str(), replace);
  }

  void HTTPMsg::add_header(const char *name, const char *value, bool replace) {
    std::size_t count = headers.count(name);
    if (count && !replace)
      return;
    if (count) {
      headers[name] = value;
      return;
    }
    headers.insert(std::pair<std::string, std::string>(name, value));
  }

  void HTTPMsg::del_header(const char *name) {
    headers.erase(name);
  }

  int HTTPReq::parse(const char *buf, size_t len) {
    std::string str(buf, len);
    return parse(str);
  }

  int HTTPReq::parse(const std::string& str) {
    enum { REQ_LINE, HEADER_LINE } expect = REQ_LINE;
    std::size_t eoh = str.find(HTTP_EOH); /* request head size */
    std::size_t eol = 0, pos = 0;
    URL url;

    if (eoh == std::string::npos)
      return 0; /* str not contains complete request */

    while ((eol = str.find(CRLF, pos)) != std::string::npos) {
      if (expect == REQ_LINE) {
        std::string line = str.substr(pos, eol - pos);
        std::vector<std::string> tokens;
        strsplit(line, tokens, ' ');
        if (tokens.size() != 3)
          return -1;
        if (!is_http_method(tokens[0]))
          return -1;
        if (!is_http_version(tokens[2]))
          return -1;
        if (!url.parse(tokens[1]))
          return -1;
        /* all ok */
        method  = tokens[0];
        uri     = tokens[1];
        version = tokens[2];
        expect = HEADER_LINE;
      } 
	  else 
	  {
        std::string line = str.substr(pos, eol - pos);
        auto p = parse_header_line(line);
		if (p.first.length () > 0)
			headers.push_back (p);
		else  
            return -1;
      }
      pos = eol + strlen(CRLF);
      if (pos >= eoh)
        break;
    }
    return eoh + strlen(HTTP_EOH);
  }

  void HTTPReq::write(std::ostream & o) 
  {
	  o << method << " " << uri << " " << version << CRLF;
	  for (auto & h : headers) 
  		o << h.first << ": " << h.second << CRLF;
	  o << CRLF;
  }

	std::string HTTPReq::to_string()
	{
		std::stringstream ss;
		write(ss);
		return ss.str();
	}

	void HTTPReq::AddHeader (const std::string& name, const std::string& value)
	{	
		headers.push_back (std::make_pair(name, value));
	}

	void HTTPReq::UpdateHeader (const std::string& name, const std::string& value)
	{
		 for (auto& it : headers)
			if (it.first == name)
			{
				it.second = value;
				break;
			}	
	}	
	
	void HTTPReq::RemoveHeader (const std::string& name, const std::string& exempt)
	{
		for (auto it = headers.begin (); it != headers.end ();)
		{
			if (!it->first.compare(0, name.length (), name) && it->first != exempt)	
				it = headers.erase (it);
			else
				it++;
		}	
	}	

	std::string HTTPReq::GetHeader (const std::string& name) const 
	{
		 for (auto& it : headers)
			if (it.first == name)
				return it.second;	
		return "";
	}	
	
  bool HTTPRes::is_chunked() const
 {
    auto it = headers.find("Transfer-Encoding");
    if (it == headers.end())
      return false;
    if (it->second.find("chunked") == std::string::npos)
      return true;
    return false;
  }

  bool HTTPRes::is_gzipped(bool includingI2PGzip) const
  {
    auto it = headers.find("Content-Encoding");
    if (it == headers.end())
      return false; /* no header */
    if (it->second.find("gzip") != std::string::npos)
      return true; /* gotcha! */
	if (includingI2PGzip &&  it->second.find("x-i2p-gzip") != std::string::npos)
	  return true;	  
    return false;
  }
	
  long int HTTPMsg::content_length() const
  {
    unsigned long int length = 0;
    auto it = headers.find("Content-Length");
    if (it == headers.end())
      return -1;
    errno = 0;
    length = std::strtoul(it->second.c_str(), (char **) NULL, 10);
    if (errno != 0)
      return -1;
    return length;
  }

  int HTTPRes::parse(const char *buf, size_t len) {
    std::string str(buf, len);
    return parse(str);
  }

  int HTTPRes::parse(const std::string& str) {
    enum { RES_LINE, HEADER_LINE } expect = RES_LINE;
    std::size_t eoh = str.find(HTTP_EOH); /* request head size */
    std::size_t eol = 0, pos = 0;

    if (eoh == std::string::npos)
      return 0; /* str not contains complete request */

    while ((eol = str.find(CRLF, pos)) != std::string::npos) {
      if (expect == RES_LINE) {
        std::string line = str.substr(pos, eol - pos);
        std::vector<std::string> tokens;
        strsplit(line, tokens, ' ', 3);
        if (tokens.size() != 3)
          return -1;
        if (!is_http_version(tokens[0]))
          return -1;
        code = atoi(tokens[1].c_str());
        if (code < 100 || code >= 600)
          return -1;
        /* all ok */
        version = tokens[0];
        status  = tokens[2];
        expect = HEADER_LINE;
      } else {
        std::string line = str.substr(pos, eol - pos);
        auto p = parse_header_line(line);
		if (p.first.length () > 0)
			headers.insert (p);  
		else	  
          return -1;
      }
      pos = eol + strlen(CRLF);
      if (pos >= eoh)
        break;
    }

    return eoh + strlen(HTTP_EOH);
  }

  std::string HTTPRes::to_string() {
    if (version == "HTTP/1.1" && headers.count("Date") == 0) {
      std::string date;
      gen_rfc1123_date(date);
      add_header("Date", date.c_str());
    }
    if (status == "OK" && code != 200)
      status = HTTPCodeToStatus(code); // update
    if (body.length() > 0 && headers.count("Content-Length") == 0)
        add_header("Content-Length", std::to_string(body.length()).c_str());
    /* build response */
    std::stringstream ss;
    ss << version << " " << code << " " << status << CRLF;
    for (auto & h : headers) {
      ss << h.first << ": " << h.second << CRLF;
    }
    ss << CRLF;
    if (body.length() > 0)
      ss << body;
    return ss.str();
  }

  const char * HTTPCodeToStatus(int code) {
    const char *ptr;
    switch (code) {
      case 105: ptr = "Name Not Resolved"; break;
      /* success */
      case 200: ptr = "OK"; break;
      case 206: ptr = "Partial Content"; break;
      /* redirect */
      case 301: ptr = "Moved Permanently"; break;
      case 302: ptr = "Found"; break;
      case 304: ptr = "Not Modified"; break;
      case 307: ptr = "Temporary Redirect"; break;
      /* client error */
      case 400: ptr = "Bad Request";  break;
      case 401: ptr = "Unauthorized"; break;
      case 403: ptr = "Forbidden"; break;
      case 404: ptr = "Not Found"; break;
      case 407: ptr = "Proxy Authentication Required"; break;
      case 408: ptr = "Request Timeout"; break;
      /* server error */
      case 500: ptr = "Internal Server Error"; break;
      case 502: ptr = "Bad Gateway"; break;
      case 503: ptr = "Not Implemented"; break;
      case 504: ptr = "Gateway Timeout"; break;
      default:  ptr = "Unknown Status";  break;
    }
    return ptr;
  }

  std::string UrlDecode(const std::string& data, bool allow_null) {
		std::string decoded(data);
    size_t pos = 0;
    while ((pos = decoded.find('%', pos)) != std::string::npos) {
      char c = strtol(decoded.substr(pos + 1, 2).c_str(), NULL, 16);
      if (c == '\0' && !allow_null) {
        pos += 3;
        continue;
      }
      decoded.replace(pos, 3, 1, c);
      pos++;
    }
    return decoded;
  }

  bool MergeChunkedResponse (std::istream& in, std::ostream& out) {
    std::string hexLen;
    while (!in.eof ()) {
      std::getline (in, hexLen);
      errno = 0;
      long int len = strtoul(hexLen.c_str(), (char **) NULL, 16);
      if (errno != 0)
        return false; /* conversion error */
      if (len == 0)
        return true; /* end of stream */
      if (len < 0 || len > 10 * 1024 * 1024) /* < 10Mb */
        return false; /* too large chunk */
      char * buf = new char[len];
      in.read (buf, len);
      out.write (buf, len);
      delete[] buf;
      std::getline (in, hexLen); // read \r\n after chunk
    }
    return true;
  }
} // http
} // i2p
