#include "HiredisTool.h"
#include <vector>
#include<basic/util/opencv/CvUtil.h>
#include <jsoncpp/json/json.h>
#include <basic/debug/Debug.h>
#include <basic/util/app/AppConfig.h>
HiredisTool::HiredisTool():
m_redis(nullptr),
m_nImgListLen(0)
{
    init();
}
HiredisTool::~HiredisTool()
{
    if(m_redis != nullptr)
    {
        redisFree(m_redis);//析构函数释放资源
        DBG("~RedisTool :: free redis connection ") ;
    }

}

void HiredisTool::init()
{
       struct timeval timeout = { 1, 500000 }; // 1.5 seconds 设置连接等待时间

     //  m_nImgListLen=appConfig.getIntProperty("redis_buf_len");
       std::string ip=appConfig.getStringProperty("redis_ip");

       int port=6379;
        m_redis = redisConnectWithTimeout(ip.c_str(), port, timeout);//建立连接
        if (m_redis->err) {

           DBG("RedisTool : Connection error: %s"<< m_redis->errstr);
        }
        else
        {
                DBG( "init redis tool success " );

        }
}





//std::map<std::string,int> HiredisTool::findAllCamera()
//{
//     std::map<std::string,int> camIdMap;
//     if(!checkParam())
//     {
//         return camIdMap;
//     }

//     redisReply *reply;

//     reply = (redisReply*)redisCommand(m_redis,"hgetall %s", cam_key);

//     if(!checkResult(reply))
//     {
//         return camIdMap;
//     }
//     if(reply->type == REDIS_REPLY_ARRAY)
//     {
//         for (int i= 0; i < reply->elements; i+=2)
//         {
//             std::string key=reply->element[i]->str;
//             std::string value=reply->element[i+1]->str;
//             if(key.empty()||value.empty()) continue;
//             camIdMap.insert(std::pair<std::string,int>(key,atoi(value.c_str())));
//         }
//     }
//     freeReplyObject(reply);
//     return camIdMap;
//}






bool HiredisTool::pushImageBuf(const std::string& file_name,const cv::Mat& img)
{


       std::vector<uchar> buf;
      Json::Value json;

      CvUtil::cvMat2Buffer(img,buf);
//      json["time"]=info.time;
      json["img"]=std::string(buf.begin(),buf.end());
  //    buf.clear();
      std::string strBuf=std::string(buf.begin(),buf.end());
      if(!listLpush(file_name,json.toStyledString()));
      {

          return false;
      }

      //DBG(json.toStyledString());

      return true;
}

void  HiredisTool::getImage(const std::string& file_name, cv::Mat& img)
{


        std::string content;
        cv::Mat imgTep;


        listRpop(file_name,content);


        Json::Reader reader;
        Json::Value value;
        if(!reader.parse(content,value))
        {
           return ;
        }

        std::string str=value["img"].asString();
        std::vector<uchar> data;

        data.resize(str.size());
        data.assign(str.begin(),str.end());
        CvUtil::buffer2CvMat(data,imgTep);
     imgTep.copyTo(img);
    // return img;

}
//bool HiredisTool::setCameraState(const std::string& cam_id,const int& type)
//{
//    DBG("type="<<type);
//    return hashSet(file_list,cam_id,type);
//}
bool HiredisTool::clearAllImageBuf()
{
//    auto cam_map=findAllCamera();
//    for(auto cam:cam_map)
//    {
//        delKey(cam.first);
//    }
}
bool HiredisTool::listLpush(const std::string& key,const std::string& value)
{
    if(!checkParam())
    {
        return false;
    }
    redisReply *reply;

    reply = (redisReply*)redisCommand(m_redis,"lpush %s %s", key.c_str(),value.c_str());
    if(!checkResult(reply))
    {
        return false;
    }

    freeReplyObject(reply);

    return true;
}

bool HiredisTool::listRpop(const std::string& key,std::string& value)
{
    if(!checkParam())
    {
        return false;
    }
    redisReply *reply;
    //1.find all filename
    reply = (redisReply*)redisCommand(m_redis,"rpop %s  ", key.c_str());

    if(!checkResult(reply))
    {
        return false;
    }
    if(reply->type == REDIS_REPLY_STRING)
    {
        value=reply->str;
    }
    freeReplyObject(reply);

    return true;
}
bool HiredisTool::hashSet(const std::string& tab,const std::string& key,const int& value)
{
    if(!checkParam())
    {
        return false;
    }
    redisReply *reply;


    reply = (redisReply*)redisCommand(m_redis,"hset %s %s %d", tab.c_str(),key.c_str(),value);

    if(!checkResult(reply))
    {
        return false;
    }
    freeReplyObject(reply);


    return true;
}

int  HiredisTool::getSize(const std::string& key)
{
    int size=0;
    if(!checkParam())
    {
        return size;
    }
    redisReply *reply;

    reply = (redisReply*)redisCommand(m_redis,"llen %s", key.c_str());

    if(!checkResult(reply))
    {
        return size;
    }
    size=reply->integer;
    freeReplyObject(reply);
    return size;
}
bool HiredisTool::listLindex(const std::string& key,std::string& value)
{
    int size=0;
    if(!checkParam())
    {
        return size;
    }
    redisReply *reply;

    reply = (redisReply*)redisCommand(m_redis,"lindex %s -1", key.c_str());

    if(!checkResult(reply))
    {
        return false;
    }
    if(reply->type == REDIS_REPLY_STRING)
    {
        value=reply->str;
    }
    freeReplyObject(reply);
}
bool HiredisTool::delKey(const std::string& key)
{
    if(!checkParam())
    {
        return false;
    }
    redisReply *reply;

    reply = (redisReply*)redisCommand(m_redis,"del %s", key.c_str());


    if(!checkResult(reply))
    {
        return false;
    }
    freeReplyObject(reply);
    return true;
}
bool HiredisTool::checkParam()
{
     if(m_redis == nullptr || m_redis->err)
     {
         DBG("Redis init Error !!!");
         init();
         return false;
     }
     return true;
}
bool HiredisTool::checkResult(redisReply *reply)
{
    if (reply==nullptr)
    {
         DBG("reply nullptr !!!");
         return false;
    }

    if (reply->type == REDIS_REPLY_ERROR)
    {
        ERR("redisCommand Error: "<<reply->str);
        freeReplyObject(reply);
        return false;
    }
    return true;
}
void HiredisTool::addFileInfo(const std::string& filename,const int& file_status)
{

      hashSet(file_list,filename,file_status);
 }
std::queue<cv::Mat> HiredisTool::getImgQue(const std::string& filename)
{
    std::queue<cv::Mat> que;
    if(!checkParam())
    {
        return que;
    }
    redisReply *reply;

    reply = (redisReply*)redisCommand(m_redis,"lrange %s 0 -1", filename.c_str());

    if(!checkResult(reply))
    {
        return que;
    }
    if(reply->type == REDIS_REPLY_ARRAY)
    {
        for(int i=0;i<reply->elements;++i)
        {
            std::string str=reply->element[i]->str;
            std::vector<uchar> data;
            cv::Mat img;
            data.resize(str.size());
            data.assign(str.begin(),str.end());
            CvUtil::buffer2CvMat(data,img);
            que.push(img);
        }
    }
    freeReplyObject(reply);
}
std::map<std::string,int> HiredisTool::findAllFileStatus()
{
     std::map<std::string,int> fileMap;
     if(!checkParam())
     {
         return fileMap;
     }

     redisReply *reply;

     reply = (redisReply*)redisCommand(m_redis,"hgetall %s", file_list);

     if(!checkResult(reply))
     {
         return fileMap;
     }

     if(reply->type == REDIS_REPLY_ARRAY)
     {

         for (int i= 0; i < reply->elements; i+=2)
         {
             std::string key=reply->element[i]->str;
             std::string value=reply->element[i+1]->str;

             if(key.empty()||value.empty()) continue;

             fileMap.insert(std::pair<std::string,int>(key,atoi(value.c_str())));
         }
     }
     freeReplyObject(reply);
     return fileMap;
}
bool HiredisTool::hashDel(const std::string& tab,const std::string &key)
{
    if(!checkParam())
    {
        return false;
    }
    redisReply *reply;


    reply = (redisReply*)redisCommand(m_redis,"hdel %s %s", tab.c_str(),key.c_str());

    if(!checkResult(reply))
    {
        return false;
    }
    freeReplyObject(reply);


    return true;
}