#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 = appConfig.getIntProperty("redis_port");
    m_redis = redisConnectWithTimeout(ip.c_str(), port, timeout);//建立连接
    if (m_redis->err) {

        DBG("RedisTool : Connection error: %s" << m_redis->errstr);
        redisFree(m_redis);
        m_redis = nullptr;
    } 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;
}

bool HiredisTool::setKeyImage(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::move(m_base64.Encode(buf.data(), buf.size()));
//    json["img"] = std::string(buf.begin(), buf.end());
    //    buf.clear();
//    std::string strBuf=std::string(buf.begin(),buf.end());
    if (!setKeyValue(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;
}


void HiredisTool::getKeyImage(const std::string &imageName, cv::Mat &img) {

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

    getKeyValue(imageName, content);

    Json::Reader reader;
    Json::Value value;

    if (!reader.parse(content, value)) {
        return;
    }

    std::string str = value["img"].asString();
    str = std::move(m_base64.Decode(str.c_str(), str.size()));
    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::setKeyValue(const std::string &key, const std::string &value) {
    if (!checkParam()) {
        return false;
    }
    redisReply *reply;

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

    freeReplyObject(reply);

    return true;
}

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

    if (!checkResult(reply)) {
        return false;
    }
    if (reply->type == REDIS_REPLY_STRING) {
        value = reply->str;
    }
    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) {
        if (m_redis) {
            redisFree(m_redis);
            m_redis = nullptr;
        }
        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;
}