#include "ImagicDownManager.h"
#include "Utility.h"
#include "JniFun.h"
#include "cocostudio/CocoStudio.h"
#include "UI/CocosGUI.h"

SINGLETON_STORAGE(ImagicDownManager);

ImagicDownManager::ImagicDownManager()
	:m_iIdexCout(0)
{
	cocos2d::Director::getInstance()->getScheduler()->schedule(CC_SCHEDULE_SELECTOR(ImagicDownManager::upTime),this,0.0f,false);
}
ImagicDownManager::~ImagicDownManager(void)
{
	cocos2d::Director::getInstance()->getScheduler()->unschedule(CC_SCHEDULE_SELECTOR(ImagicDownManager::upTime),this);
}
std::string DownImagicGetFileName(std::string kName)
{
	std::string::size_type iStart = 0;
	while (true)
	{
		std::string::size_type iTempPos = kName.find("/",iStart);
		if (iTempPos == std::string::npos)
		{
			break;
		}
		iStart = iTempPos;
		iStart++;
	}
	size_t iEnd = kName.size();
	return kName.substr(iStart,iEnd-iStart);
}

void ImagicDownManager::GetImagic(HttpClient *sender, HttpResponse *response)
{
	long statusCode = response->getResponseCode();
	std::string reqUrl = response->getHttpRequest()->getUrl();
	if (!response->isSucceed() || statusCode != 200)
	{
		cocos2d::log("ImagicDownManager::GetImagic FAILED url=%s code=%ld error=%s",
			reqUrl.c_str(), statusCode,
			response->getErrorBuffer() ? response->getErrorBuffer() : "unknown");
	}
	response->retain();
	m_pGetList.push_back(response);
}

void ImagicDownManager::OnImagic()
{
	if (m_pGetList.size() == 0)
	{
		return;
	}
	HttpResponse *response = m_pGetList[0];
	m_pGetList.erase(m_pGetList.begin());
	std::string kUrl = response->getHttpRequest()->getUrl();
	std::string kImagicName = cocos2d::FileUtils::getInstance()->getWritablePath()+"test.png";

	ImagicDownInfoList::iterator itor1 = m_pDownList.begin();
	while(itor1 != m_pDownList.end())
	{
		ImagicDownInfo& kInfo = *itor1;
		if (kInfo.kUrl.find(kUrl.c_str()) != std::string::npos)
		{
			kImagicName = kInfo.kImagicName;
			break;
		}
		itor1++;
	}
	std::vector<char> *buffer = response->getResponseData();
	if (buffer->size() == 0)
	{
		cocos2d::log("ImagicDownManager::OnImagic empty response for url=%s code=%ld",
			kUrl.c_str(), response->getResponseCode());
		response->release();
		return;
	}

	Image* img = new Image;
	img->initWithImageData((unsigned char*)buffer->data(),buffer->size());
	bool bSucess = false;
	if (img->getData())
	{
		bSucess = img->saveToFile(kImagicName, false);
	}

	delete img;
	img = nullptr;

#if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)
	// Fallback: use Android BitmapFactory via JNI when C++ libjpeg fails (ABI mismatch)
	if (!bSucess)
	{
		cocos2d::log("ImagicDownManager::OnImagic C++ decode failed, trying JNI fallback url=%s", kUrl.c_str());
		bSucess = JniFun::decodeAndSaveImage(buffer->data(), (int)buffer->size(), kImagicName.c_str());
	}
#endif

	if (!bSucess)
	{
		cocos2d::log("ImagicDownManager::OnImagic save failed file=%s url=%s", kImagicName.c_str(), kUrl.c_str());
		response->release();
		return;
	}		// 头像获取不到的时候直接返回;

	ImagicDownInfoList::iterator itor2 = m_pDownList.begin();
	while(itor2 != m_pDownList.end())
	{
		ImagicDownInfo& kInfo = *itor2;
        if (kInfo.kUrl.find(kUrl.c_str()) != std::string::npos)
		{
			if (kInfo.pSprite)
			{
				if (bSucess)
				{
					utility::setImagic(kInfo.pSprite,kImagicName,kInfo.bSameSize, kInfo.bCircle);
				}
				kInfo.pSprite->release();
			}
			if (kInfo.pButtonSprite)
			{
				if (bSucess)
				{
					//utility::setButtonImagic(kInfo.pButtonSprite,kImagicName,kImagicName,kImagicName);
				}
				kInfo.pButtonSprite->release();
			}
			itor2 = m_pDownList.erase(itor2);
		}
		else
		{
			itor2++;
		}
	}
	response->release();
}

Texture2D* ImagicDownManager::getDownTexture(std::string kFile)
{
	TextureCache* pTextureCache = cocos2d::Director::getInstance()->getTextureCache();
	Texture2D* pTexture = pTextureCache->addImage(kFile.c_str());
	if (pTexture)
	{
		return pTexture;
	}
	pTexture = pTextureCache->addImage(utility::toString("head/", kFile.c_str()));
	if (pTexture)
	{
		return pTexture;
	}
	
	std::string kImagicName = DownImagicGetFileName(kFile);
	kImagicName = FileUtils::getInstance()->getWritablePath()+kImagicName;
	std::string StrSavePath = kImagicName;
	pTexture = pTextureCache->addImage(StrSavePath.c_str());
	if (pTexture)
	{
		return pTexture;
	}
	return NULL;
}
void ImagicDownManager::addDown(Node* pNode, std::string kUrl, int iUserID, bool isWeixinHead /*= true*/, bool bSameSize /*= true*/, bool bCircle/* = false*/)
{
	if (kUrl.size() <= 0) return;

	int iIdex = 0;
	for (int i = 0;i<kUrl.size();i++)
	{
		iIdex += kUrl[i];
	}

	if (isWeixinHead)
	{
		// replace trailing "/0" with "/132" for 132px thumbnail
		std::string strSrc = "/0";
		std::string strDes = "/132";
		if (kUrl.size() >= strSrc.size() &&
			kUrl.compare(kUrl.size() - strSrc.size(), strSrc.size(), strSrc) == 0)
		{
			kUrl.replace(kUrl.size() - strSrc.size(), strSrc.size(), strDes);
		}
	}

	std::string kFileName = utility::toString(iUserID,"Idex",iIdex);
	addDown(pNode, kUrl, kFileName, bSameSize, bCircle);
}

void ImagicDownManager::addDown(Node* pNode, std::string kUrl, std::string kFileName, bool bSameSize, bool bCircle/* = false*/)
{
	if (kUrl == "")
	{
		std::string strImagic = "Platform/lobby/imgHead.png";
		utility::setImagic(pNode, strImagic, bSameSize, bCircle);
		return;
	}

	Sprite* pSprite = dynamic_cast<Sprite*>(pNode);
	Menu* pButtonSprite = dynamic_cast<Menu*>(pNode);
	ui::ImageView* pImageView = dynamic_cast<ui::ImageView*>(pNode);

	if (!pSprite && !pButtonSprite && !pImageView)
	{
		CCASSERT(false,"");
		return;
	}
	kFileName = FileUtils::getInstance()->getWritablePath()+kFileName+".png";
	std::string StrSavePath = kFileName;
	if (Director::getInstance()->getTextureCache()->addImage(StrSavePath.c_str()))
	{
		if (pSprite)
		{
			utility::setImagic(pSprite,StrSavePath,bSameSize, bCircle);
		}
		if (pButtonSprite)
		{
			//utility::setButtonImagic(pButtonSprite,StrSavePath,StrSavePath,StrSavePath);
		}
		if (pImageView)
		{
			utility::setImagic(pImageView, StrSavePath, bSameSize, bCircle);
		}
		return;
	}
	bool bHaveGet = false;
	for (int i = 0;i<(int)m_pDownList.size();i++)
	{
		ImagicDownInfo& kInfo = m_pDownList[i];
		if (kInfo.kImagicName == kFileName && kInfo.pSprite == pSprite)
		{
			return;
		}
		if (kInfo.kImagicName == kFileName)
		{
			bHaveGet = true;
		}
		
	}
	ImagicDownInfo kInfo;
	kInfo.pSprite = pSprite;
	kInfo.pButtonSprite = pButtonSprite;
	kInfo.kImagicName = kFileName;
	kInfo.kUrl = kUrl;
	kInfo.bSameSize = bSameSize;
	kInfo.bCircle = bCircle;
	if (pSprite)
	{
		pSprite->retain();
	}
	if (pButtonSprite)
	{
		pButtonSprite->retain();
	}

	if (!bHaveGet)
	{
		HttpRequest* pRequest = CWebReq::getInstance().getFileEx(kUrl, CC_CALLBACK_2(ImagicDownManager::GetImagic, this));
		kInfo.pRequest = pRequest;
	}
	m_pDownList.push_back(kInfo);
}
void ImagicDownManager::upTime(float fTime)
{
	OnImagic();
	ImagicDownInfoList::iterator itor = m_pDownList.begin();
	while(itor != m_pDownList.end())
	{
		ImagicDownInfo& kInfo = *itor;
		kInfo.fActTime += fTime;
		if (kInfo.fActTime > 20.0f)
		{
			if (kInfo.pSprite)
			{
				kInfo.pSprite->release();
			}
			if (kInfo.pButtonSprite)
			{
				kInfo.pButtonSprite->release();
			}
			itor = m_pDownList.erase(itor);
		}
		else
		{
			itor++;
		}
	}
}