/**
 * Tencent is pleased to support the open source community by making Tars available.
 *
 * Copyright (C) 2016THL A29 Limited, a Tencent company. All rights reserved.
 *
 * Licensed under the BSD 3-Clause License (the "License"); you may not use this file except 
 * in compliance with the License. You may obtain a copy of the License at
 *
 * https://opensource.org/licenses/BSD-3-Clause
 *
 * 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.
 */

#include <sys/stat.h>
#include <unistd.h>
#include "PatchCache.h"
#include "PatchServer.h"

using namespace tars;

int PatchCache::load(const std::string & sFile, std::pair<char *, size_t> & mem)
{
 TLOGDEBUG("PatchCache::load sFile:" << sFile << endl);

 struct MemState * cur = NULL;

 TC_ThreadLock::Lock lock(_mutex);
 
 try
 {
 struct stat st;
 memset(&st, 0, sizeof(struct stat));

 if (lstat(sFile.c_str(), &st) != 0)
 {
 TLOGERROR("PatchCache::load sFile:" << sFile << "|lstat file error:" << strerror(errno) << endl);
 return -1;
 }
 
 if ((size_t)st.st_size > _MemMax || (size_t)st.st_size < _MemMin)
 {
 TLOGERROR("PatchCache::load sFile:" << sFile << "|invalid file size must(" << _MemMax << ">" << st.st_size << "<" << _MemMin << ")" << endl);
 return -1;
 }

 //查看是否已经加载入内存
 std::map<std::string, struct MemState *>::iterator it = _mapFiles.find(sFile);
 if (it != _mapFiles.end())
 {
 cur = it->second;
 
 if ((cur->MemLoad == EM_LOADING || cur->MemLoad == EM_RELOAD))//错误都为1状态
 {
 TLOGERROR("PatchCache::load sFile:" << sFile << "|loading file now|MemLoad:" << cur->MemLoad << "|MemCount:" << cur->MemCount << "|FileName:" << cur->FileName << endl);

 //这里是由于内存分配不足,导致出现loading的状态
 _mapFiles.erase(sFile);

 return -1;
 }
 
 if (cur->FileSize == (size_t)st.st_size && cur->FileTime == st.st_mtime && cur->FileInode == st.st_ino)
 {
 mem.first = cur->MemBuf;
 mem.second = cur->FileSize;
 cur->MemTime = time(NULL);
 cur->MemCount++;

 TLOGDEBUG("PatchCache::load sFile:" << sFile << "|reuse file in mem" << endl);
 return 0;
 }
 else
 {
 cur->FileSize = st.st_size;
 cur->FileInode = st.st_ino;
 cur->FileTime = st.st_mtime;
 cur->MemLoad = EM_RELOAD;
 
 mem.first = cur->MemBuf;
 mem.second = st.st_size;
 
 TLOGDEBUG("PatchCache::load sFile:" << sFile << "|need reload file" << endl);
 }
 }
 else
 {
 if (__getMem(sFile, cur) == -1)
 {
 TLOGERROR("PatchCache::load sFile:" << sFile << "|get free mem fault" << endl);
 return -1;
 }

 cur->FileName = sFile;
 cur->FileSize = st.st_size;
 cur->FileInode = st.st_ino;
 cur->FileTime = st.st_mtime;

 mem.first = cur->MemBuf;
 mem.second = cur->FileSize;

 if (_mapFiles.find(sFile) == _mapFiles.end())
 {
 _mapFiles.insert(make_pair(sFile,cur));
 }
 }
 }
 catch (std::exception & ex)
 {
 TLOGERROR("PatchCache::load sFile:" << sFile << "|exception:" << ex.what() << endl);
 return -1;
 }
 catch (...)
 {
 TLOGERROR("PatchCache::load sFile:" << sFile << "|unknown Exception" << endl);
 return -1;
 }
 
 if (__loadFile(sFile, cur->MemBuf, cur->FileSize) == 0)
 {
 cur->MemCount++;
 cur->MemTime = time(NULL);
 cur->MemLoad = EM_LOADED;

 return 0;
 }
 else
 {
 cur->MemTime = 0;
 cur->MemLoad = EM_NLOAD;
 return -1;
 }

 return -1;
}

int PatchCache::release(const std::string & sFile)
{
 TLOGDEBUG("PatchCache::release sFile:" << sFile << endl);

 try
 {
 TC_ThreadLock::Lock lock(_mutex);
 
 std::map<std::string, MemState *>::iterator it = _mapFiles.find(sFile);
 if (it == _mapFiles.end())
 {
 TLOGERROR("PatchCache::release Find '" << sFile << "' fault" << endl);
 return -1;
 }

 it->second->MemCount--;
 
 TLOGDEBUG("PatchCache::release sFile:" << sFile << "|count:" << it->second->MemCount << endl);
 return 0;
 }
 catch (std::exception & ex)
 {
 TLOGERROR("PatchCache::release sFile:" << sFile << "|exception:" << ex.what() << endl);
 }
 catch (...)
 {
 TLOGERROR("PatchCache::release sFile:" << sFile << "|unknown Exception" << endl);
 }
 
 return -1;
}

int PatchCache::__getMem(const std::string & sFile, struct MemState *& cur)
{
 TLOGDEBUG("PatchCache::__getMem sFile:" << sFile << endl);

 cur = NULL;
 
 for (size_t i = 0; i < _vecMems.size(); i++)
 {
 struct MemState * st = _vecMems[i];

 TLOGDEBUG("PatchCache::__getMem sFile:" << sFile << "|MemLoad:"<<st->MemLoad << "|MemCount:" << st->MemCount << "|MemTime:" << st->MemTime << "|FileName:" << st->FileName << endl);

 if ((st->MemLoad == EM_NLOAD || st->MemLoad == EM_LOADED) && st->MemCount == 0 && st->MemTime + g_app.getExpireTime() <= time(NULL))
 {
 _mapFiles.erase(_vecMems[i]->FileName);

 cur = _vecMems[i];
 break;
 }
 }
 
 if (cur == NULL && _vecMems.size() < _MemNum)
 {
 cur = new MemState();
 cur->MemBuf = (char *)malloc(_MemMax);//从这里开始新建

 _vecMems.push_back(cur);

 _mapFiles.insert(std::make_pair(sFile, cur));
 }

 if (cur != NULL)
 {
 cur->MemCount = 0;
 cur->MemSize = _MemMax;
 cur->MemLoad = EM_LOADING;

 if (cur->MemBuf == NULL)//有可能内存分配失败
 {
 //从vector删除新的分配内存失败的元素
 _vecMems.erase(remove(_vecMems.begin(),_vecMems.end(),cur));

 TLOGERROR("PatchCache::__getMem sFile:" << sFile << "|cur->MemBuf NULL" << endl);

 return -1;
 }

 return 0;
 }

 TLOGERROR("PatchCache::__getMem sFile:" << sFile << "|not enough mem" << endl);

 return -1;
}

int PatchCache::__loadFile(const std::string & sFile, char * szBuff, size_t sizeLen)
{
 TLOGDEBUG("PatchCache::__loadFile sFile:" << sFile << "|sizeLen:" << sizeLen << endl);
 
 if(szBuff == NULL)
 {
 TLOGERROR("PatchCache::__loadFile sFile:" << sFile << "|sizeLen:" << sizeLen << "|szBuff NULL"<< endl);

 return -4;
 }

 FILE * fp = fopen(sFile.c_str(), "r");
 if (fp == NULL)
 {
 TLOGERROR("PatchCache::__loadFile sFile:" << sFile << "|sizeLen:" << sizeLen << "|open file error:" << strerror(errno) << endl);
 return -1;
 }
 
 //从指定位置开始读数据
 if (fseek(fp, 0, SEEK_SET) == -1)
 {
 fclose(fp);

 TLOGERROR("PatchCache::__loadFile sFile:" << sFile << "|sizeLen:" << sizeLen << "|fseek error:" << strerror(errno) << endl);
 return -2;
 }

 //开始读取文件
 size_t r = fread(szBuff, 1, sizeLen, fp);
 if (r > 0)
 {
 //成功读取r字节数据
 fclose(fp);
 TLOGDEBUG("PatchCache::__loadFile sFile:" << sFile << "|sizeLen:" << sizeLen << "|r:" << r << endl);
 return 0;
 }
 else
 {
 //到文件末尾了
 if (feof(fp))
 {
 fclose(fp);
 TLOGDEBUG("PatchCache::__loadFile sFile:" << sFile << "|sizeLen:" << sizeLen << "|to tail ok" << endl);
 return 1;
 }

 //读取文件出错了
 TLOGERROR("PatchCache::__loadFile sFile:" << sFile << "|sizeLen:" << sizeLen << "|r:" << r << "|error:" << strerror(errno) << endl);
 fclose(fp);
 return -3;
 }

}