UrlLoaders.h

#pragma once
#include "IDataLoader.h"
#include <vector>
/* curl specific */
#include <curl/curl.h>
#include "util/mutex.h"

namespace NPL
{
    class NPLObjectProxy;
}

namespace ParaEngine
{
    class CUrlProcessor;
    class IProcessorWorkerData;

    class CUrlLoader : public IDataLoader
    {
    public:
        CUrlLoader();
        CUrlLoader(const string& url);
        ~CUrlLoader();

        void CleanUp();

        virtual void SetEstimatedSizeInBytes(int nSize);

        virtual int GetEstimatedSizeInBytes();
    public:
        const char* GetFileName();

        void SetUrl(const char* url);

        virtual HRESULT Decompress( void** ppData, int* pcBytes );
        virtual HRESULT Destroy();
        virtual HRESULT Load();

        virtual bool IsDeviceObject() { return false; };
    private:
        std::string m_url;
        int m_nEstimatedSizeInBytes;
    };

    class CUrlProcessorUserData
    {
    public:
        CUrlProcessorUserData(){};
        virtual ~CUrlProcessorUserData(){};
    };

    typedef DWORD (*URL_LOADER_CALLBACK)(int nResult, CUrlProcessor* pRequest, CUrlProcessorUserData* pUserData);

    struct upload_context
    {
        upload_context(const char* data, int nDataSize = 0);
        const char* m_pData;
        int m_nDataSize;
        int m_nBytesSent;
    };

    class CUrlProcessor : public IDataProcessor
    {
    public:
        // default time out in milliseconds
        static const DWORD DEFAULT_TIME_OUT = 15000;
        CUrlProcessor();
        CUrlProcessor(const string& url, const string& npl_callback);
        ~CUrlProcessor();

        void CleanUp();
    // overrides
    public:
        virtual HRESULT LockDeviceObject();
        virtual HRESULT UnLockDeviceObject();
        virtual HRESULT Destroy();
        virtual HRESULT Process( void* pData, int cBytes );
        virtual HRESULT CopyToResource();
        virtual void    SetResourceError();

        virtual void SetProcessorWorkerData(IProcessorWorkerData * pThreadLocalData );
        virtual IProcessorWorkerData * GetProcessorWorkerData();

        virtual bool IsDeviceObject() { return false; };
    public:
        enum URLREQUEST_TYPE
        {
            URL_REQUEST_HTTP_AUTO,
            URL_REQUEST_HTTP_GET,
            URL_REQUEST_HTTP_POST,
            URL_REQUEST_HTTP_GETFILE,
            URL_REQUEST_HTTP_HEADERS_ONLY,
        };

        enum URLREQUEST_STATUS
        {
            // not yet started
            URL_REQUEST_UNSTARTED,
            URL_REQUEST_INCOMPLETE,
            URL_REQUEST_COMPLETED,
        };

    public:
        void SetUrl(const char* url);

        void SetHeadersOnly();

        void SetScriptCallback(const char* sCallback);

        void SetSaveToFile(const char* filename);
        
        void AppendHTTPHeader(const char* text);

        CURLFORMcode AppendFormParam(const char* name, const char* value);

        CURLFORMcode AppendFormParam(const char* name, const char* type, const char* file, const char* data, int datalen, bool bCacheData = false);

        void SetCurlEasyOpt(CURL* handle);

        void CompleteTask();

        static size_t CUrl_write_data_callback(void *buffer, size_t size, size_t nmemb, void *stream);
        static size_t CUrl_write_header_callback(void *buffer, size_t size, size_t nmemb, void *stream);
        static int CUrl_progress_callback(void *clientp,double dltotal,double dlnow,double ultotal, double ulnow);
        static size_t CUrl_read_email_payload(void *ptr, size_t size, size_t nmemb, void *userp);

        size_t write_data_callback(void *buffer, size_t size, size_t nmemb);
        size_t write_header_callback(void *buffer, size_t size, size_t nmemb);
        int progress_callback(double dltotal, double dlnow, double ultotal, double ulnow);

        void SetTimeOut(int nMilliSeconds);
        int GetTimeOut();

        void SetForbidReuse(bool bForbidReuse);

        void SetCallBack(URL_LOADER_CALLBACK pFuncCallback=NULL, CUrlProcessorUserData* pUserData=NULL, bool bDeleteUserData=false);

        bool IsTimedOut(DWORD nCurrentTime);

        DWORD UpdateTime();

        void SafeDeleteUserData();

        CUrlProcessorUserData* GetUserData() {return m_pUserData;}

        inline vector<char>& GetData() {return m_data;}

        inline vector<char>& GetHeader() {return m_header;}

        int GetTotalBytes();

        int GetBytesReceived();

        void AddBytesReceived(int nBytesReceived);
            
        bool IsEnableProgressUpdate() const;

        void SetEnableProgressUpdate(bool val);

        const char* CopyRequestData(const char* pData, int nLength);

        NPL::NPLObjectProxy& GetOptions();

        bool IsSyncCallbackMode() const;
        void SetSyncCallbackMode(bool val);
    private:
        int InvokeCallbackScript(const char* sCode, int nLength);
    public:
        string m_url;
        struct curl_slist * m_pHttpHeaders;
        struct curl_httppost* m_pFormPost;
        struct curl_httppost* m_pFormLast;

        IProcessorWorkerData * m_pThreadLocalData;

        int m_nPriority;
        std::string m_sNPLCallback;
        std::string m_sNPLStateName;

        URL_LOADER_CALLBACK m_pfuncCallBack;
        string m_sSaveToFileName;
        CParaFile* m_pFile;

        int m_nUserDataType;
        CUrlProcessorUserData * m_pUserData;
        
        URLREQUEST_TYPE m_type;
        URLREQUEST_STATUS m_nStatus;

        DWORD m_nStartTime;
        DWORD m_nLastProgressTime;

        DWORD m_nTimeOutTime;
        bool m_bForbidReuse;
        bool m_bEnableProgressUpdate;
        bool m_bIsSyncCallbackMode;
        
        int m_nBytesReceived;
        int m_nTotalBytes;
        
        vector<char> m_data;
        vector<char> m_header;
        std::string m_sResponseData;
        std::string m_sResponseHeader;
        // this is cache of the request data if any
        std::string m_sRequestData;
        // curl return code
        CURLcode m_returnCode;   
        // the last received HTTP or FTP code. We will expect 200 for successful HTTP response
        long m_responseCode;  

        upload_context* m_pUploadContext;

        std::unique_ptr<NPL::NPLObjectProxy> m_options;

        //ParaEngine::mutex m_mutex;
    };
}