#ifndef _WSS_UTIL_HPP_
#define _WSS_UTIL_HPP_

#include <map>
#include <string>
#include <vector>

#include <boost/archive/iterators/base64_from_binary.hpp>
#include <boost/archive/iterators/insert_linebreaks.hpp>
#include <boost/archive/iterators/transform_width.hpp>
#include <boost/archive/iterators/ostream_iterator.hpp>
#include <boost/uuid/sha1.hpp>

namespace wss {
namespace util {
const char* WSGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";

typedef boost::archive::iterators::base64_from_binary<boost::archive::iterators::transform_width<const char *, 6, 8>> base64_enc;

void split_string(std::vector<std::string>* container, const char* data, const char* delim, size_t data_length, size_t delim_length) {
    std::string buffer;

    while (*data) {
        if (memcmp(data, delim, delim_length) == 0) {
            if (buffer.empty() == false) {
                container->push_back(buffer);
                buffer.clear();
            }
            size_t temp = delim_length;
            while (temp-- && *data++);
        } else {
            buffer += *data++;
        }
    }

    if (buffer.empty() == false) {
        container->push_back(buffer);
    }
}

void parse_http_request(std::string* head, std::map<std::string,std::string>* args, const char* request, size_t request_len) {
    std::vector<std::string> lines;
    std::vector<std::string> buffer;

    split_string(&lines, request, "\r\n", request_len, 2);

    head->assign(lines[0]);
    lines.erase(lines.begin(), lines.begin()+1);

    for (std::vector<std::string>::iterator itr = lines.begin(); itr != lines.end(); itr++) {
        buffer.clear();
        split_string(&buffer, itr->c_str(), ": ", itr->size(), 2);
        args->insert(std::make_pair(buffer[0],buffer[1]));
    }
}

void sha1_hash(char* hash, const char* data, size_t data_nbytes) {
    boost::uuids::detail::sha1 sha1;

    unsigned int digest[5];

    sha1.process_bytes(data, data_nbytes);
    sha1.get_digest(digest);

    for(int i = 0; i < 5; ++i) {
        const char* tmp = reinterpret_cast<char*>(digest);
        hash[i*4] = tmp[i*4+3];
        hash[i*4+1] = tmp[i*4+2];
        hash[i*4+2] = tmp[i*4+1];
        hash[i*4+3] = tmp[i*4];
    }
}

unsigned int base64_encode(char* dest, const char* src, unsigned int len) {
    char tail[3] = {0,0,0};

    unsigned int one_third_len = len/3;
    unsigned int len_rounded_down = one_third_len*3;
    unsigned int j = len_rounded_down + one_third_len;

    std::copy(base64_enc(src), base64_enc(src + len_rounded_down), dest);

    if (len_rounded_down != len) {
        unsigned int i=0;
        for(; i < len - len_rounded_down; ++i) {
            tail[i] = src[len_rounded_down+i];
        }

        std::copy(base64_enc(tail), base64_enc(tail + 3), dest + j);

        for(i=len + one_third_len + 1; i < j+4; ++i) {
            dest[i] = '=';
        }

        return i;
    }

    return j;
}

std::string encode_key(std::string key) {
    key += WSGUID;

    char hash[20] = {0};
    char base64[128] = {0};

    sha1_hash(hash, key.c_str(), key.size());
    base64_encode(base64, hash, 20);

    return base64;
}
}
}

#endif