#pragma once

#include <curl/curl.h>
#include <gmock/gmock.h>

struct libcurl_mock
{
public:
    MOCK_METHOD1(
        curl_global_init,
        CURLcode ( long flags ));

    MOCK_METHOD0(
        curl_global_cleanup,
        void ( void ) );

     MOCK_METHOD2 (
         curl_slist_append,
         struct curl_slist * ( struct curl_slist *,
                               const char *));

    MOCK_METHOD1(curl_slist_free_all,
        void ( struct curl_slist * list ));

    MOCK_METHOD0(
        curl_easy_init,
        CURL * ( void ));

    MOCK_METHOD1(
        curl_easy_cleanup,
        void ( CURL *           curl ));

    MOCK_METHOD1(
        curl_easy_perform,
        CURLcode ( CURL *       curl ));

    MOCK_METHOD3(
        curl_easy_setopt_off,
        CURLcode( CURL *        curl,
                  CURLoption    option,
                  curl_off_t    value ));

    MOCK_METHOD3(
        curl_easy_setopt_ptr,
        CURLcode ( CURL *       curl,
                   CURLoption   option,
                   void *       value ));

    MOCK_METHOD3(
        curl_easy_setopt_long,
        CURLcode ( CURL *       curl,
                   CURLoption   option,
                   long         value ));

    MOCK_METHOD3(
        curl_easy_getinfo_off,
        CURLcode ( CURL *       curl,
                   CURLINFO     info,
                   curl_off_t * value));

    MOCK_METHOD3(
        curl_easy_getinfo_socket,
        CURLcode ( CURL *           curl,
                   CURLINFO         info,
                   curl_socket_t *  value));

    MOCK_METHOD3(
        curl_easy_getinfo_ptr,
        CURLcode ( CURL *   curl,
                   CURLINFO info,
                   void *   value));

    MOCK_METHOD3(
        curl_easy_getinfo_double,
        CURLcode ( CURL *   curl,
                   CURLINFO info,
                   double * value));

    MOCK_METHOD3(
        curl_easy_getinfo_long,
        CURLcode ( CURL *   curl,
                   CURLINFO info,
                   long *   value));

    MOCK_METHOD3(
        curl_easy_getinfo_str,
        CURLcode ( CURL *   curl,
                   CURLINFO info,
                   char **  value));

    MOCK_METHOD1(
        curl_easy_duphandle,
        CURL * ( CURL *curl ));

    MOCK_METHOD1(
        curl_easy_reset,
        void ( CURL *curl ));

    MOCK_METHOD4(
        curl_easy_recv,
        CURLcode ( CURL *   curl,
                   void *   buffer,
                   size_t   buflen,
                   size_t * n));

    MOCK_METHOD4(
        curl_easy_send,
        CURLcode ( CURL *       curl,
                   const void * buffer,
                   size_t       buflen,
                   size_t *     n));
    MOCK_METHOD1(
        curl_easy_strerror,
        const char * ( CURLcode mode ));

    MOCK_METHOD1(
        curl_multi_strerror,
        const char * ( CURLMcode mode ));

    MOCK_METHOD0(
        curl_multi_init,
        CURLM * ( void ));

    MOCK_METHOD1(
        curl_multi_cleanup,
        CURLMcode ( CURLM *multi_handle ));

    MOCK_METHOD2(
        curl_multi_add_handle,
        CURLMcode ( CURLM *   multi_handle,
                    CURL *    curl_handle ));

    MOCK_METHOD2(
        curl_multi_remove_handle,
        CURLMcode ( CURLM *    multi_handle,
                    CURL *     curl_handle ));

    MOCK_METHOD5(
        curl_multi_fdset,
        CURLMcode ( CURLM *    multi_handle,
                    fd_set *   read_fd_set,
                    fd_set *   write_fd_set,
                    fd_set *   exc_fd_set,
                    int *      max_fd));

    MOCK_METHOD5(
        curl_multi_wait,
        CURLMcode ( CURLM *             multi_handle,
                    struct curl_waitfd  extra_fds[],
                    unsigned int        extra_nfds,
                    int                 timeout_ms,
                    int *               ret));

    MOCK_METHOD2(
        curl_multi_perform,
        CURLMcode ( CURLM *  multi_handle,
                    int *    running_handles));

    MOCK_METHOD2(
        curl_multi_info_read,
        CURLMsg * ( CURLM *multi_handle,
                    int *msgs_in_queue));

    MOCK_METHOD2(
        curl_multi_timeout,
        CURLMcode ( CURLM *  multi_handle,
                    long *   milliseconds ));

public:
    inline libcurl_mock()
    {
        instance = this;
    }

    inline ~libcurl_mock()
    {
        if (instance == this)
            instance = nullptr;
    }

public:
    static libcurl_mock * instance;
};