#include "WebReq.h"
#include "Utility.h"
#include "Platform.h"

#include "external/json/writer.h"
#include "external/json/stringbuffer.h"

using namespace std;

CWebReq::CWebReq()
{
}

void CWebReq::init()
{
	m_kWebIP = WEB_SERVER_ADDRESS;
	m_kSocketIP = "";
	HttpClient::getInstance()->setTimeoutForConnect(5);
	//std::string kUrl = "data_interface/client_config.aspx";
	//CWebReq::instance().sendRequestDocument(kUrl,CC_CALLBACK_1(MCCWebReq::CB_IP,this));
}
std::string CWebReq::getSocketIP()
 {
	 return m_kSocketIP;
 }
std::string CWebReq::getWebIp()
 {
	 return m_kWebIP+"/";
 }
void CWebReq::CB_IP(rapidjson::Document* pDoc)
 {
	 m_kWebIP = CWebReq::getDataValueStr(pDoc, "web_service_root");
	 m_kSocketIP = CWebReq::getDataValueStr(pDoc, "logon_server_ip");
 }
void CWebReq::sendRequestStr(std::string kUrl
	 ,std::function<void(std::string)> _callBack1)
 {
	 kUrl = utility::toString(getWebIp(),kUrl);
	 sendRequestDocumentUrl(kUrl,nullptr,_callBack1);
 }
void CWebReq::sendRequestDocument(std::string kUrl
	 ,std::function<void(rapidjson::Document*)> _callBack1)
 {
	 kUrl = utility::toString(getWebIp(),kUrl);
	 sendRequestDocumentUrl(kUrl,_callBack1,nullptr);
 }
void CWebReq::sendRequestDocumentUrl(std::string kUrl
	 ,std::function<void(rapidjson::Document*)> _callBack1
	 ,std::function<void(std::string)> _callBack2)
 {
	 HttpRequest *request = new HttpRequest();
	 request->setUrl(kUrl.c_str());
	 request->setRequestType(HttpRequest::Type::POST);

	 utility::mlog("web url:%s",request->getUrl());
	 request->setResponseCallback(CC_CALLBACK_2(CWebReq::resCallBack,this));
	 HttpClient::getInstance()->sendImmediate(request);
	 request->release();
	 SendStructInfo kInfo;
	 kInfo.m_fJsonResCallBack = _callBack1;
	 kInfo.m_fStrResCallBack = _callBack2;
	 kInfo.pRequest = request;
	 m_kCBList.push_back(kInfo);
 }

std::string CWebReq::getPostData(std::map<std::string, std::string>& paramenters)
 {
	 return  joinMapToData(paramenters);
 }

std::string CWebReq::joinMapToData(std::map<std::string, std::string> &paramenters)
 {
	 string data = "";
	 for(map<string,string>::iterator it = paramenters.begin(); it != paramenters.end(); ++it) {
		 if(it != paramenters.begin()){
			 data += "&";
		 }
		 data += it->first + "=" + it->second;
	 }
	 return data;
 }
void CWebReq::resCallBack(HttpClient* client, HttpResponse* response)
 {
	 SendStructInfo kInfo;
	 for (SendStructInfoList::iterator itor = m_kCBList.begin();itor != m_kCBList.end();itor++)
	 {
		 SendStructInfo& kTemp = *itor;
		 if (kTemp.pRequest == response->getHttpRequest())
		 {
			 kInfo = kTemp;
			 m_kCBList.erase(itor);
			 break;
		 }
	 }
	 CCAssert(kInfo.pRequest,"");

	 if(kInfo.m_fStrResCallBack)
	 {
		kInfo.m_fStrResCallBack(parseResData(response));
	 }
	 if (kInfo.m_fJsonResCallBack) 
	 {
		 std::string kData =  parseResData(response);
		 std::string::iterator itor = kData.begin();
		 rapidjson::Document doc;
		 if (parseDataByJson(kData,doc))
		 {
			 kInfo.m_fJsonResCallBack(&doc);
		 }
		 else
		 {
			 kInfo.m_fJsonResCallBack(nullptr);
		 }
	 }
 }
void CWebReq::pushValue(std::string& kUrl, std::string kKey, std::string kValue)
 {
	 if (kUrl.back() != '?')
	 {
		 kUrl += "&";
	 }
	 kUrl += kKey;
	 kUrl += "=";
	 kUrl += kValue;
 }

bool CWebReq::parseResByJson(HttpResponse *response, rapidjson::Document &doc)
 {
	 std::string _data =  parseResData(response);
	 if(_data==""||_data.size()<=0)
		 return false;
	 return  parseDataByJson(_data,doc);
 }

std::string CWebReq::parseResData(HttpResponse *response)
 {
	 if(!(response->isSucceed())){
		 const char *error = response->getErrorBuffer();
		 utility::mlog("error:%s, code:%ld", error, response->getResponseCode());
		 utility::mlog("XQ5CWebReq::getParseResData error = %s",error);
		 return "";
	 }
	 std::vector<char> *buffer = response->getResponseData();

	 std::string str;
	 for (unsigned int i = 0; i < buffer->size(); i++){
		 str.push_back((*buffer)[i]);
	 }
	 utility::mlog("XQ5CWebReq::getParseResData Sucess = %s",str.c_str());
	 return str;
 }

bool CWebReq::parseDataByJson(const std::string& data, rapidjson::Document &doc)
 {
	 if(data == "")
	 {
		 return false;
	 }
	 doc.Parse<0>(data.c_str());
	 if (doc.GetParseError())
	 {
		 utility::mlog(utility::toString(doc.GetParseError()).c_str());
		 return false;
	 }
	 return true;
}

HttpRequest* CWebReq::getFile(std::string kUrl, const ccHttpRequestCallback &callback)
 {
	 kUrl = utility::toString("http://",getWebIp(),"/"+kUrl);

	 HttpRequest *request = new HttpRequest();
	 request->setUrl(kUrl.c_str());

	 request->setResponseCallback(callback);

	 request->setRequestType(HttpRequest::Type::GET);

	 HttpClient::getInstance()->sendImmediate(request);
	 request->release();
	 return request;
 }

HttpRequest* CWebReq::getFileEx(std::string kUrl, const ccHttpRequestCallback &callback)
 {
	 HttpRequest *request = new HttpRequest();
	 request->setUrl(kUrl.c_str());

	 request->setResponseCallback(callback);

	 request->setRequestType(HttpRequest::Type::GET);

	 HttpClient::getInstance()->sendImmediate(request);
	 request->release();
	 return request;
 }