/**
@file			JCFileResManager.cpp
@brief
@author			James
@version		1.0
@date			2016_5_11
*/

#include "JCFileResManager.h"
#include "../downloadCache/JCServerFileCache.h"
#include "../downloadCache/JCFileTable.h"
#include "../misc/JCWorkerThread.h"
#include "../util/JCCommonMethod.h"
#include "../util/Log.h"
#include "../util/JCLayaUrl.h"
#include "../fileSystem/JCFileSystem.h"
#include "../downloadMgr/JCCurlWrap.h"
//#include "../misc/conchDebugThread.h"
#include <algorithm>
#include "../downloadMgr/JCDownloadMgr.h"
#include "../util/JCCrypto.h"
#include "../util/JCIThreadCmdMgr.h"
#include "../downloadMgr/JCHttpHeader.h"

namespace laya
{
    HandleFileData gHandleDataFunc = nullptr;

    char* _conch_mallocData(int len) {
        return new char[len];
    }

    void setFileDataHandler(HandleFileData h) {
        gHandleDataFunc = h;
    }
    char* tttt(const char* data, int& len) {
        //test setFileDataHandler
        char* pd = _conch_mallocData(len);
        memcpy(pd, data, len);
        return pd;
    }

    std::string JCFileRes::s_strUploadChkErrUrl = "";
    bool JCFileRes::s_bHasIgnoreChksum = false;
    std::vector<std::string>	JCFileRes::s_vIgnoreChksumError;
    std::mutex	JCFileRes::s_ignorechklock;
    std::string JCFileRes::s_strExtVersion;
    JCFileRes::JCFileRes(JCDownloadMgr* pNetLoader, JCFileResManager* pMgr)
    {
        m_nLastAction = INIT;
        m_nLength = 0;
        m_nLocalFileID = 0;
        m_bDownloading = false;
        m_CallbackRef.reset(new int(1));
        m_bIgnoreError = false;
        m_bSendToJS_complete = false;
        m_pNetLoader = pNetLoader;
        m_pMgr = pMgr;
    }

    JCFileRes::~JCFileRes() {
        m_pBuffer.reset((char*)0);
        m_CallbackRef.reset();
    }

    void JCFileRes::normalizeUrl() {
        bool bToLower = m_pMgr ? m_pMgr->m_bUrlToLowerCase : false;
        if (m_Url.m_nProto == JCUrl::file) {
            std::string ret = m_Url.m_strPath + "/" + m_Url.m_vPath[m_Url.m_vPath.size() - 1];
            if (bToLower)
                UTF8ToLowercase((char*)ret.c_str());
            m_strURL = ret;
            return ;
        }
        std::string file = m_Url.m_vPath.size() > 0 ? m_Url.m_vPath[m_Url.m_vPath.size() - 1] : "";
        std::string attFile = file.length() > 0 ? ("/" + file) : "/";
        std::string& query = m_Url.m_Query;
        std::string attQuery = query.length() > 0 ? (query) : "";
        std::string ret = m_Url.m_strPath + attFile;
        if (bToLower)
            UTF8ToLowercase((char*)ret.c_str());
        ret += attQuery;
        m_strURL = ret;
    }

    void JCFileRes::load(const char* p_pszURL, JCSharedBuffer* pSyncResult) {
        if (!p_pszURL)
            return;
        std::weak_ptr<int> wptr(m_CallbackRef);
        m_Url.parse(p_pszURL);
        normalizeUrl();
        //bool bToLower = m_pMgr ? m_pMgr->m_bUrlToLowerCase : false;
        //m_strURL = normalizePath(p_pszURL, bToLower, nProto);
        //判断是否是file://
        if (m_Url.m_nProto == JCUrl::file) {
            std::weak_ptr<int> wptr(m_CallbackRef);
            const char* pPath = m_strURL.c_str() + strlen("file://");
            if (pPath[2] == ':') {
                pPath += 1;
            }
            JCBuffer buf;
            bool bret = readFileSync(pPath, buf);
            if (bret && buf.m_pPtr) {
                //如果本地打开成功，则可以立刻设置回调，因为是在一个线程
                //这么写可以做到立即回调，相当于同步函数。这样即使没有缓存也可以应付 JsAppCache::loadCachedURL 的要求。
                m_pBuffer.reset(new char[buf.m_nLen]);
                memcpy(m_pBuffer.get(), buf.m_pPtr, buf.m_nLen);
                m_nLength = buf.m_nLen;
                //hugao add
                checkIsEncrypted(m_pBuffer.get(), m_nLength);
                if (gHandleDataFunc) {
                    int nNewlen = m_nLength;
                    char* pNewData = gHandleDataFunc(m_pBuffer.get(), nNewlen);
                    if (pNewData ) {
                        m_nLength = nNewlen;
                        m_pBuffer.reset(pNewData);
                    }
                }
                setState(ready);
                if (pSyncResult) {
                    pSyncResult->m_pBuffer = m_pBuffer;
                    pSyncResult->m_nLen = m_nLength;
                }
                //立即失效。如果再有相同请求，需要重新加载
                m_pBuffer.reset((char*)0);	//TODO 测试：这个不一定会导致释放
                m_nLength = 0;
                setState(freed);
            }
            else {
                onDownloadError(1, 0, wptr);
            }
            return;
        }
        unsigned int chksum = 0;
        //再尝试从缓存中取
        JCSharedBuffer buff;
        bool needDownload = true;
        JCServerFileCache* pSvFileCache = m_pMgr->m_pFileCache;
        if (pSvFileCache) {
            std::string strQuery = m_Url.m_Query;
            std::string& extV = s_strExtVersion;
            if (strQuery.length() > 1) {
                if ( extV.length()>0 &&
                        strQuery.length() > extV.length() && 
                        memcmp(strQuery.c_str() + 1, extV.c_str(), extV.length()) == 0 && 
                        strQuery.find('&') == std::string::npos) {
                    m_bExtVersion = true;
                    //符合版本号的规则。这时候，只计算文件本身，？后面的都不算
                    std::string fullfile = m_Url.m_strPath + "/" + m_Url.m_vPath[m_Url.m_vPath.size() - 1];
                    m_nLocalFileID = pSvFileCache->getFileID(fullfile.c_str());

                    const char* pExtV = strQuery.c_str() + 1 + extV.length(); 
                    //不管是不是0都要计算真正的hash值，因为可能资源中没有，需要下载，需要缓存
                    m_nExtVersionID = JCCachedFileSys::hashRaw(pExtV);
                    if (*pExtV == '0'&& *(pExtV+1)==0) {
                        //版本为0的特殊处理
                        //前提是肯定有dcc？
                        pSvFileCache->getFileInfo(m_nLocalFileID, chksum);
                        needDownload = !pSvFileCache->load(m_nLocalFileID, chksum, buff,false,true);
                    }
                    else {
                        JCCachedFileSys::typeChkSum tcs = (JCCachedFileSys::typeChkSum)m_nExtVersionID;
                        needDownload = !pSvFileCache->load(m_nLocalFileID, tcs, buff,true,true);
                    }
                }
                else {
                    //不是外部版本控制，
                    //20170821 ?? 这个要走缓存么？ 已经忘了为什么这么写了。
                    // m_strURL是完整的带？的，如果缓存中通过某种方法加了这种地址，应该也允许缓存
                    m_nLocalFileID = pSvFileCache->getFileID(m_strURL.c_str());
                    JCCachedFileSys::typeChkSum tcs = 0;
                    needDownload = !pSvFileCache->load(m_nLocalFileID, tcs, buff, false,true);
                }
            }
            else {
                //没有？,可以用dcc
                m_nLocalFileID = pSvFileCache->getFileID(m_strURL.c_str());// hashURLFull(m_strURL.c_str());
                pSvFileCache->getFileInfo(m_nLocalFileID, chksum);
                needDownload = !pSvFileCache->load(m_nLocalFileID, chksum, buff,false,true);
            }
        }

        if (needDownload) {
            if (m_bDownloading)
                return;

            //注意不能是p_pszURL。因为不可靠。如果是p_pszURL就是m_strURL获得的，则在 m_strURL = normalizePath
            //的时候，会导致p_pszURL被释放。
            m_bDownloading = true;
            if (chksum != 0) {
                char chkbuf[64] = { 0 };
                sprintf(chkbuf, "%x", chksum);
                std::string cdnfriendUrl = m_strURL + "?" + chkbuf;
                verifyDownload(cdnfriendUrl.c_str(), chksum);
            }
            else {
                verifyDownload(m_strURL.c_str(), chksum);
            }
            goto end;
        }
    //loadok:
        {
            m_nLastAction = LOADFROMCACHE;
            //如果本地打开成功，则可以立刻设置回调，因为是在一个线程
            m_pBuffer = buff.m_pBuffer;
            m_nLength = buff.m_nLen;
            if (pSyncResult) {
                pSyncResult->m_pBuffer = buff.m_pBuffer;
                pSyncResult->m_nLen = m_nLength;
            }
            //转到js线程执行setState。不要同步了，保持与浏览器一致。
            if (m_pMgr->m_pCmdPoster) {
                if (!m_bSendToJS_complete) {
                    m_bSendToJS_complete = true;	//这里肯定是js线程，可以处理这个标志
                    std::function<void()> cb = std::bind(&JCFileRes::onResDownloadOK_JSThread, this, wptr);
                    m_pMgr->m_pCmdPoster->postToJS(cb);
                }
            }
            else {
                onResDownloadOK_JSThread(wptr);
            }
        }
    end:
        int a = 0;
    }

    bool JCFileRes::loadFromCache(JCBuffer& buff, bool bDoCheckSum) {
        JCUrl url;
        url.parse(m_strURL.c_str());
        if (url.m_nProto == JCUrl::file) {
            char* pFile = (char*)m_strURL.c_str();
            if (strstr(m_strURL.c_str(), "file:///") == pFile) {
                if (pFile[9] == ':') {
                    pFile += 8;
                }
                else {
                    pFile += 7;
                }
            }
            return readFileSync(pFile, buff);
        }

        if (m_bDownloading)
            return false;
        if (!m_pMgr || !m_pMgr->m_pFileCache)
            return false;
        if (bDoCheckSum && m_bExtVersion) {
            JCSharedBuffer _buff;
            JCCachedFileSys::typeChkSum tcs = (JCCachedFileSys::typeChkSum)m_nExtVersionID;
            if (m_pMgr->m_pFileCache->load(m_nLocalFileID, tcs, _buff, true, true)) {
                if (_buff.m_pBuffer.get()) {
                    buff.create(_buff.m_nLen);
                    memcpy(buff.m_pPtr, _buff.m_pBuffer.get(), _buff.m_nLen);
                    return true;
                }
            }
            return false;
        }
        return m_pMgr->m_pFileCache->load(m_nLocalFileID, buff, bDoCheckSum);
    }

    bool JCFileRes::checkIsEncrypted(char *buf, int len){
#ifndef THIN_COMMON_WITHOUT_DOWNLOAD
        bool temp = JCEncrypt::decrypt(buf, len);
        if (temp)m_nLength = len - JCEncrypt::s_nPreLen;
        return temp;
#else
        return false;
#endif
    }

    void JCFileRes::verifyDownload(const char* p_pszURL, unsigned int p_nChkSum) {
        m_nLastAction = DOWNLOADING;
        JCDownloadMgr* pNetLoader = m_pNetLoader;
        std::weak_ptr<int> wptr(m_CallbackRef);
        pNetLoader->download(p_pszURL, 0,
            std::bind(&JCFileRes::onProgress, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, wptr),
            std::bind(&JCFileRes::onDownloaded, this, 
                std::placeholders::_1, 
                std::placeholders::_2, 
                std::placeholders::_3, 
                std::placeholders::_4,
                std::placeholders::_5,
                std::placeholders::_6,
                p_nChkSum, 1, wptr), m_nOptTimeout, m_nConnTimeout);
    }

    void JCFileRes::onResDownloadOK_JSThread(std::weak_ptr<int> p_cbref) {
        if (!p_cbref.lock())
            return;
        if (m_nLength == 0)	//如果已经为0了，则表示已经处理的，状态改变已经通知给需要的人了，直接返回。
            return;
        //hugao add
        checkIsEncrypted(m_pBuffer.get(), m_nLength);
        if (gHandleDataFunc) {
            int nNewlen = m_nLength;
            char* pNewData = gHandleDataFunc(m_pBuffer.get(), nNewlen);
            if (pNewData) {
                m_nLength = nNewlen;
                m_pBuffer.reset(pNewData);
            }
        }
        setState(ready);
        //立即失效。如果再有相同请求，需要重新加载
        m_pBuffer.reset((char*)0);	//TODO 测试：这个不一定会导致释放
        m_nLength = 0;
        setState(freed);
        m_bSendToJS_complete = false;	//处理完了，可以继续post了。
    }

    void JCFileRes::notifyErrorHandler(int p_nError, int p_nHttpResponse) {
        if (!m_bIgnoreError) {
        }
    }

    void JCFileRes::onResDownloadErr_JSThread(std::weak_ptr<int> p_cbref, int p_nError, int p_nHttpResponse) {
        if (!p_cbref.lock())
            return;
        //mnErrNo = downloadError;
        m_bDownloading = false;
        m_nErrNo = p_nError;
        m_nLastHttpResponse = p_nHttpResponse;
        setState(error);
        //立即失效。如果再有相同请求，需要重新加载
        m_pBuffer.reset((char*)0);	//TODO 测试：这个不一定会导致释放
        m_nLength = 0;
        //setState(freed);	不应该再设置成freed，应该保留error，否则再次设置 setOnErrorCB的话
    }

    inline bool _MaybeAnImg(const char* pBuff, int nLen) {
        if (pBuff && nLen > 4) {
            static int jpegID = 0x00ffd8ff;	//最高位00那个位置不一定是什么
            static int gifID = 0x38464947;
            static int pngID = 0x474e5089;

            int idval = *(int*)pBuff;
            return (idval == pngID || idval == gifID || (idval & 0xffffff) == jpegID);
        }
        return false;
    }

    inline bool _StrInVec(const char* pStr, std::vector<std::string>& vec) {
        for (int ei = 0, sz = vec.size(); ei < sz; ei++) {
            if (vec[ei] == pStr) {
                return true;
            }
        }
        return false;
    }

    void JCFileRes::onDownloaded(JCBuffer& p_Buff,
        const string& pLocalAddr, const string& pSvAddr,
        int pnCurlRet, int pnHttpRet,
        const string& pstrHeader,
        unsigned int p_nChkSum,
        int p_nDownloadNum, std::weak_ptr<int> p_cbref) {
        //用这种方式并不可靠，当多线程的时候，可能在这时候还有效，执行完这句就被删除了。
        if (!p_cbref.lock())
            return;
        m_nLastAction = DOWNLOADED;
        m_strSvIP = pSvAddr;
        LOGI("Downloaded %s@%s s=%x l=%d", m_strURL.c_str(), pSvAddr.c_str(), p_nChkSum, p_Buff.m_nLen);
        bool chkErr = false;
        JCServerFileCache* pSvFileCache = nullptr;
        if (pnCurlRet == CURLE_OK && pnHttpRet >= 200 && pnHttpRet < 300) {
            //如果什么都没有返回，则不用继续处理了
            if (p_Buff.m_pPtr == NULL || p_Buff.m_nLen == 0)
                goto end;
            pSvFileCache = m_pMgr->m_pFileCache;
            if (pSvFileCache) {
                if (p_nChkSum > 0) {
                    unsigned int downchk = JCCachedFileSys::getChkSum(p_Buff.m_pPtr, p_Buff.m_nLen);
                    if (downchk != p_nChkSum) {
                        //校验没有通过。
                        if (s_strUploadChkErrUrl.length() > 0) {
                            //上传一次。注意这里必须是在下载线程，以免造成卡顿
                            JCDownloadMgr* pNetLoader = m_pNetLoader;
                            if (pNetLoader) {
                                char postbuf[1024];
                                sprintf(postbuf, "%s,%s,%08x,%08x,%d,%s",
                                    pLocalAddr.c_str(),
                                    pSvAddr.c_str(),
                                    downchk,	//实际
                                    p_nChkSum,	//应该
                                    p_Buff.m_nLen,//长度
                                    m_strURL.c_str());//url
                                pNetLoader->postData(s_strUploadChkErrUrl.c_str(),
                                    postbuf, strlen(postbuf), JCDownloadMgr::defCompleteFunc
                                    );
                            }
                        }
                        //这时候，只能算作临时文件
                        chkErr = true;
                        goto updatecache;
                    }
                }
                goto updatecache;    //
            }
            //如果没有appcache也要通知onok
            //转到js线程执行setState。
            m_pBuffer = std::shared_ptr<char>(new char[p_Buff.m_nLen], std::default_delete<char[]>());
            memcpy(m_pBuffer.get(), p_Buff.m_pPtr, p_Buff.m_nLen);
            m_nLength = p_Buff.m_nLen;
            std::weak_ptr<int> wptr(m_CallbackRef);
            if (m_pMgr->m_pCmdPoster) {
                std::function<void()> cb = std::bind(&JCFileRes::onResDownloadOK_JSThread, this, wptr);
                m_pMgr->m_pCmdPoster->postToJS(cb);
            }
            else {
                onResDownloadOK_JSThread(wptr);
            }
            goto end;
        }
        else {
            //error
            std::weak_ptr<int> wptr(m_CallbackRef);
            onDownloadError(pnCurlRet, pnHttpRet, wptr);
            goto end;
        }

    updatecache:{
            std::string ext = getLowercaseExtOfUrl(m_strURL.c_str());
            m_pBuffer = std::shared_ptr<char>(new char[p_Buff.m_nLen], std::default_delete<char[]>());
            memcpy(m_pBuffer.get(), p_Buff.m_pPtr, p_Buff.m_nLen);
            m_nLength = p_Buff.m_nLen;
            std::weak_ptr<int> wptr(m_CallbackRef);
            //需要更新缓存。
            bool bNeedSave = false;
            if (m_bExtVersion || (p_nChkSum != 0 && !chkErr)) {
                //长期保存
                std::string strLocalFile = pSvFileCache->updateAFile(m_nLocalFileID,
                    m_pBuffer.get(), p_Buff.m_nLen,
                    m_bExtVersion ? m_nExtVersionID : p_nChkSum,
                    m_bExtVersion,
                    0,0);
            }
            else if (_MaybeAnImg(p_Buff.m_pPtr, p_Buff.m_nLen) || 
                _StrInVec(ext.c_str(), m_pMgr->m_vExtNeedSave) ||
                chkErr ) {
                //临时保存。进程内不允许删除
                JCHttpHeader hh(pstrHeader.c_str());
                //hh.getCacheContrl()
                //TODO 计算过期时间
                std::string strLocalFile = pSvFileCache->updateAFile(m_nLocalFileID,
                    m_pBuffer.get(), p_Buff.m_nLen,
                    0,
                    0,
                    0, 1);
            }
            else {
                //临时保存，进程内可以删除
                //TODO  需要实现临时缓存的管理
                /*
                std::string strLocalFile = pSvFileCache->updateAFile(m_nLocalFileID,
                    m_pBuffer.get(), p_Buff.m_nLen,
                    m_bExtVersion ? m_nExtVersionID : p_nChkSum,
                    m_bExtVersion,
                    0, 0);
                */
            }
            m_nLastAction = UPDATECACHE;

            //转到js线程执行setState。
            if (m_pMgr->m_pCmdPoster) {
                std::function<void()> cb = std::bind(&JCFileRes::onResDownloadOK_JSThread, this, wptr);
                m_pMgr->m_pCmdPoster->postToJS(cb);
            }
            else {
                onResDownloadOK_JSThread(wptr);
            }
        }
    //nocache:
        //int b = 0;
    end:
        //int c = 0;

        m_bDownloading = false;
    }

    //问题：这个可能是在另外的线程调用的
    void JCFileRes::onDownloadedOld(JCBuffer& p_Buff, 
            const string& pLocalAddr, const string& pSvAddr, 
            int pnCurlRet, int pnHttpRet,
            const string& pstrHeader,
            unsigned int p_nChkSum, 
            int p_nDownloadNum, std::weak_ptr<int> p_cbref) {
        //用这种方式并不可靠，当多线程的时候，可能在这时候还有效，执行完这句就被删除了。
        if (!p_cbref.lock())
            return;
        m_nLastAction = DOWNLOADED;
        m_strSvIP = pSvAddr;
        LOGI("Downloaded %s@%s s=%x l=%d", m_strURL.c_str(), pSvAddr.c_str(), p_nChkSum, p_Buff.m_nLen);
        bool downError = (p_Buff.m_pPtr == NULL || p_Buff.m_nLen == 0);
        std::string ext = getLowercaseExtOfUrl(m_strURL.c_str());
        JCServerFileCache* pSvFileCache = m_pMgr->m_pFileCache;
        if (!downError) {
            //先写到fileCache中。这时候还不是js线程，这里写是为了不影响js线程的效率。
            //问题是可能导致load和写cache不在一个线程。这个可能问题不大
            //如果非要一个线程，则这里不要调用，通过 setOnReadyCB( std::bind(&svFileCache::onFileDownloaded, pSvFileCache, std::placeholders::_1, chksum)) 的方法在js线程中执行
            bool chkok = p_nChkSum == 0;
            if (p_nChkSum) {
                unsigned int downchk = 0;
                //如果是文本文件，把\r\n统一换成\n再进行校验，以绕开各个环节的转换
                downchk = JCCachedFileSys::getChkSum(p_Buff.m_pPtr, p_Buff.m_nLen);
                chkok = (downchk == p_nChkSum);
                if (!chkok && checkIgnoreChksum((char*)ext.c_str())) {
                    LOGW("[%s@%s]Check error,but you can ignore,real:%08x,should be:%08x,loc=%s\n", m_strURL.c_str(), pSvAddr.c_str(),
                        downchk, p_nChkSum, pLocalAddr.c_str());
                    //errorflog("[%s@%s]校验错误，但忽略，实%08x,应 %08x,loc=%s\n", m_strURL.c_str(), p_pCurl->m_strSvAddr.c_str(), downchk, p_nChkSum,	p_pCurl->m_strLocalAddr.c_str());
                    chkok = true;	//算作正确
                    //上传一次
                    if (s_strUploadChkErrUrl.length() > 0) {
                        //上传一次。注意这里必须是在下载线程，以免造成卡顿
                        JCDownloadMgr* pNetLoader = m_pNetLoader;
                        if (pNetLoader) {
                            char postbuf[1024];
                            sprintf(postbuf, "%s,%s,%08x,%08x,%d,%s",
                                pLocalAddr.c_str(),
                                pSvAddr.c_str(),
                                downchk,	//实际
                                p_nChkSum,	//应该
                                p_Buff.m_nLen,//长度
                                m_strURL.c_str());//url
                            pNetLoader->postData(s_strUploadChkErrUrl.c_str(), 
                                postbuf, strlen(postbuf), JCDownloadMgr::defCompleteFunc
                                );
                        }
                    }
                }
                if (!chkok) {
                    LOGW("[%s@%s]check error,real:%08x,should be:%08x,loc=%s\n", m_strURL.c_str(), pSvAddr.c_str(), downchk, 
                        p_nChkSum, pLocalAddr.c_str());
                    //errorflog("[%s@%s]校验错误，实%08x,应 %08x,loc=%s\n", m_strURL.c_str(), p_pCurl->m_strSvAddr.c_str(), downchk, p_nChkSum,	p_pCurl->m_strLocalAddr.c_str());
                    if (p_nDownloadNum >= MAXDOWNLOADTRY && s_strUploadChkErrUrl.length() > 0) {
                        //上传一次。注意这里必须是在下载线程，以免造成卡顿
                        JCDownloadMgr* pNetLoader = m_pNetLoader;
                        if (pNetLoader) {
                            char postbuf[1024];
                            sprintf(postbuf, "%s,%s,%08x,%08x,%d,%s",
                                pLocalAddr.c_str(),
                                pSvAddr.c_str(),
                                downchk,	//实际
                                p_nChkSum,	//应该
                                p_Buff.m_nLen,//长度
                                m_strURL.c_str());//url
                            pNetLoader->postData(s_strUploadChkErrUrl.c_str(), postbuf, strlen(postbuf), 
                                JCDownloadMgr::defCompleteFunc
                                );
                        }
                    }
                }
            }
            if (!chkok && p_nDownloadNum < MAXDOWNLOADTRY) {
                //继续下载
                LOGI("再次尝试下载");
                JCDownloadMgr* pNetLoader = m_pNetLoader;
                std::weak_ptr<int> wptr(m_CallbackRef);
                pNetLoader->download(m_strURL.c_str(), 0,
                    std::bind(&JCFileRes::onProgress, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, wptr),
                    std::bind(&JCFileRes::onDownloaded, this, 
                        std::placeholders::_1, 
                        std::placeholders::_2, 
                        std::placeholders::_3, 
                        std::placeholders::_4,
                        std::placeholders::_5,
                        std::placeholders::_6,
                        p_nChkSum, ++p_nDownloadNum, wptr),
                    0);
                return;
            }
            downError = !chkok;
            if (!chkok && s_strUploadChkErrUrl.length() <= 0) {//如果有上传地址，就不再需要提示了
                //JCErrorHandleInterface* pEH = getErrorHandler();
                //if(pEH){
                //	pEH->download_chkSumVerifyError(m_strURL.c_str());
                //}
            }
        }

        //下载的数据先copy一份，使用完了之后，立即删除
        //即使校验错误，也算作正确的。
        if (!downError || p_nDownloadNum > 2) {
            //注意：这里并没有复制buffer，外部使用者需要自己复制。
            m_pBuffer = std::shared_ptr<char>(new char[p_Buff.m_nLen],std::default_delete<char[]>());
            memcpy(m_pBuffer.get(), p_Buff.m_pPtr, p_Buff.m_nLen);
            m_nLength = p_Buff.m_nLen;
            std::weak_ptr<int> wptr(m_CallbackRef);

            //如果是缓存文件。需要更新缓存。
            bool bNeedSave = false;
            if (p_nChkSum) {
                bNeedSave = p_nDownloadNum <= 1;
            }
            else {
                //如果是图片文件要恢复
                if (p_Buff.m_pPtr && p_Buff.m_nLen > 4) {
                    static int jpegID = 0x00ffd8ff;	//最高位00那个位置不一定是什么
                    static int gifID = 0x38464947;
                    static int pngID = 0x474e5089;

                    int idval = *(int*)p_Buff.m_pPtr;
                    if (idval == pngID || idval == gifID || (idval & 0xffffff) == jpegID)
                        bNeedSave = true;
                }
                //如果是外部版本管理，需要保存
                if (!bNeedSave) {

                }
                if (!bNeedSave) {
                    //如果是需要同步恢复的资源文件，就要缓存
                    for (int ei = 0, sz = m_pMgr->m_vExtNeedSave.size(); ei < sz; ei++) {
                        if (m_pMgr->m_vExtNeedSave[ei] == ext) {
                            bNeedSave = true;
                            break;
                        }
                    }
                }
            }
            if (bNeedSave){
                std::string strLocalFile = pSvFileCache->updateAFile(
                    m_nLocalFileID, m_pBuffer.get(), p_Buff.m_nLen,
                    p_nChkSum, 0, 0, 0);
                if (strLocalFile.length() > 0) {
                    m_nLastAction = UPDATECACHE;
                }
            }

            //转到js线程执行setState。
            if (m_pMgr->m_pCmdPoster) {
                std::function<void()> cb = std::bind(&JCFileRes::onResDownloadOK_JSThread, this, wptr);
                m_pMgr->m_pCmdPoster->postToJS(cb);
            }
            else {
                onResDownloadOK_JSThread(wptr);
            }
        }
        else {
            m_pBuffer.reset((char*)0);
            m_nLength = 0;
            //notifyErrorHandler(Curl::EC_PartialFile, 0);	//校验错误的responsecode只能0了
            std::weak_ptr<int> wptr(m_CallbackRef);
            if (m_pMgr->m_pCmdPoster) {
                //转到js线程执行setState。
                std::function<void()> cb = std::bind(&JCFileRes::onResDownloadErr_JSThread, 
                    this, wptr, -1, 0);
                m_pMgr->m_pCmdPoster->postToJS (cb);
            }
            else {
                onResDownloadErr_JSThread(wptr, -1, 0);
            }
        }
        m_bDownloading = false;
    }

    bool JCFileRes::restoreRes() {
        load(m_strURL.c_str(),nullptr);
        return true;
    }

    void JCFileRes::onDownloadError(int p_nError, int p_nHttpResponse, std::weak_ptr<int> p_cbref) {
        //std::lock_guard<std::mutex> lock(m_pMgr->m_maplock);//要删除map，可能会与请求的时候冲突
        if (!p_cbref.lock())
            return;
        m_pBuffer.reset((char*)0);
        m_nLength = 0;

        if (!m_bIgnoreError) {
            LOGE("JCFileRes::onDownloadError file error[%d]:%s", p_nError, m_strURL.c_str());
            //errorflog("下载文件错误[%d]：%s",p_nError, m_strURL.c_str());
        }
        //m_pMgr->delRes(m_strURL.c_str());	到资源管理器中统一做
        //auto it = m_ResMap.find(m_strURL.c_str());
        notifyErrorHandler(p_nError, p_nHttpResponse);
        std::weak_ptr<int> wptr(m_CallbackRef);
        //转到js线程执行setState。
        if (m_pMgr->m_pCmdPoster) {
            std::function<void()> cb = std::bind(&JCFileRes::onResDownloadErr_JSThread, this, wptr, p_nError, p_nHttpResponse);
            m_pMgr->m_pCmdPoster->postToJS(cb);
        }
        else {
            onResDownloadErr_JSThread(wptr, p_nError, p_nHttpResponse);
        }
    }

    int JCFileRes::onProgress(unsigned int now, unsigned int total, float speed, std::weak_ptr<int> p_cbref) {
        return 0;
    }

    JCFileResManager::JCFileResManager(JCDownloadMgr* pDownloadMgr) {
        m_pFileCache = nullptr;
        m_pCmdPoster = nullptr;
        m_bUrlToLowerCase = false;
        m_vExtNeedSave = {".png",".jpg",".wav",".ogg"};
        m_pDownloadMgr = pDownloadMgr;
    }

    JCFileResManager::~JCFileResManager() {
        clear();
    }

    void JCFileResManager::clear() {
        std::lock_guard<std::mutex> lock(m_maplock);
        FileResMap::iterator it = m_ResMap.begin();
        FileResMap::iterator ed = m_ResMap.end();
        while (it != ed) {
            delete (*it).second;
            it++;
        }
        m_ResMap.clear();
    }

    //如果已经下载完了，应该同步去打开文件，不要再走下载了（在load中做了）
    JCFileRes* JCFileResManager::getRes(const std::string& url, int p_nConnTimeout , int p_nOptTimeout) {
        std::lock_guard<std::mutex> lock(m_maplock);//下面要添加资源，需要锁。因为失败的话会删除
        JCFileRes* pRes = NULL;
        FileResMap::iterator it = m_ResMap.find(url);
        if (it == m_ResMap.end()) {
            pRes = new JCFileRes(m_pDownloadMgr,this);
            if (p_nConnTimeout>0) {
                pRes->m_nConnTimeout = p_nConnTimeout;
            }
            if (p_nOptTimeout > 0) {
                pRes->m_nOptTimeout = p_nOptTimeout;
            }
            m_ResMap[url] = pRes;
            //问题：load和下载回调不在一个线程会有问题么？
            // 如果load不修改表和文件内容，下载回调在最后再设置ready，应该没事
            pRes->load(url.c_str(),nullptr);
            //m_pThread = workerThread::getCurThread();
            return pRes;
        }
        pRes = (*it).second;
        if (p_nConnTimeout>0) {
            pRes->m_nConnTimeout = p_nConnTimeout;
        }
        if (p_nOptTimeout > 0) {
            pRes->m_nOptTimeout = p_nOptTimeout;
        }

        return pRes;
    }



    bool JCFileResManager::delRes(const char* p_pszURL) {
        std::lock_guard<std::mutex> lock(m_maplock);
        auto it = m_ResMap.find(p_pszURL);
        if (it != m_ResMap.end()) {
            m_ResMap.erase(it);
            return true;
        }
        return false;
    }

    void JCFileRes::addChkIgnoreChksumExt(const char* p_pszExt) {
        s_bHasIgnoreChksum = true;
        std::string ext = p_pszExt;
        std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
        s_ignorechklock.lock();
        for (int i = 0, sz = s_vIgnoreChksumError.size(); i < sz; i++) {
            if (s_vIgnoreChksumError[i] == ext) {
                s_ignorechklock.unlock();
                return;
            }
        }
        s_vIgnoreChksumError.push_back(ext);
        s_ignorechklock.unlock();
    }

    void JCFileRes::clearChkIgnoreChksumExt() {
        s_bHasIgnoreChksum = false;
        s_ignorechklock.lock();
        s_vIgnoreChksumError.clear();
        s_ignorechklock.unlock();
    }

    bool JCFileRes::checkIgnoreChksum(char* p_pszExt) {
        if (!s_bHasIgnoreChksum)
            return false;
        std::string ext = p_pszExt;
        std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
        s_ignorechklock.lock();
        for (int i = 0, sz = s_vIgnoreChksumError.size(); i < sz; i++) {
            if (s_vIgnoreChksumError[i] == ext) {
                s_ignorechklock.unlock();
                return true;
            }
        }
        s_ignorechklock.unlock();
        return false;
    }
}
//------------------------------------------------------------------------------


//-----------------------------END FILE--------------------------------