#include "include/HttpClient.h"
#include <sys/stat.h>

HttpClient *HttpClient::instance = NULL;

double HttpClient::downloadFileLength = -1;
curl_off_t HttpClient::resumeByte = -1;
time_t HttpClient::lastTime = 0;

bool HttpClient::stopCurl = false;

HttpClient::HttpClient()
{
}


HttpClient::~HttpClient()
{
}

HttpClient *HttpClient::getInstance()
{
    if (instance == NULL)
	{
		instance = new HttpClient();
		instance->init();
	}

	return instance;
}

void HttpClient::destroyInstance()
{
    if (instance != NULL)
	{
        stopCurl = true;

        // curl_global_cleanup()    will crash on Qt windows

        delete instance;
        instance = NULL;
	}
}

bool HttpClient::init()
{
    if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK)
        return false;

    return true;
}

void HttpClient::zlog(const char *date, const char *time, const char *file, const int line, const char *func, const char *str)
{
#ifdef Z_DEBUG
	FILE *fp = NULL;
#ifdef _WIN32
	fopen_s(&fp, "log.log", "a+");
#else
	fopen("log.log", "a+");
#endif
    fprintf(fp, "%s | %s | %s | %d | %s | %s\n", date, time, file, line, func, str);
	fclose(fp);
#else
	(void)str;
#endif	// end Z_DEBUG
}

// Return 0 if success, otherwise return error code
int HttpClient::HttpGet(const string requestURL, const string saveTo, void *sender, progress_info_callback cb)
{
    string partPath = saveTo + ".part";

    CURL *easy_handle = NULL;
    FILE *fp = NULL;

    int ret = HTTP_REQUEST_ERROR;

    do
    {
        // Get the file size on the server
        downloadFileLength = getDownloadFileLength(requestURL);

        if (downloadFileLength < 0)
        {
            ZLOG("getDownloadFileLength error");
            break;
        }

        easy_handle = curl_easy_init();
        if (!easy_handle)
        {
            ZLOG("curl_easy_init error");
            break;
        }

#ifdef _WIN32
        fopen_s(&fp, partPath.c_str(), "ab+");
#else
		fp = fopen(partPath.c_str(), "ab+");
#endif
        if (fp == NULL)
        {
            ZLOG("file open failed");
            ZLOG(partPath.c_str());
            break;
        }

        // Set the url
        ret = curl_easy_setopt(easy_handle, CURLOPT_URL, requestURL.c_str());

        // Save data from the server
        ret |= curl_easy_setopt(easy_handle, CURLOPT_WRITEFUNCTION, &HttpClient::write_callback);
        ret |= curl_easy_setopt(easy_handle, CURLOPT_WRITEDATA, fp);

		Progress_User_Data data = { sender, easy_handle, cb };

        // Get the download progress
        ret |= curl_easy_setopt(easy_handle, CURLOPT_NOPROGRESS, 0L);
        ret |= curl_easy_setopt(easy_handle, CURLOPT_XFERINFOFUNCTION, &HttpClient::progress_callback);
        ret |= curl_easy_setopt(easy_handle, CURLOPT_XFERINFODATA, &data);

        // Fail the request if the HTTP code returned is equal to or larger than 400
        ret |= curl_easy_setopt(easy_handle, CURLOPT_FAILONERROR, 1L);

        // The maximum time that allow the connection parse to the server
        ret |= curl_easy_setopt(easy_handle, CURLOPT_CONNECTTIMEOUT, 10L);

		resumeByte = getLocalFileLength(partPath);
        if (resumeByte > 0)
        {
            // Set a point to resume transfer
            ret |= curl_easy_setopt(easy_handle, CURLOPT_RESUME_FROM_LARGE, resumeByte);
        }

        if (ret != CURLE_OK)
        {
			ret = HTTP_REQUEST_ERROR;
            ZLOG("curl_easy_setopt error");
            break;
        }

        ret = curl_easy_perform(easy_handle);

        if (ret != CURLE_OK)
        {
			char s[100] = { 0 };
#ifdef _WIN32
			sprintf_s(s, sizeof(s), "error:%d:%s", ret, curl_easy_strerror(static_cast<CURLcode>(ret)));
#else
			sprintf(s, "error:%d:%s", ret, curl_easy_strerror(static_cast<CURLcode>(ret)));
#endif

            ZLOG(s);
            switch (ret)
            {
                case CURLE_HTTP_RETURNED_ERROR:
                {
                    int code = 0;
                    curl_easy_getinfo(easy_handle, CURLINFO_RESPONSE_CODE, &code);

					char s[100] = { 0 };
#ifdef _WIN32
					sprintf_s(s, sizeof(s), "HTTP error code:%d", code);
#else
					sprintf(s, "HTTP error code:%d", code);
#endif
                    ZLOG(s);
                    break;
                }
            }
        }
    } while (0);

	if (fp != NULL)
	{
		fclose(fp);
		fp = NULL;
	}

    curl_easy_cleanup(easy_handle);
    easy_handle = NULL;

    if (ret == CURLE_OK)
    {
        remove(saveTo.c_str());
		rename(partPath.c_str(), saveTo.c_str());
    }

    return ret;
}

size_t HttpClient::write_callback(char *buffer, size_t size, size_t nmemb, void *userdata)
{
	FILE *fp = static_cast<FILE *>(userdata);
	size_t length = fwrite(buffer, size, nmemb, fp);
	if (length != nmemb)
	{
		return length;
	}

	return size * nmemb;
}

int HttpClient::progress_callback(void *userdata, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow)
{
    (void)ultotal;
    (void)ulnow;

    if(stopCurl)
        return 1;

    time_t now = time(NULL);
	if (now - lastTime < 1)
	{
		return 0;
	}
	lastTime = now;

    Progress_User_Data *data = static_cast<Progress_User_Data *>(userdata);
	CURL *easy_handle = data->handle;

	// Defaults to bytes/second
	double speed = 0;
	curl_easy_getinfo(easy_handle, CURLINFO_SPEED_DOWNLOAD, &speed);

	// Time remaining
	double leftTime = 0;

	// Progress percentage
	double progress = 0;

	if (dltotal != 0 && speed != 0)
	{
		progress = (dlnow + resumeByte) / downloadFileLength * 100;
		leftTime = (downloadFileLength - dlnow - resumeByte) / speed;
		//printf("\t%.2f%%\tRemaing time:%s\n", progress, timeFormat);
	}

    if (data->cb != NULL)
		data->cb(data->sender, speed, leftTime, progress);

	return 0;
}

// Get the local file size, return -1 if failed
p_off_t HttpClient::getLocalFileLength(string path)
{
	p_off_t ret;
	struct stat fileStat;

	ret = stat(path.c_str(), &fileStat);
	if (ret == 0)
	{
		return fileStat.st_size;
	}

	return ret;
}

size_t nousecb(char *buffer, size_t x, size_t y, void *userdata)
{
	(void)buffer;
	(void)userdata;
	return x * y;
}

// Get the file size on the server
double HttpClient::getDownloadFileLength(string url)
{
    CURL *easy_handle = NULL;
	int ret = CURLE_OK;
	double size = -1;

	do
	{
		easy_handle = curl_easy_init();
		if (!easy_handle)
		{
            ZLOG("curl_easy_init error");
			break;
		}

		// Only get the header data
		ret = curl_easy_setopt(easy_handle, CURLOPT_URL, url.c_str());
		ret |= curl_easy_setopt(easy_handle, CURLOPT_HEADER, 1L);
		ret |= curl_easy_setopt(easy_handle, CURLOPT_NOBODY, 1L);
        ret |= curl_easy_setopt(easy_handle, CURLOPT_WRITEFUNCTION, nousecb);	// libcurl_a.lib will return error code 23 without this sentence on windows

		if (ret != CURLE_OK)
		{
            ZLOG("curl_easy_setopt error");
			break;
		}

		ret = curl_easy_perform(easy_handle);
		if (ret != CURLE_OK)
		{
			char s[100] = {0};
#ifdef _WIN32
			sprintf_s(s, sizeof(s), "error:%d:%s", ret, curl_easy_strerror(static_cast<CURLcode>(ret)));
#else
			sprintf(s, "error:%d:%s", ret, curl_easy_strerror(static_cast<CURLcode>(ret)));
#endif
            ZLOG(s);
			break;
		}

		// size = -1 if no Content-Length return or Content-Length=0
		ret = curl_easy_getinfo(easy_handle, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &size);
		if (ret != CURLE_OK)
		{
            ZLOG("curl_easy_getinfo error");
			break;
		}

	} while (0);

	curl_easy_cleanup(easy_handle);
	return size;
}