/*

 * Copyright (C) 2012 Emweb bv, Herent, Belgium.

 *

 * See the LICENSE file for terms of use.

 */

#include <vector>

#include <iterator>

#include <string.h>

#include "Wt/WConfig.h" // WT_WIN32

// for htonl():

#ifndef WT_WIN32

#include <arpa/inet.h>

#else

#include <winsock2.h>

#endif

#include "Wt/WLogger.h"

#include "Wt/Utils.h"

#include "DomElement.h"

#include "md5.h"

#include "base32.h"

#include "base64.h"

#include "ImageUtils.h"

#include "StringUtils.h"

#include <cstring>

extern "C" {

  #include "sha1.h"

}

namespace Wt {

LOGGER("Utils");

  namespace Utils {

    namespace {

unsigned char fromHex(char b)

{

  if (b <= '9')

    return b - '0';

  else if (b <= 'F')

    return (b - 'A') + 0x0A;

  else

    return (b - 'a') + 0x0A;

}

unsigned char fromHex(char msb, char lsb)

{

  return (fromHex(msb) << 4) + fromHex(lsb);

}

char toHex(unsigned char b)

{

  if (b < 0xA)

    return '0' + b;

  else

    return 'a' + (b - 0xA);

}

void toHex(unsigned char b, char& msb, char& lsb)

{

  lsb = toHex(b & 0x0F);

  msb = toHex(b >> 4);

}

    }

std::string md5(const std::string& text)

{

  md5_state_t c;

  wt_md5_init(&c);

  wt_md5_append(&c, (const md5_byte_t *)text.c_str(), text.length());

  unsigned char buf[16];

  wt_md5_finish(&c, buf);

  return std::string((const char *)buf, 16);

}

std::string sha1(const std::string& text)

{

  SHA1Context sha;

  wt_SHA1Reset(&sha);

  wt_SHA1Input(&sha, (unsigned char *)text.c_str(), text.length());

  if (!wt_SHA1Result(&sha)) {

    LOG_ERROR("Error computing sha1 hash");

    return std::string();

  } else {

    const unsigned SHA1_LENGTH = 20;

    unsigned char hash[SHA1_LENGTH];

    for (unsigned i = 0; i < 5; ++i) {

      unsigned v = htonl(sha.Message_Digest[i]);

      memcpy(hash + (i*4), &v, 4);

    }

    return std::string(hash, hash + SHA1_LENGTH);

  }

}

std::string base32Encode(const std::string& data, bool crlf)

{

  std::vector<char> v;

  // base32 encoded value will be 8/5 larger than original value

  v.reserve(static_cast<std::size_t>(data.size() * 1.6));

  base32::encode(data.begin(), data.end(), std::back_inserter(v), crlf);

  return std::string(v.begin(), v.end());

}

std::string base32Decode(const std::string& data)

{

  std::vector<char> v;

  // decoded value will be 5/8 smaller than encoded value

  v.reserve((std::size_t)(data.size() * 0.625));

  base32::decode(data.begin(), data.end(), std::back_inserter(v));

  return std::string(v.begin(), v.end());

}

std::string base64Encode(const std::string& data, bool crlf)

{

  std::vector<char> v;

  // base64 encoded value will be 4/3 larger than original value

  v.reserve((std::size_t)(data.size() * 1.35));

  base64::encode(data.begin(), data.end(), std::back_inserter(v), crlf);

  return std::string(v.begin(), v.end());

}

std::string base64Decode(const std::string& data)

{

  std::vector<char> v;

  // decoded value will be 3/4 smaller than encoded value

  v.reserve((std::size_t)(data.size() * 0.8));

  base64::decode(data.begin(), data.end(), std::back_inserter(v));

  return std::string(v.begin(), v.end());

}

std::string hexEncode(const std::string& data)

{

  std::string result(data.length() * 2, '-');

  for (unsigned i = 0; i < data.length(); ++i)

    toHex(data[i], result[2 * i], result[2 * i + 1]);

  return result;

}

std::string hexDecode(const std::string& data)

{

  std::string result(data.length() / 2, '-');

  for (unsigned i = 0; i < result.length(); ++i)

    result[i] = fromHex(data[2 * i], data[2 * i + 1]);

  return result;

}

std::string htmlEncode(const std::string& text, WFlags<HtmlEncodingFlag> flags)

{

  std::string result = text;

  WWebWidget::escapeText(result,

                         (flags.test(HtmlEncodingFlag::EncodeNewLines)) ?

                         true : false);

  return result;

}

WString htmlEncode(const WString& text, WFlags<HtmlEncodingFlag> flags)

{

  return WString::fromUTF8(htmlEncode(text.toUTF8(), flags));

}

std::string htmlAttributeValue(const std::string& text)

{

  Wt::WStringStream ss;

  DomElement::htmlAttributeValue(ss, text);

  return ss.str();

}

std::string urlEncode(const std::string& text)

{

  return DomElement::urlEncodeS(text);

}

std::string urlDecode(const std::string &text)

{

  WStringStream result;

  for (unsigned i = 0; i < text.length(); ++i) {

    char c = text[i];

    if (c == '+') {

      result << ' ';

    } else if (c == '%' && i + 2 < text.length()) {

      std::string h = text.substr(i + 1, 2);

      char *e = nullptr;

      int hval = std::strtol(h.c_str(), &e, 16);

      if (*e == 0) {

        result << (char)hval;

        i += 2;

      } else

        // not a proper %XX with XX hexadecimal format

        result << c;

    } else

      result << c;

  }

  return result.str();

}

bool removeScript(WString& text)

{

  return WWebWidget::removeScript(text);

}

std::string guessImageMimeTypeData(const std::vector<unsigned char>& header)

{

  return Wt::ImageUtils::identifyMimeType(header);

}

std::string guessImageMimeType(const std::string& file)

{

  return Wt::ImageUtils::identifyMimeType(file);

}

std::string createDataUrl(std::vector<unsigned char>& data, std::string mimeType){

  std::string url = "data:"+mimeType+";"+"base64,";

  std::string datab64 = base64Encode(std::string(data.begin(), data.end()));

  return url+datab64;

}

std::string hmac(const std::string& text,

                 const std::string& key,

                 std::string (*hashfunction)(const std::string&),

                 size_t blocksize,

                 size_t keysize)

{

  unsigned char ipad[256];

  unsigned char opad[256];

  std::memset(ipad, 0, sizeof(unsigned char) * blocksize);

  if (key.size() > blocksize) {

    std::memcpy(ipad, (unsigned char*) hashfunction(key).c_str(), keysize);

  }

  else {

    keysize = key.size();

    std::memcpy(ipad, (unsigned char*) key.c_str(), keysize);

  }

  std::memcpy(opad, ipad, blocksize);

  for (size_t i=0; i<blocksize; ++i) {

    ipad[i] ^= 0x36;

    opad[i] ^= 0x5c;

  }

  return hashfunction(std::string((char*) opad,blocksize)

       + hashfunction(std::string((char*) ipad,blocksize) + text));

}

std::string hmac_md5(const std::string& text, const std::string& key)

{

  return hmac(text,

              key,

              &md5,

              64,

              16);

}

std::string hmac_sha1(const std::string& text, const std::string& key)

{

  return hmac(text,

              key,

              &sha1,

              64,

              20);

}

std::vector<std::string> getWidgetStyleClasses(WWidget* widget)

{

  std::string styleClass = widget->styleClass().toUTF8();

  std::vector<std::string> styleClassVec;

  SplitSet styleClassSet;

  split(styleClassSet, styleClass, " ", false);

  for (const auto& entry : styleClassSet) {

    styleClassVec.push_back(splitEntryToString(entry));

  }

  return styleClassVec;

}

}

}