/*
 * Copyright: JessMA Open Source (ldcsaa@gmail.com)
 *
 * Version	: 3.6.1
 * Author	: Bruce Liang
 * Website	: http://www.jessma.org
 * Project	: https://github.com/ldcsaa
 * Blog		: http://www.cnblogs.com/ldcsaa
 * Wiki		: http://www.oschina.net/p/hp-socket
 * QQ Group	: 75375912
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once

#include "TcpClient.h"
#include "HttpHelper.h"

template<class T> class CHttpClientT : public IHttpRequester, public T
{
private:
	typedef THttpObjT<CHttpClientT, CHttpClientT>	THttpObj;
	friend struct									THttpObj;

public:
	virtual BOOL SendRequest(LPCSTR lpszMethod, LPCSTR lpszPath, const THeader lpHeaders[] = nullptr, int iHeaderCount = 0, const BYTE* pBody = nullptr, int iLength = 0);

	virtual BOOL SendPost(LPCSTR lpszPath, const THeader lpHeaders[], int iHeaderCount, const BYTE* pBody, int iLength)
		{return SendRequest(HTTP_METHOD_POST, lpszPath, lpHeaders, iHeaderCount, pBody, iLength);}
	virtual BOOL SendPut(LPCSTR lpszPath, const THeader lpHeaders[], int iHeaderCount, const BYTE* pBody, int iLength)
		{return SendRequest(HTTP_METHOD_PUT, lpszPath, lpHeaders, iHeaderCount, pBody, iLength);}
	virtual BOOL SendPatch(LPCSTR lpszPath, const THeader lpHeaders[], int iHeaderCount, const BYTE* pBody, int iLength)
		{return SendRequest(HTTP_METHOD_PATCH, lpszPath, lpHeaders, iHeaderCount, pBody, iLength);}
	virtual BOOL SendGet(LPCSTR lpszPath, const THeader lpHeaders[] = nullptr, int iHeaderCount = 0)
		{return SendRequest(HTTP_METHOD_GET, lpszPath, lpHeaders, iHeaderCount);}
	virtual BOOL SendDelete(LPCSTR lpszPath, const THeader lpHeaders[] = nullptr, int iHeaderCount = 0)
		{return SendRequest(HTTP_METHOD_DELETE, lpszPath, lpHeaders, iHeaderCount);}
	virtual BOOL SendHead(LPCSTR lpszPath, const THeader lpHeaders[] = nullptr, int iHeaderCount = 0)
		{return SendRequest(HTTP_METHOD_HEAD, lpszPath, lpHeaders, iHeaderCount);}
	virtual BOOL SendTrace(LPCSTR lpszPath, const THeader lpHeaders[] = nullptr, int iHeaderCount = 0)
		{return SendRequest(HTTP_METHOD_TRACE, lpszPath, lpHeaders, iHeaderCount);}
	virtual BOOL SendOptions(LPCSTR lpszPath, const THeader lpHeaders[] = nullptr, int iHeaderCount = 0)
		{return SendRequest(HTTP_METHOD_OPTIONS, lpszPath, lpHeaders, iHeaderCount);}
	virtual BOOL SendConnect(LPCSTR lpszHost, const THeader lpHeaders[] = nullptr, int iHeaderCount = 0)
		{return SendRequest(HTTP_METHOD_CONNECT, lpszHost, lpHeaders, iHeaderCount);}

public:

	virtual void SetLocalVersion(EnHttpVersion enLocalVersion)	{m_enLocalVersion = enLocalVersion;}
	virtual EnHttpVersion GetLocalVersion()						{return m_enLocalVersion;}

	virtual BOOL IsUpgrade()
		{return m_objHttp.IsUpgrade();}
	virtual BOOL IsKeepAlive()
		{return m_objHttp.IsKeepAlive();}
	virtual USHORT GetVersion()
		{return m_objHttp.GetVersion();}
	virtual ULONGLONG GetContentLength()
		{return m_objHttp.GetContentLength();}
	virtual LPCSTR GetContentType()
		{return m_objHttp.GetContentType();}
	virtual EnHttpUpgradeType GetUpgradeType()
		{return m_objHttp.GetUpgradeType();}
	virtual USHORT GetParseErrorCode(LPCSTR* lpszErrorDesc = nullptr)
		{return m_objHttp.GetParseErrorCode(lpszErrorDesc);}

	virtual BOOL GetHeader(LPCSTR lpszName, LPCSTR* lpszValue)
		{return m_objHttp.GetHeader(lpszName, lpszValue);}
	virtual BOOL GetHeaders(LPCSTR lpszName, LPCSTR lpszValue[], DWORD& dwCount)
		{return m_objHttp.GetHeaders(lpszName, lpszValue, dwCount);}
	virtual BOOL GetAllHeaders(THeader lpHeaders[], DWORD& dwCount)
		{return m_objHttp.GetAllHeaders(lpHeaders, dwCount);}
	virtual BOOL GetAllHeaderNames(LPCSTR lpszName[], DWORD& dwCount)
		{return m_objHttp.GetAllHeaderNames(lpszName, dwCount);}

	virtual BOOL GetCookie(LPCSTR lpszName, LPCSTR* lpszValue)
		{return m_objHttp.GetCookie(lpszName, lpszValue);}
	virtual BOOL GetAllCookies(TCookie lpCookies[], DWORD& dwCount)
		{return m_objHttp.GetAllCookies(lpCookies, dwCount);}
	virtual BOOL AddCookie(LPCSTR lpszName, LPCSTR lpszValue, BOOL bRelpace = TRUE)
		{return m_objHttp.AddCookie(lpszName, lpszValue, bRelpace);}
	virtual BOOL DeleteCookie(LPCSTR lpszName)
		{return m_objHttp.DeleteCookie(lpszName);}
	virtual BOOL DeleteAllCookies()
		{m_objHttp.DeleteAllCookies(); return TRUE;}

	virtual USHORT GetStatusCode()
		{return m_objHttp.GetStatusCode();}

protected:
	virtual BOOL CheckParams();

	virtual EnHandleResult DoFireReceive(IClient* pClient, const BYTE* pData, int iLength)
		{ASSERT(pClient == this); return m_objHttp.Execute(pData, iLength);}

	EnHandleResult DoFireSuperReceive(CHttpClientT* pClient, const BYTE* pData, int iLength)
		{ASSERT(pClient == this); return __super::DoFireReceive(pClient, pData, iLength);}

	virtual void Reset()
	{
		m_objHttp.Reset();

		__super::Reset();
	}

	EnHttpParseResult FireMessageBegin(IHttp* pHttp)
		{return m_pListener->OnMessageBegin(pHttp);}
	EnHttpParseResult FireRequestLine(IHttp* pHttp, LPCSTR lpszMethod, LPCSTR lpszUrl)
		{return m_pListener->OnRequestLine(pHttp, lpszMethod, lpszUrl);}
	EnHttpParseResult FireStatusLine(IHttp* pHttp, USHORT usStatusCode, LPCSTR lpszDesc)
		{return m_pListener->OnStatusLine(pHttp, usStatusCode, lpszDesc);}
	EnHttpParseResult FireHeader(IHttp* pHttp, LPCSTR lpszName, LPCSTR lpszValue)
		{return m_pListener->OnHeader(pHttp, lpszName, lpszValue);}
	EnHttpParseResult FireHeadersComplete(IHttp* pHttp)
		{return m_pListener->OnHeadersComplete(pHttp);}
	EnHttpParseResult FireBody(IHttp* pHttp, const BYTE* pData, int iLength)
		{return m_pListener->OnBody(pHttp, pData, iLength);}
	EnHttpParseResult FireChunkHeader(IHttp* pHttp, int iLength)
		{return m_pListener->OnChunkHeader(pHttp, iLength);}
	EnHttpParseResult FireChunkComplete(IHttp* pHttp)
		{return m_pListener->OnChunkComplete(pHttp);}
	EnHttpParseResult FireMessageComplete(IHttp* pHttp)
		{return m_pListener->OnMessageComplete(pHttp);}
	EnHttpParseResult FireUpgrade(IHttp* pHttp, EnHttpUpgradeType enUpgradeType)
		{return m_pListener->OnUpgrade(pHttp, enUpgradeType);}
	EnHttpParseResult FireParseError(IHttp* pHttp, int iErrorCode, LPCSTR lpszErrorDesc)
		{return m_pListener->OnParseError(pHttp, iErrorCode, lpszErrorDesc);}

public:
	CHttpClientT(IHttpClientListener* pListener)
	: T					(pListener)
	, m_pListener		(pListener)
	, m_enLocalVersion	(DEFAULT_HTTP_VERSION)
	, m_objHttp			(FALSE, this, this)
	{

	}

	virtual ~CHttpClientT()
	{
		Stop();
	}

private:
	IHttpClientListener*	m_pListener;

	EnHttpVersion			m_enLocalVersion;

	THttpObj				m_objHttp;

};

typedef CHttpClientT<CTcpClient> CHttpClient;

#ifdef _SSL_SUPPORT

#include "SSLClient.h"

typedef CHttpClientT<CSSLClient> CHttpsClient;

#endif