path: root/src/Response.cpp

#include "Response.hpp"

Response::json Response::simple_response(std::string const &text, std::string const &session, bool success) {
    std::vector<json> reply_vec;
    reply_vec.emplace_back(create_text(text));

    return create_response(std::move(reply_vec), session, success);
}

Response::json Response::create_annotation(Reply::AnnotationType annotationType, std::string const &extra) {
    json annotation(crow::json::type::Object);
    annotation["type"] = Reply::GetStringAnnotationType(annotationType);
    if (extra.empty()) {
        annotation["extra"] = json(crow::json::type::List);
    } else {
        annotation["extra"] = create_text(extra);
    }
    return annotation;
}

Response::json Response::create_annotation(Reply::AnnotationType annotationType, std::vector<json> &&extra) {
    json annotation(crow::json::type::Object);
    annotation["type"] = Reply::GetStringAnnotationType(annotationType);
    annotation["extra"] = std::move(extra);
    return annotation;
}

Response::json Response::create_text(std::string const &text) {
    std::vector<json> annotations;
    annotations.emplace_back(create_annotation());
    return create_text(text, std::move(annotations));
}

Response::json Response::create_text(std::string const &text, std::vector<json> &&annotations) {
    json reply(crow::json::type::Object);
    reply["text"] = text;
    reply["annotations"] = std::move(annotations);
    return reply;
}

Response::json Response::create_response(std::vector<json> &&reply, std::string const &session, bool success) {
    json response(crow::json::type::Object);
    response["success"] = success;
    response["session"] = session;
    response["reply"] = std::move(reply);
    return response;
}

static std::string const base64_chars =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "abcdefghijklmnopqrstuvwxyz"
        "0123456789+/";

std::string base64_encode(unsigned char const *input, unsigned int const len) {
    std::string ret;
    size_t i = 0;
    unsigned char bytes[3];
    unsigned char sextets[4];

    while (i <= (len - 3)) {
        bytes[0] = *(input++);
        bytes[1] = *(input++);
        bytes[2] = *(input++);

        sextets[0] = (bytes[0] & 0xfc) >> 2;    // Cuts last two bits off of first byte
        sextets[1] = ((bytes[0] & 0x03) << 4) + ((bytes[1] & 0xf0)
                >> 4);   // Takes last two bits from first byte and adds it to first 4 bits of 2nd byte
        sextets[2] = ((bytes[1] & 0x0f) << 2) + ((bytes[2] & 0xc0)
                >> 6);   // Takes last 4 bits of 2nd byte and adds it to first 2 bits of third byte
        sextets[3] = bytes[2] & 0x3f;   // takes last 6 bits of third byte

        for (size_t j = 0; j < 4; ++j) {
            ret += base64_chars[sextets[j]];
        }

        i += 3; // increases to go to third byte
    }

    if (i != len) {
        size_t k = 0;
        size_t j = len - i; // Find index of last byte
        while (k < j) {     // Sets first bytes
            bytes[k] = *(input++);
            ++k;
        }

        while (j < 3) {     // Set last bytes to 0x00
            bytes[j] = '\0';
            ++j;
        }

        sextets[0] = (bytes[0] & 0xfc) >> 2;    // Cuts last two bits off of first byte
        sextets[1] = ((bytes[0] & 0x03) << 4) + ((bytes[1] & 0xf0)
                >> 4);   // Takes last two bits from first byte and adds it to first 4 bits of 2nd byte
        sextets[2] = ((bytes[1] & 0x0f) << 2) + ((bytes[2] & 0xc0)
                >> 6);   // Takes last 4 bits of 2nd byte and adds it to first 2 bits of third byte
        // No last one is needed, because if there were 4, then (i == len) == true

        for (j = 0; j < (len - i) + 1; ++j) {   // Gets sextets that include data
            ret += base64_chars[sextets[j]];    // Appends them to string
        }

        while ((j++) < 4)   // Appends remaining ='s
            ret += '=';

    }

    return ret;
}

std::string base64_encode_file(std::string const &path) {
    std::vector<char> temp;

    std::ifstream infile;
    infile.open(path, std::ios::binary);     // Open file in binary mode
    if (infile.is_open()) {
        while (!infile.eof()) {
            char c = (char) infile.get();
            temp.push_back(c);
        }
        infile.close();
    } else return "File could not be opened";
    std::string ret(temp.begin(), temp.end() - 1);
    ret = base64_encode((unsigned const char *) ret.c_str(), ret.size());

    return ret;
}

Response::json Response::create_attachment(std::string const &file_path) {
    std::string name = file_path;
    if (auto pos = file_path.find_last_of('/'); pos != std::string::npos) {
        name = file_path.substr(pos + 1);
    }
    return create_attachment(file_path, name);
}

Response::json Response::create_attachment(std::string const &file_path, std::string const &file_name) {
    std::string type = "unknown";
    if (auto pos = file_name.find_last_of('.'); pos != std::string::npos) {
        type = file_name.substr(pos + 1);
    }
    return create_attachment(file_path, file_name, type);
}

Response::json
Response::create_attachment(std::string const &file_path, std::string const &file_name, std::string const &file_type) {
    json attachment(crow::json::type::Object);
    attachment["type"] = file_type;
    attachment["name"] = file_name;
    attachment["content"] = base64_encode_file(file_path);
    return attachment;
}