/*
 * File:   DropBoxProvider.cc
 * Author: jgaebler
 *
 * Created on April 26, 2012, 3:27 PM
 */

#include "DropBoxProvider.h"


#include "Dispatcher.h"
#include "common/container/PeerIDList.h"
#include "common/time/GenericTime.h"
#include "mob/sync/cloud/transfer/TransferContainer.h"
#include "mob/sync/cloud/transfer/TransferMessage.h"
#include "mob/sync/cloud/transfer/TransferSerializer.h"
#include "common/util/StringUtil.h"
#include "common/container/StringList.h"
#if OMNETPP
#include "../../opt/json-c-0.10/include/json/json.h"
#include <oauth.h>
#include <curl/curl.h>
#endif

#include "Moversight.h"
#include <ctime>
#include <stdlib.h>

#undef DEBUG
#define DEBUG(msg) if (module.isPrintDebugDIS()) MOV_DEBUG << "DBP@" << dispatcher.getMembershipService().getLocalID()<< " "<<msg<<endl;

namespace ubeeme {
    namespace moversight {

        //Dropbox API and OAuth-Keys
        const std::string DropBoxProvider::APP_KEY = "bv3uv5q2t9qbqse";
        const std::string DropBoxProvider::APP_SECRET = "wbo2ieyzvvejrpz";

        // oauth_token and oauth_token_secret created by the scripted gettoken.py
        const std::string DropBoxProvider::OAUTH_TOKEN_SECRET = "negr39cwhxsuc4z";
        const std::string DropBoxProvider::OAUTH_TOKEN = "jhht95nex1gpapz";

        const std::string DropBoxProvider::META_DATA_FILE_NAME_PREFIX = "globalmetadata";
        const std::string DropBoxProvider::FILE_TYPE = "dat";

        /**
         * @brief Constructor
         * @param dis A reference to the dispatcher
         * @param mov A reference to the moversight module
         */
        DropBoxProvider::DropBoxProvider(Dispatcher & dis, Moversight & mov) : CloudProvider(dis, mov), counter(0) {
        }

        /**
         * @brief Destructor
         */
        DropBoxProvider::~DropBoxProvider() {
        }

        /**
         * @brief Puts the given data into the cloud.
         * @param uploadData The data to upload.
         * @param uPID The id of the uploading peer.
         * @param fileName The name of the file that stores the data.
         */
        void
        DropBoxProvider::upload(ByteArray & uploadData, PeerID uPID, std::string fileName) {
#if OMNETPP
            if (uploadData.size() > 0) {

                //std::cerr<< "upload - file name " << fileName<<endl;
                std::string url = buildUploadUrl(uPID, fileName);

                //@TOOD find a better solution
                const char * postData = reinterpret_cast<const char*> (&uploadData[0]);

                char * reply;
                reply = oauth_post_data(url.c_str(),
                                        postData,
                                        uploadData.size(),
                                        "Content-Type: application/json");

                //@TODO check reply for errors and propaged it
                //std::cout << "reply: " << reply << std::endl;
                if (reply) free(reply);

            }//End if
#endif
        }

        /**
         * @brief Creates the url for the file upload to dropbox
         * @param id The id of the peer which has created the first folder in the dropbox.
         * @param fileName The name of the file to store
         * @return The build url.
         */
        std::string
        DropBoxProvider::buildUploadUrl(PeerID id, std::string fileName) {

            std::string s_time = StringUtil::int2String(std::time(NULL));

            std::string folder = StringUtil::int2String(id);
#if OMNETPP
            char * nonce = oauth_gen_nonce();

            // Building Upload url
            std::string url = "https://api-content.dropbox.com/1/files_put/sandbox/" + folder;
            url += "/" + fileName + "." + FILE_TYPE;

            std::string a(url);

            a += "?oauth_nonce=" + std::string(nonce) + "?overwrite=false";
            a += "&oauth_timestamp=" + s_time + "&oauth_consumer_key=" + APP_KEY;
            a += "&oauth_signature_method=PLAINTEXT&oauth_version=1.0&oauth_token=" + OAUTH_TOKEN;
            a += "&oauth_signature=" + APP_SECRET + "%26" + OAUTH_TOKEN_SECRET; // + "&overwrite=False";

            if (nonce) free(nonce);

            //char* signedUrl = oauth_sign_url2(url.c_str(), //request url
            //                                  NULL, //post arguments
            //                                  OA_HMAC, //oauth method OA_HMAC
            //                                  NULL, //http method (GET or POST), if NULL - auto detection
            //                                  APP_KEY.c_str(), //c_key
            //                                  APP_SECRET.c_str(), //c_secret
            //                                  OAUTH_TOKEN.c_str(), // t_key
            //                                  OAUTH_TOKEN_SECRET.c_str()); //t_secret


            //std::cout << "UPLOAD URL: " << url << std::endl;
            //std::cout << "SIGNED URL: " << signedUrl << std::endl;
            //std::cout << "EXPECTED URL: "<< a <<std::endl;
            //std::string t(signedUrl);
            //free(signedUrl);
            return a;
#else
            return folder;
#endif

        }

        TransferContainerList
        DropBoxProvider::downloadMessagesFromPeer(PeerID id) {

            std::stringstream buf;
            buf << "downloadMessagesFromPeer - peer " << id;
            DEBUG(buf.str().c_str());

            std::string metaDataUrl = buildMetaDataUrl(id);

            TransferContainerList tcl;
#if OMNETPP
            char * metaReply = oauth_http_get(metaDataUrl.c_str(), NULL);

            if (metaReply != NULL) {

                //extract the fileList from the reply
                StringList filePathList;
                StringList fileSizeList;
                const std::string pathKey("path");
                const std::string sizeKey("bytes");

                json_object * jobj = json_tokener_parse(metaReply);
                jsonParse(jobj, false, filePathList, pathKey.c_str());
                jsonParse(jobj, false, fileSizeList, sizeKey.c_str());

                //free the reply
                free(metaReply);

                //check, if the size of both lists equal
                if (filePathList.size() != fileSizeList.size()) {
                    DEBUG("downloadMessagesFromPeer - error: the size of the retrieved path and file size lists are not consistent");
                    filePathList.clear();
                }//End if

                //retrieve the files
                //skip paths, which consists only of the peer folder itself (the first entry)
                //TODO FIX DOWNLOAD LIMIT (TO AVOID LONG DOWNLOADS)
std::cerr<<"DropBoxProvider: limit download to 4 files"<<endl;
                for (size_t i = 1; i < filePathList.size() && i < 5; i++) {

                    DEBUG("retrieve from cloud: " + filePathList.get(i));

                    std::string fileUrl = buildDownloadUrl(filePathList.get(i));
                    struct MemoryStruct ms = performCurlDownload(fileUrl);

                    if (ms.size > 0) {

                        ByteArray loadedFile(ms.memory, ms.memory + ms.size);

                        TransferContainer tc;
                        tc.setPeerID(id);

                        if (TransferSerializer::deserialize(loadedFile, tc)) {
                            tcl.add(tc);
                        }//End if
                        else {
                            DEBUG("downloadMessagesFromPeer - error: de-serialize retrieved data failed.");
                        }//End else

                        //clean up
                        free(ms.memory);

                    }//End if
                    else {
                        DEBUG("downloadMessagesFromPeer - error: download failed.");
                    }//End else

                }//End for
            }//End if metaReply
#endif
            return tcl;

        }

        /**
         * @brief Determine the peers, which have stored messages in the cloud.
         * @return The list of peers that have stored messages in the cloud.
         */
        PeerIDList
        DropBoxProvider::determineStoringPeers() {

            // the dropbox api response with an json array
            // the array is parsed with the json parser
            // create the url for the metadata download
            std::string mdurl = buildMetaDataUrl();

            PeerIDList idList;
#if OMNETPP
            char * reply = oauth_http_get(mdurl.c_str(), NULL);          

            if (reply != NULL) {

                //list of peers which have stored messages in the cloud, filled by the json parser
                StringList peerList;
                std::string pathKey("path");
                json_object * jobj = json_tokener_parse(reply);

                //false
                jsonParse(jobj, true, peerList, pathKey.c_str());

                //have a peer messages stored in the cloud?
                for (size_t i = 0; i < peerList.size(); i++) {

                    //we have at least one peer, which have stored messages in the cloud
                    //load the string of the peer ID
                    std::string client = peerList.get(i);

                    if (client != "") {
                        //convert the ID and store it in the list
                        idList.add(PeerID(atoi(client.c_str())));
                    }//End if
                }//end while

                free(jobj);
                free(reply);

            }//End if
#endif
            return idList;

        }

        /*
         * @brief The json array parser
         * @note See joysofprogramming.com/json-c-libjson-tutorial/ for the
         * source of the original code
         */
        void
        DropBoxProvider::jsonParseArray(json_object *jobj, char *key, bool parse, StringList & list, const char * param /* = "path" */) {
#if OMNETPP
            enum json_type type;

            //Simply get the array
            json_object *jarray = jobj;

            if (key) {
                //Getting the array if it is a key value pair
                jarray = json_object_object_get(jobj, key);
            }

            //Getting the length of the array
            int arraylen = json_object_array_length(jarray);
            int i;
            json_object * jvalue;

            for (i = 0; i < arraylen; i++) {
                //Getting the array element at position i
                jvalue = json_object_array_get_idx(jarray, i);
                type = json_object_get_type(jvalue);
                if (type == json_type_array) {
                    jsonParseArray(jvalue, NULL, false, list, param);
                }
                else {
                    jsonParse(jvalue, parse, list, param);
                }
            }
#endif
        }

        /*
         * @brief The json object parser
         * @note base on joysofprogramming.com/json-c-libjson-tutorial/
         *
         * @param jobj The object to parse
         * @param parse Enable parsing
         * @param param The parameter to parse
         * @param list The list of the resulting tokens, with match to the key
         * "path" within the JSON response
         */
        void
        DropBoxProvider::jsonParse(json_object * jobj, bool /* parse */, StringList & list, const char * param /* = "path" */) {
#if OMNETPP
            enum json_type type;

            //Passing through every array element

            json_object_object_foreach(jobj, key, val) {
                type = json_object_get_type(val);
                switch (type) {
                    case json_type_string:

                        if (strcmp(key, param) == 0) {
                            std::string client = json_object_get_string(val);
                            list.add(client.substr(1));
                        }
                        break;
                    case json_type_array:
                        if (strcmp(key, "contents") == 0) {
                            jsonParseArray(jobj, key, true, list, param);
                        }
                        break;
                    case json_type_int:
                        if (strcmp(key, param) == 0) {
                            int intVal = json_object_get_int(val);
                            list.add(StringUtil::int2String(intVal));
                        }
                    default:
                    {
                        //‘json_type_boolean’
                        //‘json_type_double’
                        //‘json_type_object’
                    }
                }
            }
#endif
        }

        /*
         * @brief Creates the url for requesting the meta data for the path "path"
         * @return The build url.
         */
        std::string
        DropBoxProvider::buildMetaDataUrl() {
            return buildMetaDataUrl(UNDEFINED_PEER_ID);
        }

        /*
         * @brief Creates the url for requesting the meta data for the given peer
         * ID. If the id equals to UNDEFINED_PEER_ID, the path is set to empty;
         * @param id The id of the uploading peer.
         * @return The build url.
         */
        std::string
        DropBoxProvider::buildMetaDataUrl(PeerID id) {

            std::string path;

            if (id != UNDEFINED_PEER_ID) {
                path = path + StringUtil::int2String(id) + "/";
            }

            return buildMetaDataUrl(path);
        }

        /*
         * @brief Creates the url for requesting the meta data for the path.
         * @param path The path to set
         * @return The build url.
         */
        std::string
        DropBoxProvider::buildMetaDataUrl(std::string path) {
#if OMNETPP
            char * nonce = oauth_gen_nonce();

            std::string url = "https://api.dropbox.com/1/metadata/sandbox/" + path + "?oauth_nonce="
                    + std::string(nonce) + "&oauth_timestamp=" + StringUtil::int2String(std::time(NULL)) + "&file_limit=10000&list=true"
                    + "&oauth_consumer_key=" + APP_KEY + "&oauth_signature_method=PLAINTEXT&include_deleted=False&oauth_version=1.0&"
                    + "&oauth_token=" + OAUTH_TOKEN + "&oauth_signature=" + APP_SECRET + "%26" + OAUTH_TOKEN_SECRET;

            free(nonce);

            return url;
#else
            return "https://no.url.com";
#endif
        }

        /**
         * @brief Creates the url for the file download from the dropbox.
         * @param path The path to the file to download.
         * @return The build url.
         */
        std::string
        DropBoxProvider::buildDownloadUrl(std::string path) {

            int random = (rand() % 99999999 + 1) + 10000000;

            std::string url = "https://api-content.dropbox.com/1/files/sandbox/" + path + "?oauth_nonce="
                    + StringUtil::int2String(random) + "&oauth_timestamp=" + StringUtil::int2String(std::time(NULL))
                    + "&oauth_consumer_key=" + APP_KEY + "&oauth_signature_method=PLAINTEXT&oauth_version=1.0&"
                    + "&oauth_token=" + OAUTH_TOKEN + "&oauth_signature=" + APP_SECRET + "%26" + OAUTH_TOKEN_SECRET;

            return url;
        }

        /**
         * @brief Retrieves a curl fetch operation and returns a chunk of memory,
         * which stores the retrieved file.
         * @param url The url of the message to fetch
         * @return The memory struct, which stores the retrieved file content.
         * @note The memory of the MemoryStruct chunk have to be cleaned by the caller
         * @see http://curl.haxx.se/libcurl/c/getinmemory.html
         */
        struct MemoryStruct
        DropBoxProvider::performCurlDownload(std::string url) {

            //init the memory area to store the meta data
            MemoryStruct chunk;
            chunk.memory = (char*) malloc(1);
            chunk.size = 0;
#if OMNETPP
            //build the curl request for the metadata upload
            //and perform the request
            CURL* curl_handle;
            curl_global_init(CURL_GLOBAL_ALL);
            curl_handle = curl_easy_init();
            curl_easy_setopt(curl_handle, CURLOPT_URL, url.c_str());
            curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, writeMemoryCallback);
            curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *) &chunk);
            curl_easy_perform(curl_handle);
            curl_easy_cleanup(curl_handle);
            curl_global_cleanup();
#endif
            return chunk;

        }

        /**
         * @brief Callback for the curl library downloads
         * @param contents The content to store
         * @param size the size of the fetched content
         * @param nmemb the size of the allocated memory
         * @param userp the destination to store
         * @return the value of the allocated memory
         * @see http://curl.haxx.se/libcurl/c/getinmemory.html
         */
        size_t
        DropBoxProvider::writeMemoryCallback(void *contents, size_t size, size_t nmemb, void *userp) {

            size_t realsize = size * nmemb;
            MemoryStruct *mem = (MemoryStruct *) userp;

            mem->memory = (char*) realloc(mem->memory, mem->size + realsize + 1);
            if (mem->memory == NULL) {
                // out of memory!
                std::cerr << "not enough memory (realloc returned NULL)" << std::endl;
                exit(EXIT_FAILURE);
            }

            memcpy(&(mem->memory[mem->size]), contents, realsize);
            mem->size += realsize;
            mem->memory[mem->size] = 0;

            return realsize;
        }
    }
}