#ifndef APP_GENSOFT_IMEJP_BUSINESSPLATFORM_INCLUDE_WINHTTP_HTTP_CLIENT_H
#define APP_GENSOFT_IMEJP_BUSINESSPLATFORM_INCLUDE_WINHTTP_HTTP_CLIENT_H
#include <Windows.h>
#include <winhttp.h>
#include <assert.h>
#include <string>
#include <sstream>
#include <vector>
#include <set>
#include <memory>

#pragma comment(lib, "Winhttp.lib")
#define USER_AGENT L"BDI18N"

namespace mjz
{
class WinError
    : public std::exception
{    // base of all logic-error exceptions
private:
	std::string m_str;    // the stored message string

public:
    explicit WinError(const std::string& message)
        : m_str(message)
    {    // construct from message string
        char buf[16] = {0}; 
        _ultoa_s(::GetLastError(), buf, 16, 10);
        m_str.append(" LastError:");
        m_str.append(buf);
    }


/*
	virtual ~WinError() _THROW0()
	{    // destroy the object
	}


	virtual const char *__CLR_OR_THIS_CALL what() const _THROW0()
	{    // return pointer to message string
		return (m_str.c_str());
	}

*/
    virtual ~WinError() throw()
    {    // destroy the object
    }


    virtual const char *__CLR_OR_THIS_CALL what() const throw()
    {    // return pointer to message string
        return (m_str.c_str());
    }

#if !_HAS_EXCEPTIONS
protected:
    virtual void __CLR_OR_THIS_CALL _Doraise() const
    {    // perform class-specific exception handling
        _RAISE(*this);
    }
#endif /* _HAS_EXCEPTIONS */


};

class RepeatCallError : public std::logic_error
{
public:
    explicit  RepeatCallError(const std::string& message)
        : std::logic_error(message)
    {    // construct from message string
    }

    virtual ~RepeatCallError() throw()
    {    // destroy the object
    }
};

class CLock
{
    PCRITICAL_SECTION m_pCS;
public:
    explicit CLock(PCRITICAL_SECTION pcs = NULL)
        : m_pCS(NULL)
    {
        if (pcs) {
            Lock(pcs);
        }
    }
    ~CLock()
    {
        if (m_pCS) {
            LeaveCriticalSection(m_pCS);
        }
    }
    void Lock(PCRITICAL_SECTION pSection)
    {
        if (m_pCS) {
            throw RepeatCallError("CLock:Lock.");
        }
        m_pCS = pSection;
        EnterCriticalSection(m_pCS);
    }
};

template<typename T, typename Closer, T INVALID=NULL>
class HandleBase
{
public:
    HandleBase()
        : m_h(INVALID) {}
    HandleBase(T handle)
        : m_h(handle) {}

    ~HandleBase() {
        Close();
    }
    BOOL IsValid() const {
        return m_h!=INVALID;
    }
    operator T() const {
        return m_h;
    }
    operator BOOL() const {
        return m_h!=INVALID;
    }
    T* operator&() {
        return &m_h;
    }
    void Close() {
        if (IsValid()) {
            Closer c;
            c.operator()(m_h);
            m_h=INVALID;
        }
    }
    T Detach() {
        T val = m_h;
        m_h = INVALID;
        return val;
    }
    void reset(T handle) {
        if (m_h!=handle) {
            Close();
            m_h=handle;
        }
    }
    T get() {
        return m_h;
    }
    void operator=(T handle) {
        assert(!IsValid());
        reset(handle);
    }
protected:
    T m_h;
};

class HttpCloser
{
public:
    void operator()(HINTERNET h) {
        ::WinHttpCloseHandle(h);
    }
};
class NormalCloser
{
public:
    void operator()(HANDLE h) {
        ::CloseHandle(h);
    }
};

class GlobalFreeCloser
{
public:
    void operator()(HLOCAL hMem) {
        ::GlobalFree(hMem);
    }
};
typedef HandleBase<HINTERNET, HttpCloser, NULL> HttpHandle;
typedef HandleBase<HANDLE, NormalCloser, NULL> FileHandle;
//typedef HandleBase<HANDLE, NormalCloser, INVALID_HANDLE_VALUE> FileHandle;
typedef HandleBase<HANDLE, NormalCloser, NULL> EventHandle; 
typedef HandleBase<HANDLE, GlobalFreeCloser, NULL> GlobalAllocHandle; 


class RefHandle
{
    volatile long m_lref;
public:
    RefHandle(): m_lref(1) {}
    void AddRef() {
        InterlockedIncrement(&m_lref);
    }
    void Release() {
        if (InterlockedDecrement(&m_lref) == 0) {
            delete this;
        }
    }
protected:
    virtual ~RefHandle() {}
};

class CriticalSection
{
protected:
    CRITICAL_SECTION m_cs;
public:
    CriticalSection() {
        if (!::InitializeCriticalSectionAndSpinCount(&m_cs, 4000)) {
            throw WinError("InitializeCriticalSectionAndSpinCount");
        }
    }
    virtual ~CriticalSection() {
        DeleteCriticalSection(&m_cs);
    }
};

class HttpSession : public HttpHandle, public RefHandle
{
public:
    inline HttpSession(BOOL bAsync=FALSE);
    inline static VOID CALLBACK _AsyncCallback(
        HINTERNET hInternet,
        DWORD_PTR dwContext,
        DWORD dwInternetStatus,
        LPVOID lpvStatusInformation,
        DWORD dwStatusInformationLength);
};

class ProxyResolver
{
    std::vector<std::wstring> m_allProxy; //至少包括一个空代理
protected:
    inline static void _GlobalFree(LPWSTR& lpPtr);
    inline static BOOL _IsRecoverableAutoProxyError(DWORD dwError);
    inline static BOOL _IsErrorValidForProxyFailover(DWORD dwError);
    inline static DWORD _GetProxyForAutoSettings(
        HINTERNET hSession,
        PCWSTR pwszUrl,
        PCWSTR pwszAutoConfigUrl,
        std::wstring& wsProxy,
        std::wstring& wsProxyBypass);
    inline void _ParseProxy(const std::wstring& wsProxy, const std::wstring& wsScheme);
public:
    ProxyResolver() {}
    inline DWORD ResolveProxy(HttpSession* pSession, PCWSTR pwszUrl);
    inline DWORD GetProxyServerNum() {return static_cast<DWORD>(m_allProxy.size());}
    inline std::wstring GetProxyList();
    inline void TakeFirst(LPCWSTR lpProxy);
    inline DWORD SetNextProxySetting(HINTERNET hInternet, DWORD dwRequestError, DWORD& dwNextIndex);
};

class HttpRequest;
class HttpConnection : public HttpHandle, public RefHandle, public CriticalSection
{
    ProxyResolver m_Proxy;
public:
    friend HttpRequest;
    inline HttpConnection(HttpSession* pSession, const std::wstring& wsUrl);
    ProxyResolver& GetProxy() {return m_Proxy;}
};

enum {ERROR_USER_CANCEL=1000000};

class FileHelper
{
public:
    inline static DWORD ReadFile(
        HANDLE hFile,
        HANDLE hCancelEvent,
        ULARGE_INTEGER ullOffSet,
        LPVOID lpBuf,
        DWORD dwByteNumToRead,
        DWORD& dwByteNumReaded);
    inline static DWORD WriteFile(
        HANDLE hFile,
        HANDLE hCancelEvent,
        ULARGE_INTEGER ullOffSet,
        LPCVOID pBuf,
        DWORD dwByteNum);
};
class StringHelper
{
public:
    static DWORD HashKey(LPCWSTR Key, SIZE_T nLen = -1)
    {
        DWORD i = 0;
        if (nLen == -1) {
            nLen = wcslen(Key);
        }
        while (nLen-- > 0) {
            i = (i << 5) + i + Key[nLen];
        }
        return i;
    }
    static void Trim(std::wstring& str)
    {
        while (!str.empty() && iswspace(*str.begin()))
        {
            str.erase(str.begin());
        }
        while (!str.empty() && iswspace(*str.rbegin()))
        {
            str.erase(str.size()-1);
        }
    }
};
template<typename T>
class SmartPtr
{
    T* m_ptr;
public:
    SmartPtr(T* ptr) : m_ptr(ptr) {}
    ~SmartPtr() {
        release();
    }
    
    operator T* () {
        return m_ptr;
    }
    T& operator*() {
        return *m_ptr;
    }
    T** operator&() {
        return &m_ptr;
    }
    T* operator->() {
        return m_ptr;
    }
    T* get() {
        return m_ptr;
    }
    T* detach() {
        T* pTemp = m_ptr;
        m_ptr = NULL;
        return pTemp;
    }
    void release() {
        T* pTemp = m_ptr;
        if (pTemp) {
            m_ptr = NULL;
            pTemp->Release();
        }
    }
    void reset(T* ptr) {
        release();
        m_ptr = ptr;
    }
};
typedef bool (*PROGRESSPROC)(double);

#define VERB_GET L"GET"
#define VERB_POST L"POST"

class HttpRequest : public RefHandle, public CriticalSection
{
public:
    static const DWORD WRITE_SIZE = 8092;
    static const DWORD MAX_READ_BUF_SIZE = 1024*1024;
    static const ULONGLONG INVALID_CONTENT_SIZE = -1;
public:
    friend HttpSession;
    friend HttpConnection;

    inline HttpRequest(const std::wstring &url,
        HttpSession* pSession=NULL,
        HttpConnection* pConnection=NULL);
    inline void SetProgressProc(PROGRESSPROC progressProc);
    inline void SetAdditionalRequestHeaders(const std::wstring &additionalRequestHeaders);
    inline void SetLocalFileToSaveResponse(const CString& file, BOOL bAllowPartialTranfer=FALSE);//get 接口
    inline void SetAdditionalDataToSend(BYTE *data, DWORD dataSize);//POST 接口
    inline void SetCookie(const std::wstring& wsCookie);
    inline void SetCallBackMsg(HWND hWnd, DWORD dwMsg);
    inline void SetCallBackEvent(HANDLE hEvent);
    inline void SetCancelEvent(HANDLE hEvent);
    inline void SetMaxTestRequestNum(SIZE_T nNum) {m_nMaxTestRequestNum = nNum;}
    inline DWORD Send(LPCWSTR httpVerb = L"GET");
    inline void Cancel();
    inline BOOL WaitResult(DWORD dwTimeout = INFINITE);
    inline std::wstring GetResponseHeader();
    inline std::wstring GetResponseCookies();
    inline DWORD GetStatusCode();
    inline const std::string& GetResponseBuf();
    inline std::wstring GetResponseCharset();
protected:
    inline ~HttpRequest(void);
    inline BOOL _LoadPartialTranferInfo();
    inline DWORD _SavPartialTranferInfo();
    inline DWORD _Finishing(DWORD dwErrorCode);
    inline DWORD _Finished(DWORD dwErrorCode);
    inline DWORD _Finished();
    inline DWORD _ReSendRequestWithProxy(HINTERNET hRequest, DWORD dwLastRequestError);
    inline DWORD _ReadData(DWORD dwDataSize);
    inline DWORD _WriteData();
    inline DWORD _OnReadComplete(DWORD dwByteNumReaded, DWORD dwError = ERROR_SUCCESS);
    inline DWORD _OnWriteComplete(DWORD dwByteNumWritten);
    inline DWORD _OnHeadersAvailable();
    inline DWORD _SaveData(LPBYTE lpBuf, DWORD dwDataLength);
    inline void _SetProgress();
    inline DWORD _GetAdditionalDataSize();
    inline LPBYTE _GetAdditionalDataBuf();
    inline DWORD _QueryHeaderStringInfo(std::wstring& wsInfo, DWORD dwInfoLevel, LPDWORD lpdwIndex);
    inline void _AttachRequest(HINTERNET hRequest);
    inline void _ClearTestRequest(HINTERNET hRequest);
protected:
    SmartPtr<HttpSession> m_pSession;
    SmartPtr<HttpConnection> m_pConnection;
    std::set<HINTERNET> m_testRequestSet;
    SIZE_T m_nMaxTestRequestNum;
    volatile HINTERNET m_hRequest;
    DWORD m_dwProxyIndex;
    std::wstring m_wsURL;
    std::wstring m_wsHost;
    std::wstring m_wsPath;
    std::wstring m_wsExtraInfo;
    std::wstring m_wsUserName;
    std::wstring m_wsPassword;
    INTERNET_SCHEME m_nScheme;
    PROGRESSPROC m_pfProcessProc;
    DWORD m_dwHttpError;
    EventHandle m_hFinishedEvent;
    EventHandle m_hCancelEvent;
    std::string         m_sReadBuf;
    DWORD m_dwBufSize;
    std::auto_ptr<BYTE> m_pAdditionalData;
    std::wstring m_wsVerb;
    std::wstring m_wsAdditionalRequestHeaders;
    std::wstring m_wsAdditionalRequestCookies;
    std::wstring m_wsResponseHeader;
    std::wstring m_wsResponseCookies;
    std::wstring m_wsLastModifyTime;
    std::wstring m_sResponseCharset;
    std::string   m_sResponseBuf;
    ULARGE_INTEGER m_ullContentBegin;
    ULARGE_INTEGER m_ullContentEnd;
    ULARGE_INTEGER m_ullContentTotalSize;
    ULARGE_INTEGER m_ullDataTransfered;
    DWORD m_dwStatusCode;
    //std::wstring m_wsLocalFileToSaveResponse;
	CString m_wsLocalFileToSaveResponse;
    BOOL m_bAllowPartialTranfer;
    BOOL m_bOnlyCheckModify;
    FileHandle m_hFile;
    FileHandle m_hInfoFile;
    ULARGE_INTEGER m_ullFilePoint;
    HWND m_hCallBackWnd;
    DWORD m_dwCallBackMsg;
    EventHandle m_hCallBackEvent;
};



HttpSession::HttpSession(BOOL bAsync/*=FALSE*/)
{
    m_h = ::WinHttpOpen(USER_AGENT,
        WINHTTP_ACCESS_TYPE_NO_PROXY,
        WINHTTP_NO_PROXY_NAME,
        WINHTTP_NO_PROXY_BYPASS,
        bAsync ? WINHTTP_FLAG_ASYNC : 0);

    if (m_h == NULL) {
        throw WinError("WinHttpOpen failed.");
    }

    if (bAsync && ::WinHttpSetStatusCallback(m_h,
        (WINHTTP_STATUS_CALLBACK)_AsyncCallback,
        WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS,
        0) == WINHTTP_INVALID_STATUS_CALLBACK) 
    {
        throw WinError("WinHttpSetStatusCallback failed.");
    }
}

VOID CALLBACK HttpSession::_AsyncCallback(
    HINTERNET hInternet,
    DWORD_PTR dwContext,
    DWORD dwInternetStatus,
    LPVOID lpvStatusInformation,
    DWORD dwStatusInformationLength
)
{
    DWORD dwError = ERROR_SUCCESS;
    HttpRequest* pClient = (HttpRequest*)dwContext;

    if (pClient == NULL)
    {
        return;
    }

    CLock lock1;

    if (dwInternetStatus != WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING)
    {
        // If we're going to try use the request handle then we'd better lock it.
        lock1.Lock(&pClient->m_cs);
    }

    switch (dwInternetStatus)
    {
    case WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE:
        if (pClient->m_hRequest == NULL)
        {
            pClient->_AttachRequest(hInternet);

            pClient->_ClearTestRequest(NULL);

            if (pClient->m_wsVerb == VERB_GET)
            {
                if (!::WinHttpReceiveResponse(pClient->m_hRequest, NULL)) 
                {
                    pClient->_Finishing(GetLastError());
                }
            }
            else
            {
                pClient->_WriteData();
            }
        }
        break;

    case  WINHTTP_CALLBACK_STATUS_REQUEST_ERROR:
        {
            WINHTTP_ASYNC_RESULT*pWinhttpAsyncResult = (WINHTTP_ASYNC_RESULT*)lpvStatusInformation;
            switch (pWinhttpAsyncResult->dwResult)
            {
            case API_SEND_REQUEST:
                if (pClient->m_hRequest)
                {
                    pClient->_ClearTestRequest(hInternet);
                }
                else if (ERROR_SUCCESS 
                    != pClient->_ReSendRequestWithProxy(hInternet, pWinhttpAsyncResult->dwError))
                {
                   pClient->_ClearTestRequest(hInternet);
                }
                break;
            
            case API_QUERY_DATA_AVAILABLE:
            case API_READ_DATA:
                pClient->_OnReadComplete(0, pWinhttpAsyncResult->dwError);
                break;
            case API_RECEIVE_RESPONSE:
            case API_WRITE_DATA:
                pClient->_Finishing(pWinhttpAsyncResult->dwError);
                break;
            default:
                break;
            }
        }
        break;

    case WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE:
        dwError = pClient->_OnHeadersAvailable();
        break;
    case WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE:
        dwError = pClient->_ReadData(*(LPDWORD)lpvStatusInformation);
        break;
    case WINHTTP_CALLBACK_STATUS_READ_COMPLETE:
        dwError = pClient->_OnReadComplete(dwStatusInformationLength);
        break;

    case WINHTTP_CALLBACK_STATUS_WRITE_COMPLETE:
        dwError = pClient->_OnWriteComplete(*(LPDWORD)lpvStatusInformation);
        break;

    case WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING:
        // Garanted last callback this context will ever receive. Release 
        // context when we're done on behalf of all callbacks. (Balances the
        // reference we took when we called WinHttpSendRequest)
        if (pClient->m_hRequest == hInternet)
        {
            pClient->_Finished();
        }
        pClient->Release();
        break;

    default:
        break;

    }
}

HttpConnection::HttpConnection(HttpSession* pSession, const std::wstring& wsUrl)
{
    URL_COMPONENTS url_component;
    ::ZeroMemory(&url_component, sizeof(URL_COMPONENTS));
    url_component.dwStructSize = sizeof(URL_COMPONENTS);
    wchar_t szHostName[256] = {0};
    url_component.lpszHostName = szHostName;
    url_component.dwHostNameLength  = 256;
    if (!::WinHttpCrackUrl(wsUrl.c_str(), (DWORD)wsUrl.length(), ICU_ESCAPE, &url_component))
    {
        throw WinError("WinHttpCrackUrl");
    }
    szHostName[url_component.dwHostNameLength] = 0;
    m_h = ::WinHttpConnect(
        pSession->get(),
        szHostName,
        url_component.nPort,
        0);

    if (m_h == NULL) {
        throw WinError("WinHttpConnect");
    }
    m_Proxy.ResolveProxy(pSession, wsUrl.c_str());
}

void ProxyResolver::_GlobalFree(LPWSTR& lpPtr)
{
    if (lpPtr) {
        ::GlobalFree(lpPtr);
        lpPtr = NULL;
    }
}

BOOL ProxyResolver::_IsRecoverableAutoProxyError(DWORD dwError)
{
    BOOL fRecoverable = FALSE;

    switch (dwError)
    {
    case ERROR_SUCCESS:
    case ERROR_INVALID_PARAMETER:
    case ERROR_WINHTTP_AUTO_PROXY_SERVICE_ERROR:
    case ERROR_WINHTTP_AUTODETECTION_FAILED:
    case ERROR_WINHTTP_BAD_AUTO_PROXY_SCRIPT:
    case ERROR_WINHTTP_LOGIN_FAILURE:
    case ERROR_WINHTTP_OPERATION_CANCELLED:
    case ERROR_WINHTTP_TIMEOUT:
    case ERROR_WINHTTP_UNABLE_TO_DOWNLOAD_SCRIPT:
    case ERROR_WINHTTP_UNRECOGNIZED_SCHEME:
        fRecoverable = TRUE;
        break;

    default:
        break;
    }

    return fRecoverable;
}

BOOL ProxyResolver::_IsErrorValidForProxyFailover(DWORD dwError)
{
    BOOL fValid = FALSE;

    switch (dwError)
    {
    case ERROR_WINHTTP_NAME_NOT_RESOLVED:
    case ERROR_WINHTTP_CANNOT_CONNECT:
    case ERROR_WINHTTP_CONNECTION_ERROR:
    case ERROR_WINHTTP_TIMEOUT:
        fValid = TRUE;
        break;

    default:
        break;
    }

    return fValid;
}

DWORD ProxyResolver::_GetProxyForAutoSettings(
    HINTERNET hSession,
    PCWSTR pwszUrl,
    PCWSTR pwszAutoConfigUrl,
    std::wstring& wsProxy,
    std::wstring& wsProxyBypass)
{
    DWORD dwError = ERROR_SUCCESS;
    WINHTTP_AUTOPROXY_OPTIONS waoOptions = {0};
    WINHTTP_PROXY_INFO wpiProxyInfo = {0};

    if (pwszAutoConfigUrl)
    {
        waoOptions.dwFlags = WINHTTP_AUTOPROXY_CONFIG_URL;
        waoOptions.lpszAutoConfigUrl = pwszAutoConfigUrl;
    }
    else
    {
        waoOptions.dwFlags = WINHTTP_AUTOPROXY_AUTO_DETECT;
        waoOptions.dwAutoDetectFlags = WINHTTP_AUTO_DETECT_TYPE_DHCP | WINHTTP_AUTO_DETECT_TYPE_DNS_A;
    }

    // First call with no autologon.  Autologon prevents the
    // session (in proc) or autoproxy service (out of proc) from caching
    // the proxy script.  This causes repetitive network traffic, so it is
    // best not to do autologon unless it is required according to the
    // result of WinHttpGetProxyForUrl.
  
    if (!::WinHttpGetProxyForUrl(hSession,
                               pwszUrl,
                               &waoOptions,
                               &wpiProxyInfo))
    {
        dwError = ::GetLastError();

        if (dwError != ERROR_WINHTTP_LOGIN_FAILURE)
        {
            goto quit;
        }
        // Enable autologon if challenged.
        dwError = ERROR_SUCCESS;
        waoOptions.fAutoLogonIfChallenged = TRUE;
        if (!::WinHttpGetProxyForUrl(hSession,
                                   pwszUrl,
                                   &waoOptions,
                                   &wpiProxyInfo))
        {
            dwError = ::GetLastError();
            goto quit;
        }
    }

    if (wpiProxyInfo.lpszProxy) {
        wsProxy = wpiProxyInfo.lpszProxy;
    }
    if (wpiProxyInfo.lpszProxyBypass) {
        wsProxyBypass = wpiProxyInfo.lpszProxyBypass;
    }
quit:
    _GlobalFree(wpiProxyInfo.lpszProxy);
    _GlobalFree(wpiProxyInfo.lpszProxyBypass);
    return dwError;
}

void ProxyResolver::_ParseProxy(const std::wstring& wsProxy, const std::wstring& wsScheme)
{
    if (wsProxy.empty())
        return;

    wchar_t* pNextProxy = NULL;
    wchar_t* pProxy = wcstok_s(const_cast<wchar_t*>(wsProxy.c_str()), L"; ", &pNextProxy);
    LPCWSTR lpEqualPos = NULL;
    while (pProxy != NULL)
    {
        std::wstring wsItem;
        if (lpEqualPos = wcsstr(pProxy, L"="))
        {
            std::wstring wsSchemePre(pProxy, lpEqualPos-pProxy);
            if (_wcsicmp(wsScheme.c_str(), wsSchemePre.c_str())==0)
            {
                wsItem = pProxy+wsSchemePre.length()+1;
            }
        } else {
            wsItem = pProxy;
        }
        StringHelper::Trim(wsItem);
        size_t i=0;
        while (i < m_allProxy.size())
        {
            if (m_allProxy[i] == wsItem)
            {
               break;
            }
            ++i;
        }
        if (i == m_allProxy.size())
        {
            m_allProxy.push_back(wsItem);
        }
        pProxy = wcstok_s(NULL, L"; ", &pNextProxy);
    }
}
DWORD ProxyResolver::ResolveProxy(HttpSession* pSession, PCWSTR pwszUrl)
{
    DWORD dwError = ERROR_SUCCESS;
    m_allProxy.clear();
    m_allProxy.push_back(L""); //空代理，表示不使用代理
    std::wstring wsProxy;
    std::wstring wsProxyBypass;
    LPCWSTR lpSchemeEnd = wcsstr(pwszUrl, L"://");
    if (lpSchemeEnd == NULL)
    {
        throw std::invalid_argument("url");
    }
   std::wstring wsScheme(pwszUrl, lpSchemeEnd-pwszUrl);

   //获取winhttp 默认代理
    WINHTTP_PROXY_INFO DefProxyInfo = {0};
    if (::WinHttpGetDefaultProxyConfiguration(&DefProxyInfo))
    {
        if (DefProxyInfo.dwAccessType == WINHTTP_ACCESS_TYPE_NAMED_PROXY && DefProxyInfo.lpszProxy)
        {
            _ParseProxy(DefProxyInfo.lpszProxy, wsScheme);
        } 
        _GlobalFree(DefProxyInfo.lpszProxy);
        _GlobalFree(DefProxyInfo.lpszProxyBypass);
    }

    //获取ie代理
    WINHTTP_CURRENT_USER_IE_PROXY_CONFIG IEProxyConfig = {};
    if (!::WinHttpGetIEProxyConfigForCurrentUser(&IEProxyConfig))
    {
        dwError = GetLastError();
        if (dwError != ERROR_FILE_NOT_FOUND)
        {
            goto quit;
        }

        // No IE proxy settings found, just do autodetect.
        IEProxyConfig.fAutoDetect = TRUE;
        dwError = ERROR_SUCCESS;
    }

    // Begin processing the proxy settings in the following order:
    //  1) Auto-Detect if configured.
    //  2) Auto-Config URL if configured.
    //  3) Static Proxy Settings if configured.
    //
    // In the event one mechanism fails with an expected error code it is
    // required to fall back to the next mechanism.  If the request fails
    // after exhausting all detected proxies, there should be no attempt
    // to discover additional proxies.
    if (IEProxyConfig.fAutoDetect)
    {
        // Detect Proxy Settings
        dwError = _GetProxyForAutoSettings(pSession->get(),
                                          pwszUrl,
                                          NULL,
                                          wsProxy,
                                          wsProxyBypass);

        if (dwError == ERROR_SUCCESS)
        {
            _ParseProxy(wsProxy, wsScheme);
        }

        if (!_IsRecoverableAutoProxyError(dwError))
        {
            goto quit;
        }

        // Fall back to Autoconfig URL or Static settings.  Application can
        // optionally take some action such as logging, or creating a mechanism
        // to expose multiple error codes in the class.
        dwError = ERROR_SUCCESS;
    }

    if (IEProxyConfig.lpszAutoConfigUrl)
    {
        // Run autoproxy with AutoConfig URL.
        dwError = _GetProxyForAutoSettings(pSession->get(),
                                          pwszUrl,
                                          IEProxyConfig.lpszAutoConfigUrl,
                                          wsProxy,
                                          wsProxyBypass);
        if (dwError == ERROR_SUCCESS)
        {
            _ParseProxy(wsProxy, wsScheme);
        }

        if (!_IsRecoverableAutoProxyError(dwError))
        {
            goto quit;
        }

        // Fall back to Static Settings.  Application can optionally take some
        // action such as logging, or creating a mechanism to to expose multiple
        // error codes in the class.
        dwError = ERROR_SUCCESS;
    }

    // Static Proxy Config.  Failover is not valid for static proxy since
    // it is always either a single proxy or a list containing protocol
    // specific proxies such as "proxy" or http=httpproxy;https=sslproxy

    if (IEProxyConfig.lpszProxy) {
        wsProxy = IEProxyConfig.lpszProxy;
    }
    if (IEProxyConfig.lpszProxyBypass) {
        wsProxyBypass = IEProxyConfig.lpszProxyBypass;
    }
    _ParseProxy(wsProxy, wsScheme);

quit:
    _GlobalFree(IEProxyConfig.lpszProxy);
    _GlobalFree(IEProxyConfig.lpszAutoConfigUrl);
    _GlobalFree(IEProxyConfig.lpszProxyBypass);
    return dwError;
}

DWORD ProxyResolver::SetNextProxySetting(HINTERNET hInternet, DWORD dwRequestError, DWORD& dwNextIndex)
{
    DWORD dwError = ERROR_SUCCESS;
    PWSTR pwszCursor = NULL;
    WINHTTP_PROXY_INFO NextProxyInfo = {0};

    if (!_IsErrorValidForProxyFailover(dwRequestError))
    {
        return ERROR_NO_MORE_ITEMS;
    }

    if (m_allProxy.size() > dwNextIndex)
    {
        WINHTTP_PROXY_INFO NextProxyInfo = {0};
        NextProxyInfo.dwAccessType = WINHTTP_ACCESS_TYPE_NO_PROXY;
        if (!m_allProxy[dwNextIndex].empty())
        {
            NextProxyInfo.dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
            NextProxyInfo.lpszProxy = const_cast<wchar_t*>(m_allProxy[dwNextIndex].c_str());
        }
        if (!::WinHttpSetOption(hInternet,
            WINHTTP_OPTION_PROXY,
            &NextProxyInfo,
            sizeof(NextProxyInfo)))
        {
            return ::GetLastError();
        }
        dwNextIndex ++;
        return ERROR_SUCCESS;
    }
    else
    {
        return ERROR_NO_MORE_ITEMS;
    }
}

void ProxyResolver::TakeFirst(LPCWSTR lpProxy)
{
    //proxy set 172.12.22.22:8234
    // lpProxy 172.12.22.22
    size_t i= 0;
    while (i < m_allProxy.size()) {
        if (m_allProxy[i] == lpProxy)
        {
            if (i > 0)
            {
                m_allProxy.erase(m_allProxy.begin()+i);
                m_allProxy.insert(m_allProxy.begin(), lpProxy);
            }
           break;
        }
        else if (*lpProxy != L'\0' && wcsstr(m_allProxy[i].c_str(), lpProxy) != NULL)
        {
            if (i > 0) {
                std::wstring wsItem = m_allProxy[i];
                m_allProxy.erase(m_allProxy.begin()+i);
                m_allProxy.insert(m_allProxy.begin(), wsItem);
            }
        }
        ++ i;
    }
}
std::wstring ProxyResolver::GetProxyList()
{
    std::wstring wsOut;
    std::vector<std::wstring>::iterator it = m_allProxy.begin();
    while (it != m_allProxy.end())
    {
        if (!it->empty())
        {
            if (it != m_allProxy.begin()) {
                wsOut += L"; ";
            }
            wsOut += *it;
        }
        ++ it;
    }
    return wsOut;
}


DWORD FileHelper::ReadFile(
    HANDLE hFile,
    HANDLE hCancelEvent,
    ULARGE_INTEGER ullOffSet,
    LPVOID lpBuf,
    DWORD dwByteNumToRead,
    DWORD& dwByteNumReaded)
{
    dwByteNumReaded = 0;

    OVERLAPPED oa = {0};
    oa.Offset = ullOffSet.LowPart;
    oa.OffsetHigh = ullOffSet.HighPart;
    oa.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
    EventHandle h(oa.hEvent);

    BOOL bRt = ::ReadFile(hFile, lpBuf, dwByteNumToRead, &dwByteNumReaded, &oa);

    if (bRt)
    {
        return dwByteNumReaded>0 ? ERROR_SUCCESS : ERROR_HANDLE_EOF;
    }
    else
    {
        DWORD dwError = ::GetLastError();
        if (dwError == ERROR_IO_PENDING)
        {
            HANDLE hWaitEvent[] = {hCancelEvent, oa.hEvent};
            DWORD dwRt = ::WaitForMultipleObjects(ARRAYSIZE(hWaitEvent), hWaitEvent, FALSE, INFINITE);
            if (dwRt == WAIT_OBJECT_0)
            {
                ::CancelIo(hFile);
                return ERROR_USER_CANCEL;
            }
            else if (dwRt == WAIT_OBJECT_0+1)
            {
                if (::GetOverlappedResult(hFile, &oa, &dwByteNumReaded, FALSE))
                {
                    return dwByteNumReaded>0 ? ERROR_SUCCESS : ERROR_HANDLE_EOF;
                }
            }
        }
    }
    return ::GetLastError();
}

DWORD FileHelper::WriteFile(
                                 HANDLE hFile,
                                 HANDLE hCancelEvent,
                                 ULARGE_INTEGER ullOffSet,
                                 LPCVOID pBuf,
                                 DWORD dwByteNum)
{
    DWORD dwNumOfByteToWrite = dwByteNum;
    DWORD dwNumOfByteWritten = 0;

    OVERLAPPED oa = {0};
    oa.Offset = ullOffSet.LowPart;
    oa.OffsetHigh = ullOffSet.HighPart;
    oa.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
    EventHandle event(oa.hEvent);
    BOOL bRt = ::WriteFile(hFile, pBuf, dwNumOfByteToWrite, &dwNumOfByteWritten, &oa);
    if (bRt && dwNumOfByteWritten == dwNumOfByteToWrite)
    {
        return ERROR_SUCCESS;
    }
    else if (!bRt && GetLastError() == ERROR_IO_PENDING)
    {
        HANDLE hWaitEvent[] = {hCancelEvent, oa.hEvent};
        DWORD dwRt = ::WaitForMultipleObjects(ARRAYSIZE(hWaitEvent), hWaitEvent, FALSE, INFINITE);
        if (dwRt == WAIT_OBJECT_0)
        {
            ::CancelIo(hFile);
            return ERROR_USER_CANCEL;
        }
        else if (dwRt == WAIT_OBJECT_0+1)
        {
            if (::GetOverlappedResult(hFile, &oa, &dwNumOfByteWritten, FALSE)
                && dwNumOfByteWritten==dwNumOfByteToWrite)
            {
                return ERROR_SUCCESS;
            }
        }
        return ::GetLastError();
    }
    else
    {
        throw WinError("WriteFile error.");
    }
}





HttpRequest::HttpRequest(
                         const std::wstring &wsUrl,
                         HttpSession* pSession/*=NULL*/,
                         HttpConnection* pConnection/*=NULL*/)
: m_pSession(pSession)
, m_pConnection(pConnection)
, m_hRequest(NULL)
, m_dwProxyIndex(0)
, m_wsURL(wsUrl)
, m_dwHttpError(ERROR_SUCCESS)
, m_dwStatusCode(-1)
, m_hCallBackWnd(NULL)
, m_dwCallBackMsg(NULL)
, m_bAllowPartialTranfer(FALSE)
, m_bOnlyCheckModify(FALSE)
, m_nMaxTestRequestNum(1)
{
    m_ullFilePoint.QuadPart = 0;
    m_ullContentBegin.QuadPart = INVALID_CONTENT_SIZE;
    m_ullContentEnd.QuadPart = INVALID_CONTENT_SIZE;
    m_ullContentTotalSize.QuadPart = INVALID_CONTENT_SIZE;
    m_ullDataTransfered.QuadPart = 0;
    m_pfProcessProc = NULL;

    m_hFinishedEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
    m_hCancelEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);


    if (m_pSession.get() == NULL) {
        m_pSession.reset(new HttpSession(TRUE));
    } else {
        m_pSession->AddRef();
    }
    if (m_pConnection.get() == NULL) {
        m_pConnection.reset(new HttpConnection(m_pSession, m_wsURL));
    } else {
        m_pConnection->AddRef();
    }


    URL_COMPONENTS url_component;
    ::ZeroMemory(&url_component, sizeof(URL_COMPONENTS));
    url_component.dwStructSize = sizeof(URL_COMPONENTS);

    wchar_t szHostName[256] = {0};
    url_component.lpszHostName = szHostName;
    url_component.dwHostNameLength  = 256;

    wchar_t szUrlPath[512] = {0};
    url_component.lpszUrlPath = szUrlPath;
    url_component.dwUrlPathLength = 512;

    std::auto_ptr<wchar_t> pExtraInfo(new wchar_t[wsUrl.size()*4]);
    url_component.lpszExtraInfo = pExtraInfo.get();
    url_component.dwExtraInfoLength = (DWORD)wsUrl.size()*4;

    wchar_t szUserName[256] = {0};
    url_component.lpszUserName = szUserName;
    url_component.dwUserNameLength = 256;

    wchar_t szPassword[256] = {0};
    url_component.lpszPassword = szPassword;
    url_component.dwPasswordLength = 256;

    if (!::WinHttpCrackUrl(wsUrl.c_str(), (DWORD)wsUrl.length(), ICU_ESCAPE, &url_component))
    {
        throw WinError("WinHttpCrackUrl");
    }
    m_wsHost.assign(url_component.lpszHostName, url_component.dwHostNameLength);
    m_wsPath.assign(url_component.lpszUrlPath, url_component.dwUrlPathLength);
    m_wsExtraInfo.assign(url_component.lpszExtraInfo, url_component.dwExtraInfoLength);
    m_wsPassword.assign(url_component.lpszPassword, url_component.dwPasswordLength);
    m_wsUserName.assign(url_component.lpszUserName, url_component.dwUserNameLength);

    m_nScheme  = url_component.nScheme;
}

HttpRequest::~HttpRequest(void)
{
}

DWORD HttpRequest::Send(LPCWSTR httpVerb /*= L"GET"*/)
{
    if (_wcsicmp(httpVerb, VERB_GET) == 0)
    {
        m_wsVerb = VERB_GET;
    }
    else if (_wcsicmp(httpVerb, VERB_POST) == 0)
    {
        m_wsVerb = VERB_POST;
    }
    else
    {
        throw std::invalid_argument("verb error.");
    }

    DWORD dwOpenRequestFlag =
        (m_nScheme == INTERNET_SCHEME_HTTPS) ? WINHTTP_FLAG_SECURE : 0;

    std::wstring wsObjectName = m_wsPath + m_wsExtraInfo;

    CLock lock(&m_pConnection->m_cs);
    for (DWORD i=0; i<m_pConnection->GetProxy().GetProxyServerNum(); ++i)
    {
        HttpHandle hRequest = ::WinHttpOpenRequest(
            m_pConnection->get(),
            m_wsVerb.c_str(),
            wsObjectName.c_str(),
            NULL,
            WINHTTP_NO_REFERER,
            WINHTTP_DEFAULT_ACCEPT_TYPES,
            dwOpenRequestFlag);

        if (!hRequest)
        {
            throw WinError("WinHttpOpenRequest");
        }
        if (!m_wsUserName.empty())
        {
            if (!::WinHttpSetCredentials(
                hRequest,
                WINHTTP_AUTH_TARGET_SERVER,
                WINHTTP_AUTH_SCHEME_BASIC,
                m_wsUserName.c_str(),
                m_wsPassword.c_str(),
                NULL))
            {
                throw WinError("WinHttpSetCredentials");
            }
        }
        if (m_bOnlyCheckModify)
        {
            assert(!m_wsLastModifyTime.empty());
            if (!m_wsLastModifyTime.empty())
            {
                std::wstring wsRange(L"If-Modified-Since: ");
                wsRange += (m_wsLastModifyTime + L"\r\n");
                if (!::WinHttpAddRequestHeaders(
                    hRequest,
                    wsRange.c_str(),
                    static_cast<DWORD>(wsRange.size()),
                    WINHTTP_ADDREQ_FLAG_ADD|WINHTTP_ADDREQ_FLAG_REPLACE))
                {
                    throw WinError("WinHttpAddRequestHeaders");
                }
            }
        }
        else if (m_ullContentBegin.QuadPart != INVALID_CONTENT_SIZE)
        {
            assert(!m_wsLastModifyTime.empty());
            //TCHAR szRange[256];
            //swprintf_s(szRange, 256, _T(""), );
			CString szRange;
			szRange.Format(_T("Range: bytes=%I64u-\r\n"), m_ullContentBegin.QuadPart);
            if (!::WinHttpAddRequestHeaders(
                hRequest,
                szRange.AllocSysString(),
                -1,
                WINHTTP_ADDREQ_FLAG_ADD|WINHTTP_ADDREQ_FLAG_REPLACE))
            {
                throw WinError("WinHttpAddRequestHeaders");
            }
            if (!m_wsLastModifyTime.empty())
            {
                std::wstring wsRange(L"Unless-Modified-Since: ");
                wsRange += (m_wsLastModifyTime + L"\r\n");
                if (!::WinHttpAddRequestHeaders(
                    hRequest,
                    wsRange.c_str(),
                    static_cast<DWORD>(wsRange.size()),
                    WINHTTP_ADDREQ_FLAG_ADD|WINHTTP_ADDREQ_FLAG_REPLACE))
                {
                    throw WinError("WinHttpAddRequestHeaders");
                }
            }
        }


        if (!m_wsAdditionalRequestHeaders.empty())
        {
            if (!::WinHttpAddRequestHeaders(
                hRequest,
                m_wsAdditionalRequestHeaders.c_str(),
                static_cast<DWORD>(m_wsAdditionalRequestHeaders.size()),
                WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON))
            {
                throw WinError("WinHttpAddRequestHeaders");
            }
        }

        if (!m_wsAdditionalRequestCookies.empty())
        {
            std::wstring cookies = L"Cookie: ";
            cookies += m_wsAdditionalRequestCookies;
            if (!::WinHttpAddRequestHeaders(hRequest,
                cookies.c_str(),
                static_cast<DWORD>(cookies.size()),
                WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON))
            {
                throw WinError("WinHttpAddRequestHeaders");
            }
        }
        if (ERROR_SUCCESS
            != m_pConnection->GetProxy().SetNextProxySetting(hRequest, ERROR_WINHTTP_TIMEOUT, m_dwProxyIndex))
        {
                break;
        }
        m_testRequestSet.insert(hRequest.Detach());
        if (m_nMaxTestRequestNum <= m_testRequestSet.size())
        {
            break;
        }
    }
    std::set<HINTERNET>::iterator it = m_testRequestSet.begin();
    while (it != m_testRequestSet.end())
    {
        AddRef();
        DWORD_PTR dwPtr = (DWORD_PTR)this;
        DWORD dwTotalLength = _GetAdditionalDataSize();
        if (!::WinHttpSendRequest(*it,
            WINHTTP_NO_ADDITIONAL_HEADERS,
            0,
            WINHTTP_NO_REQUEST_DATA,
            0,
            dwTotalLength,
            dwPtr))
        {
            throw WinError("WinHttpSendRequest");
        }
        ++ it;
    }
    //异步操作，需要到_AsyncCallback去处理
    return ERROR_SUCCESS;
}
DWORD HttpRequest::_ReSendRequestWithProxy(HINTERNET hRequest, DWORD dwLastRequestError)
{
    DWORD dwError = m_pConnection->GetProxy().SetNextProxySetting(hRequest,
                                                      dwLastRequestError, m_dwProxyIndex);

    if (dwError != ERROR_SUCCESS)
    {
        return dwLastRequestError;
    }
    else
    {
        DWORD dwTotalLength = _GetAdditionalDataSize();
        if (!::WinHttpSendRequest(hRequest,
            WINHTTP_NO_ADDITIONAL_HEADERS,
            0,
            WINHTTP_NO_REQUEST_DATA,
            0,
            dwTotalLength,
            NULL))
        {
            return dwLastRequestError;
        }
        return ERROR_SUCCESS;
    }
}

BOOL HttpRequest::WaitResult(DWORD dwTimeout)
{
    if (WAIT_OBJECT_0 != ::WaitForSingleObject(m_hFinishedEvent, dwTimeout))
    {
        Cancel();
        ::WaitForSingleObject(m_hFinishedEvent, INFINITE);
        return FALSE;
    }
    if (m_wsVerb == L"GET")
    {
        return m_dwHttpError == ERROR_SUCCESS;
    }
    else
    {
        return m_dwHttpError == ERROR_SUCCESS;
    }
}

void HttpRequest::Cancel()
{
    CLock lock(&m_cs);
    if (!::SetEvent(m_hCancelEvent))
    {
        throw WinError("SetEvent");
    }
    _Finishing(ERROR_USER_CANCEL);
}

DWORD HttpRequest::_Finishing(DWORD dwErrorCode)
{
    if (WAIT_OBJECT_0 == ::WaitForSingleObject(m_hCancelEvent, 0))
    {
        m_dwHttpError = ERROR_USER_CANCEL;
    } else {
        m_dwHttpError = dwErrorCode;
    }
    if (m_hRequest) {
        ::WinHttpCloseHandle(m_hRequest); //这里不置0，需要保留原值，用于比对
    }
    return dwErrorCode;
}
std::wstring HttpRequest::GetResponseHeader()
{
    CLock lock(&m_cs);
    return m_wsResponseHeader;
}

DWORD HttpRequest::_Finished()
{
    m_hFile.Close();
    m_hInfoFile.Close();

    ::SetEvent(m_hFinishedEvent);
    if (m_hCallBackEvent) {
        ::SetEvent(m_hCallBackEvent);
    }
    if (m_hCallBackWnd) {
        ::PostMessage(m_hCallBackWnd, m_dwCallBackMsg, (WPARAM)this, (LPARAM)WaitResult());
    }
    return m_dwHttpError;
}

DWORD HttpRequest::_Finished(DWORD dwErrorCode)
{
    m_dwHttpError = dwErrorCode;
    if (m_hRequest) {
        ::WinHttpCloseHandle(m_hRequest); //这里不置0，需要保留原值，用于比对
    }
    _Finished();
    return dwErrorCode;
}

DWORD HttpRequest::_QueryHeaderStringInfo(
                                    std::wstring& wsInfo,
                                    DWORD dwInfoLevel,
                                    LPDWORD   lpdwIndex)
{
    DWORD dwSize = 0;
    ::WinHttpQueryHeaders(m_hRequest,
        dwInfoLevel,
        WINHTTP_HEADER_NAME_BY_INDEX,
        WINHTTP_NO_OUTPUT_BUFFER,
        &dwSize,
        lpdwIndex);
    if (::GetLastError() == ERROR_INSUFFICIENT_BUFFER)
    {
        wsInfo.resize(dwSize/2, 0);
        if (::WinHttpQueryHeaders(m_hRequest,
            dwInfoLevel,
            WINHTTP_HEADER_NAME_BY_INDEX,
            (LPWSTR)wsInfo.data(),
            &dwSize,
            lpdwIndex))
        {
            wsInfo.resize(dwSize/2, 0);
            return ERROR_SUCCESS;
        }
        else
        {
            wsInfo.clear();
        }
    }
    return ::GetLastError();
}
DWORD HttpRequest::_OnHeadersAvailable()
{
    DWORD dwRt =  _QueryHeaderStringInfo(
        m_wsResponseHeader, WINHTTP_QUERY_RAW_HEADERS_CRLF, WINHTTP_NO_HEADER_INDEX);
    if (dwRt != ERROR_SUCCESS)
    {
        return _Finishing(dwRt);
    }

    DWORD dwInfoLevel = WINHTTP_QUERY_FLAG_NUMBER | WINHTTP_QUERY_STATUS_CODE;
    DWORD dwLength  = sizeof(m_dwStatusCode);
    if (!::WinHttpQueryHeaders(m_hRequest,
        dwInfoLevel,
        WINHTTP_HEADER_NAME_BY_INDEX,
        &m_dwStatusCode,
        &dwLength,
        WINHTTP_NO_HEADER_INDEX)) 
    {
        return _Finishing(::GetLastError());
    }
    if (m_dwStatusCode < HTTP_STATUS_FIRST || m_dwStatusCode > HTTP_STATUS_LAST)
    {
        throw std::runtime_error("invalid status code");
    }

    if (m_wsVerb == VERB_GET)
    {
        //cookie
        m_wsResponseCookies.clear();
        DWORD dwIndex = 0;
        do
        {
            std::wstring wsCookie;
            dwRt =  _QueryHeaderStringInfo(
                wsCookie, WINHTTP_QUERY_SET_COOKIE, &dwIndex);
            if (dwRt == ERROR_SUCCESS)
            {
                if (m_wsResponseCookies.size() > 0)
                {
                    m_wsResponseCookies += L"; ";
                }
                StringHelper::Trim(wsCookie);
                m_wsResponseCookies += wsCookie;
            }
            else if (m_wsResponseCookies.size()>0 && *m_wsResponseCookies.rbegin() != L';')
            {
                m_wsResponseCookies.append(1, L';');
            }
        } while (dwRt == ERROR_SUCCESS);

        //last modify time
        dwRt =  _QueryHeaderStringInfo(
            m_wsLastModifyTime, WINHTTP_QUERY_LAST_MODIFIED, WINHTTP_NO_HEADER_INDEX);

        if (m_wsLastModifyTime.empty())
        {
            m_bAllowPartialTranfer = FALSE;
        }
        // charset
        std::wstring wsContentType;
        dwRt =  _QueryHeaderStringInfo(
            wsContentType, WINHTTP_QUERY_CONTENT_TYPE, WINHTTP_NO_HEADER_INDEX);
        if (!wsContentType.empty() && wsContentType.find(L"charset=")!=std::wstring::npos)
        {
            wchar_t szType[256] = {0};
            wchar_t szCharset[256] = {0};
            swscanf_s(wsContentType.c_str(), L"%[^;]; charset=%s",
                szType, ARRAYSIZE(szType), szCharset, ARRAYSIZE(szCharset));
            m_sResponseCharset = szCharset;
        }

        if (m_dwStatusCode == HTTP_STATUS_OK) //200
        {
            m_ullFilePoint.QuadPart = 0;
            m_ullContentBegin.QuadPart = 0;
            dwInfoLevel = WINHTTP_QUERY_FLAG_NUMBER | WINHTTP_QUERY_CONTENT_LENGTH;
            ULONGLONG uContentLength = 0;
            dwLength = sizeof(uContentLength);
            if (::WinHttpQueryHeaders(m_hRequest,
                dwInfoLevel,
                WINHTTP_HEADER_NAME_BY_INDEX,
                &uContentLength,
                &dwLength,
                WINHTTP_NO_HEADER_INDEX)) 
            {
                m_ullContentTotalSize.QuadPart = uContentLength;
                m_ullContentEnd.QuadPart = uContentLength-1;
            }
        }
        else if (m_dwStatusCode == HTTP_STATUS_PARTIAL_CONTENT) //206
        {
            std::wstring wsContentRange;
            dwRt =  _QueryHeaderStringInfo(
                wsContentRange, WINHTTP_QUERY_CONTENT_RANGE, WINHTTP_NO_HEADER_INDEX);

            if (dwRt == ERROR_SUCCESS)
            {
                ULONGLONG uContentBegin=0, uContentEnd=0, uContentTotalSize=0;
                if (3 == swscanf_s(wsContentRange.c_str(),
                    L"bytes %I64u-%I64u/%I64u",
                    &uContentBegin, &uContentEnd, &uContentTotalSize)
                    && uContentBegin <= uContentEnd
                    && uContentEnd < uContentTotalSize)
                {
                    m_ullContentBegin.QuadPart = uContentBegin;
                    m_ullContentEnd.QuadPart = uContentEnd;
                    m_ullContentTotalSize.QuadPart = uContentTotalSize;
                    m_ullFilePoint.QuadPart = uContentBegin;
                } else {
                    throw std::invalid_argument("Content Range");
                }
            } else {
                return _Finishing(dwRt);
            }
        }
        else if (m_dwStatusCode == HTTP_STATUS_NOT_MODIFIED) //304
        {
            assert(m_bOnlyCheckModify);
            return _Finishing(ERROR_SUCCESS);
        }
        else
        {
            return _Finishing(m_dwStatusCode);
        }
        assert(HTTP_STATUS_OK == m_dwStatusCode  || HTTP_STATUS_PARTIAL_CONTENT == m_dwStatusCode);

        if (m_hFile.IsValid())
        {
            if (!::SetFilePointerEx(m_hFile, *(PLARGE_INTEGER)&m_ullFilePoint, NULL, FILE_BEGIN)) {
                throw WinError("SetFilePointerEx");
            }
            if (!::SetEndOfFile(m_hFile)) {
                throw WinError("SetEndOfFile");
            }
        }

        if (!::WinHttpQueryDataAvailable(m_hRequest, NULL))
        {
            throw WinError("WinHttpQueryDataAvailable");
        }
        return ERROR_SUCCESS;
    }
    else
    {
        if (m_dwStatusCode == HTTP_STATUS_OK)
        {
            return _Finishing(ERROR_SUCCESS);
        }
        return _Finishing(m_dwStatusCode);
    }
}

DWORD HttpRequest::_ReadData(DWORD dwDataSize)
{
    if (dwDataSize == 0)
    {
        return _OnReadComplete(0);
    }
    if (m_sReadBuf.size() < dwDataSize)
    {
        m_sReadBuf.resize(dwDataSize);
    }
    if (!::WinHttpReadData(m_hRequest, const_cast<char*>(m_sReadBuf.data()), dwDataSize, NULL))
    {
        return _Finishing(::GetLastError());
    }
    return ERROR_SUCCESS;
}

DWORD HttpRequest::_OnReadComplete(DWORD dwByteNumReaded, DWORD dwError)
{
    if (dwByteNumReaded != 0)
    {
        m_sResponseBuf.append(m_sReadBuf.c_str(), dwByteNumReaded);
    }

    if (!m_wsLocalFileToSaveResponse.IsEmpty())
    {
        if (!m_hFile)
        {
            m_hFile = ::CreateFile(m_wsLocalFileToSaveResponse.GetBuffer(),
                GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_FLAG_OVERLAPPED, NULL);
            if (!m_hFile)
            {
                return _Finishing(::GetLastError());
            }
            assert(m_ullFilePoint.QuadPart == 0);
            assert(m_ullDataTransfered.QuadPart == 0);
            assert(m_ullContentBegin.QuadPart == 0);
        }
        size_t nBufSize = m_sResponseBuf.size();
        if (nBufSize > MAX_READ_BUF_SIZE || (dwByteNumReaded == 0 && nBufSize > 0))
        {
            DWORD dwRt = FileHelper::WriteFile(m_hFile, m_hCancelEvent, m_ullFilePoint, m_sResponseBuf.data(), nBufSize);
            m_sResponseBuf.clear();
            if (ERROR_SUCCESS == dwRt)
            {
                m_ullDataTransfered.QuadPart += nBufSize;
                m_ullFilePoint.QuadPart += nBufSize;
                if (m_bAllowPartialTranfer)
                {
                    _SavPartialTranferInfo();
                }
                _SetProgress();
            }
            else
            {
                return _Finishing(dwRt);
            }
        }
    }
    else
    {
        m_ullDataTransfered.QuadPart += dwByteNumReaded;
        _SetProgress();
    }

    if (dwByteNumReaded != 0)
    {
        assert(dwError == ERROR_SUCCESS);
        if (!::WinHttpQueryDataAvailable(m_hRequest, NULL))
        {
            throw WinError("WinHttpQueryDataAvailable");
        }
        return ERROR_SUCCESS;
    }

    if (dwError != ERROR_SUCCESS)
    {
        return _Finishing(dwError);
    }
    //有时候dwByteNumReaded == 0，但是实际下载没有完成，所以做个check
    //但是有时候下载网页，拿不到content-length，只有transfer-encoding:chunked，那么不知道m_ullContentEnd的值
    //所以无法通过检查接收的数据大小来确认是否下载完成，那么只能依赖于dwByteNumReaded == 0
    if (m_ullContentTotalSize.QuadPart != INVALID_CONTENT_SIZE
        && m_ullDataTransfered.QuadPart < m_ullContentEnd.QuadPart-m_ullContentBegin.QuadPart+1)
    {
        return _Finishing(ERROR_WINHTTP_INTERNAL_ERROR);
    }
    return _Finishing(ERROR_SUCCESS);
}

DWORD HttpRequest::_WriteData()
{
    ULONGLONG ullTotalLength = _GetAdditionalDataSize();
    if (ullTotalLength > 0)
    {
        if (ullTotalLength > m_ullDataTransfered.QuadPart)
        {
            ULONGLONG ullDataLen = WRITE_SIZE;
            if (ullDataLen > ullTotalLength - m_ullDataTransfered.QuadPart)
            {
                ullDataLen = ullTotalLength - m_ullDataTransfered.QuadPart;
            }
            if (!::WinHttpWriteData(
                m_hRequest,
                _GetAdditionalDataBuf()+m_ullDataTransfered.QuadPart,
                (DWORD)ullDataLen,
                NULL))
            {
                return _Finishing(::GetLastError());
            }
            return ERROR_SUCCESS;
        }
        else if (ullTotalLength == m_ullDataTransfered.QuadPart)
        {
            if (!::WinHttpReceiveResponse(m_hRequest, NULL)) 
            {
                return _Finishing(GetLastError());
            }
            return ERROR_SUCCESS;
        }
        else
        {
            throw std::runtime_error("invalid transfer data size");
        }
        assert(FALSE);
    }
    throw std::runtime_error("invalid data size");
}
DWORD HttpRequest::_OnWriteComplete(DWORD dwByteNumWritten)
{
    if (dwByteNumWritten != 0)
    {
        m_ullDataTransfered.QuadPart += dwByteNumWritten;
        _SetProgress();
    }
    return _WriteData();
}


DWORD HttpRequest::_SaveData(LPBYTE lpBuf, DWORD dwDataLength)
{
    if (m_wsLocalFileToSaveResponse.IsEmpty())
    {
        m_sResponseBuf.append((const char*)lpBuf, dwDataLength);
        return ERROR_SUCCESS;
    }
    if (!m_hFile)
    {
        m_hFile = ::CreateFile(m_wsLocalFileToSaveResponse.GetBuffer(),
            GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_FLAG_OVERLAPPED, NULL);
        if (!m_hFile)
        {
            return _Finishing(::GetLastError());
        }
        assert(m_ullFilePoint.QuadPart == 0);
        assert(m_ullDataTransfered.QuadPart == 0);
        assert(m_ullContentBegin.QuadPart ==0);
    }
    DWORD dwRt = FileHelper::WriteFile(m_hFile, m_hCancelEvent, m_ullFilePoint, lpBuf, dwDataLength);
    if (ERROR_SUCCESS == dwRt)
    {
        m_ullFilePoint.QuadPart += dwDataLength;
    }
    return dwRt;
}

void HttpRequest::SetLocalFileToSaveResponse(const CString& file, BOOL bAllowPartialTranfer/*=FALSE*/)
{
    m_wsLocalFileToSaveResponse = file;
    m_bAllowPartialTranfer = bAllowPartialTranfer;
    if (m_bAllowPartialTranfer)
    {
        _LoadPartialTranferInfo();
    }
}

void HttpRequest::SetAdditionalRequestHeaders(const std::wstring &additionalRequestHeaders)
{
    m_wsAdditionalRequestHeaders = additionalRequestHeaders;
}

void HttpRequest::SetAdditionalDataToSend(BYTE *data, DWORD dataSize)
{
    if (data == NULL || dataSize == 0)
    {
        return;
    }
    m_pAdditionalData.reset(new BYTE[dataSize+sizeof(dataSize)]);
    memcpy(m_pAdditionalData.get(), &dataSize, sizeof(dataSize));
    memcpy(m_pAdditionalData.get()+sizeof(dataSize), data, dataSize);
}

void HttpRequest::SetCallBackMsg(HWND hWnd, DWORD dwMsg)
{
    m_hCallBackWnd = hWnd;
    m_dwCallBackMsg =dwMsg;
}

void HttpRequest::SetCallBackEvent(HANDLE hEvent)
{
    HANDLE hEventDup = NULL;
    if (!::DuplicateHandle(::GetCurrentProcess(), 
        hEvent, 
        ::GetCurrentProcess(),
        &hEventDup, 
        EVENT_MODIFY_STATE,
        FALSE,
        0))
    {
        throw WinError("DuplicateHandle");
    }
    m_hCallBackEvent = hEventDup;
}

void HttpRequest::SetCancelEvent(HANDLE hEvent)
{
    HANDLE hEventDup = NULL;
    if (!::DuplicateHandle(::GetCurrentProcess(), 
        hEvent,
        ::GetCurrentProcess(),
        &hEventDup,
        EVENT_MODIFY_STATE,
        FALSE,
        0))
    {
        throw WinError("DuplicateHandle");
    }
    m_hCancelEvent.reset(hEventDup);
}

void HttpRequest::SetProgressProc(PROGRESSPROC progressProc)
{
    m_pfProcessProc = progressProc;
}

void HttpRequest::_SetProgress()
{
    if (m_pfProcessProc == NULL) {
        return;
    }
    if (m_wsVerb == VERB_GET)
    {
        if (m_ullContentTotalSize.QuadPart != INVALID_CONTENT_SIZE)
        {
            ULONGLONG ullTotalDataTransfered = m_ullContentBegin.QuadPart + m_ullDataTransfered.QuadPart;
            double dProgress = (double)ullTotalDataTransfered * 100 / m_ullContentTotalSize.QuadPart;
            m_pfProcessProc(dProgress);
        }
    }
    else if (m_wsVerb == VERB_POST && _GetAdditionalDataSize() > 0)
    {
        double dProgress = (double)m_ullDataTransfered.QuadPart * 100 / _GetAdditionalDataSize();
        m_pfProcessProc(dProgress);
    }
}

std::wstring HttpRequest::GetResponseCookies()
{
    CLock lock(&m_cs);
    return m_wsResponseCookies;
}

DWORD HttpRequest::GetStatusCode()
{
    CLock lock(&m_cs);
    return m_dwStatusCode;
}

std::wstring HttpRequest::GetResponseCharset()
{
    CLock lock(&m_cs);
    return m_sResponseCharset;
}

const std::string& HttpRequest::GetResponseBuf()
{
    CLock lock(&m_cs);
    return m_sResponseBuf;
}

BOOL HttpRequest::_LoadPartialTranferInfo()
{
	CString strInfoFile;
	strInfoFile.Format(_T("%s.info"), m_wsLocalFileToSaveResponse);
	m_hInfoFile = ::CreateFile(strInfoFile.GetBuffer(),
        GENERIC_READ|GENERIC_WRITE, NULL, NULL, OPEN_ALWAYS,
        FILE_FLAG_OVERLAPPED|FILE_FLAG_WRITE_THROUGH|FILE_FLAG_NO_BUFFERING, NULL);

    if (!m_hInfoFile || GetLastError() != ERROR_ALREADY_EXISTS) {
        return FALSE;
    }

    BOOL bReadFileOk = FALSE;
    DWORD dwSize = ::GetFileSize(m_hInfoFile, NULL);
    std::auto_ptr<BYTE> pBuf;
    if (dwSize > 10 && dwSize < 1024*1024)
    {
        pBuf.reset(new BYTE[dwSize+2]);
        DWORD dwByteNumReaded = 0;
        ULARGE_INTEGER ullOffset = {0};
        if (ERROR_SUCCESS == FileHelper::ReadFile(m_hInfoFile, m_hCancelEvent, ullOffset, pBuf.get(), dwSize, dwByteNumReaded)
            && dwByteNumReaded == dwSize)
        {
            bReadFileOk = TRUE;
        }
    }

    if (bReadFileOk)
    {
        wchar_t* lpBuf = (wchar_t*)(pBuf.get()+sizeof(DWORD)*2);
        DWORD dwInfoSize = *(LPDWORD)(pBuf.get()+sizeof(DWORD));
        if (dwInfoSize+sizeof(DWORD)*2 > dwSize)
        {
            return FALSE;
        }
        lpBuf[dwInfoSize/2] = 0;
        DWORD dwHashKey = StringHelper::HashKey(lpBuf, dwInfoSize/2);
        DWORD dwHashKey2 = *(LPDWORD)pBuf.get();
       if (dwHashKey != dwHashKey2)
       {
           return FALSE;
       }
       wchar_t szLastModify[256] = {0};
       std::auto_ptr<wchar_t> pUrl(new wchar_t[dwInfoSize/2]);
       ULONGLONG  ullTotalSize = 0;
       ULONGLONG ullSize = 0;
       int nRt =  swscanf_s(lpBuf,
           L"total_size=%I64u\nsize=%I64u\nurl=%[^\n]\nlast_modify=%[^\n]\n",
           &ullTotalSize, &ullSize,
           pUrl.get(), dwInfoSize/2,
           szLastModify, 256);

       if (4 > nRt)
       {
           return FALSE;
       }
       if (m_wsURL != pUrl.get())
       {
           //不是同一个url，从头下
           m_ullFilePoint.QuadPart = 0;
           return FALSE;
       }
       m_hFile = ::CreateFile(m_wsLocalFileToSaveResponse.GetBuffer(),
           GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_FLAG_OVERLAPPED, NULL);
       if (!m_hFile)
       {
           _Finishing(::GetLastError());
           return FALSE;
       }
       if (!::GetFileSizeEx(m_hFile, (PLARGE_INTEGER)&m_ullFilePoint))
       {
           throw WinError("GetFileSizeEx");
       }
       if (m_ullFilePoint.QuadPart < ullSize)
       {
           //源文件已经被破坏了,从头开始下载
           m_ullFilePoint.QuadPart = 0;
           return FALSE;
       }
       m_ullFilePoint.QuadPart = ullSize;
       m_wsLastModifyTime = szLastModify;
       m_ullContentBegin.QuadPart = ullSize;
       m_ullContentTotalSize.QuadPart = ullTotalSize;
       m_ullContentEnd.QuadPart = ullTotalSize-1;

       if (ullSize == ullTotalSize)
       {//已经下完了，去服务器看看是否有更新
           m_bOnlyCheckModify = TRUE;
       }
       return TRUE;
   }
    return FALSE;
}

DWORD HttpRequest::_SavPartialTranferInfo()
{
    if (!m_hInfoFile)
    {
        return ERROR_INVALID_HANDLE;
    }
    std::wostringstream os;
    os << L"total_size=" << m_ullContentTotalSize.QuadPart << L"\n"
        << L"size=" << m_ullDataTransfered.QuadPart+m_ullContentBegin.QuadPart << L"\n"
        << L"url=" << m_wsURL << L"\n"
        << L"last_modify=" << m_wsLastModifyTime << L"\n";

    
    std::wstring wsInfo = os.str();
    DWORD nBufSize = (DWORD)wsInfo.size()*2+sizeof(DWORD)*2;
    nBufSize = (nBufSize/4096+1)*4096;
    std::auto_ptr<BYTE> pBuf(new BYTE[nBufSize]);
    LPBYTE lpBuf = pBuf.get();

    DWORD dwHashKey = StringHelper::HashKey(wsInfo.c_str(), wsInfo.size());
    memcpy(lpBuf, &dwHashKey, sizeof(DWORD));

    lpBuf += sizeof(DWORD);
    DWORD dwInfoSize = static_cast<DWORD>(wsInfo.size())*2;
    memcpy(lpBuf, &dwInfoSize, sizeof(DWORD));

    lpBuf += sizeof(DWORD);
    memcpy(lpBuf, wsInfo.c_str(), wsInfo.size()*2);

    ULARGE_INTEGER ullOffset = {0};
    return FileHelper::WriteFile(m_hInfoFile, m_hCancelEvent, ullOffset, pBuf.get(), nBufSize);
}

DWORD HttpRequest::_GetAdditionalDataSize()
{
    DWORD dwTotalLength = 0;
    if (m_pAdditionalData.get())
    {
        dwTotalLength = *(LPDWORD)m_pAdditionalData.get();
    }
    return dwTotalLength;
}
LPBYTE HttpRequest::_GetAdditionalDataBuf()
{
    return m_pAdditionalData.get()+sizeof(DWORD);
}

void HttpRequest::_AttachRequest(HINTERNET hRequest)
{
    WINHTTP_PROXY_INFO pi = {0};
    DWORD dwLen = sizeof(pi);
    if (::WinHttpQueryOption(hRequest, WINHTTP_OPTION_PROXY, &pi, &dwLen))
    {
        if (pi.dwAccessType == WINHTTP_ACCESS_TYPE_NO_PROXY)
        {
            CLock lock(&m_pConnection->m_cs);
            m_pConnection->GetProxy().TakeFirst(L"");
        }
        else if (pi.dwAccessType == WINHTTP_ACCESS_TYPE_NAMED_PROXY) {
            CLock lock(&m_pConnection->m_cs);
            m_pConnection->GetProxy().TakeFirst(pi.lpszProxy);
        }
    }
    m_hRequest = hRequest;
    m_testRequestSet.erase(hRequest);
}

void HttpRequest::_ClearTestRequest(HINTERNET hRequest)
{
    if (hRequest == NULL)
    {
        std::set<HINTERNET>::iterator it = m_testRequestSet.begin();
        while (it != m_testRequestSet.end())
        {
            ::WinHttpCloseHandle(*it);
            ++it;
        }
        m_testRequestSet.clear();
    }
    else if (m_testRequestSet.find(hRequest) != m_testRequestSet.end())
    {
        ::WinHttpCloseHandle(hRequest);
        m_testRequestSet.erase(hRequest);
    }
    if (m_testRequestSet.empty() && m_hRequest == NULL)
    {
        _Finished(ERROR_WINHTTP_CANNOT_CONNECT);
    }
}

}
#endif // APP_GENSOFT_IMEJP_BUSINESSPLATFORM_INCLUDE_WINHTTP_HTTP_CLIENT_H