//
// Created by ps on 18-11-29.
//

#include "ErlangDbTool.h"

#include <QtSql/QSql>
#include <QtSql/QSqlDatabase>
#include <QtSql/QSqlError>
#include <QtSql/QSqlQuery>
#include <QtCore/QString>
#include <QtCore/QDebug>
#include <QtCore/QVariantList>

using ErlangTool::map_DevDataCache;
using ErlangTool::map_TabDataCache;
using ErlangTool::map_BwDataCache;
using ErlangTool::map_FaceDataCache;


static QSqlDatabase g_syncDbFile = QSqlDatabase::addDatabase("QSQLITE", "SyncDBSqliteFile");


static bool ErlangTool::dir_file_exists(std::string dir, bool mkdir_flag) {
    int state = access(dir.c_str(), R_OK | W_OK); // 头文件 #include <unistd.h>
    if (state == 0) {
        //#todo
        INFO("file exist");
        return true;
    } else if (mkdir_flag) {
        dir = "mkdir -p " + dir;
        system(dir.c_str()); // 调用linux系统命令创建文件
        //#todo
        return true;
    } else {
        return false;
    }
}

static bool ErlangTool::pingNode(const std::string &nodeName, const std::string &cookie) {
    int fd = -1;
    int ret = -1;
//    erl_init(NULL, 0);
//    struct in_addr addr;
//    addr.s_addr = inet_addr("127.0.0.1");

//    std::string str_node("cnode");
//    str_node.append(to_string((int) getpid()));

//    std::string t_nodeName(str_node);
//    t_nodeName.append("@127.0.0.1");

//    INFO("str_node << " << str_node << " ;t_nodeName " << t_nodeName);

//    if (erl_connect_xinit(str_node.c_str(), str_node.c_str(), t_nodeName.c_str(), &addr, cookie.c_str(), 0) == -1) {
//        ERR("erl_connect_xinit error");
//        erl_err_quit("erl_connect_xinit");
//        return false;
//    }

    fd = erl_connect(const_cast<char *>(nodeName.c_str()));
    if (0 > fd) {
        erl_close_connection(fd);
        ERR("erl_connect error  " << nodeName);
//            erl_err_quit("erl_connect");
        return false;
    }
    erl_close_connection(fd);
    return true;
}

static int ErlangTool::checkETERMType(ETERM *elemen) {
    if (elemen == NULL) {
        return -1;
    }
    switch (ERL_TYPE(elemen)) {
        case ERL_UNDEF:
            return ERL_UNDEF;
        case ERL_INTEGER:
            INFO("value is a int: " << ERL_INT_VALUE(elemen));
            return ERL_INTEGER;
        case ERL_U_INTEGER:
            break;
        case ERL_ATOM: {
//                int atomSize = ERL_ATOM_SIZE(elemen);
//                char *atomValue = ERL_ATOM_PTR(elemen);
//                printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
            return ERL_ATOM;
        }
        case ERL_PID:
            break;
        case ERL_PORT:
            break;
        case ERL_REF:
            break;
        case ERL_LIST:
//                printf("value is a list:%s\n", erl_iolist_to_string(elemen));
            return ERL_LIST;
        case ERL_NIL:
            return ERL_EMPTY_LIST;
        case ERL_TUPLE:
            INFO("value is a tupe: " << ERL_ATOM_PTR(erl_element(1, elemen)));
            return ERL_TUPLE;
        case ERL_BINARY:
            break;
        case ERL_FLOAT:
            break;
        case ERL_VARIABLE:
            break;
        case ERL_SMALL_BIG:
            break;
        case ERL_U_SMALL_BIG:
            break;
        case ERL_FUNCTION:
            break;
        case ERL_BIG:
            break;
        case ERL_LONGLONG:
            break;
        case ERL_U_LONGLONG:
            break;
        default:
            ERR("[Client] got a value but now checked\n\r");
            //#todo morechuli
    }
    return -1;
}

static void ErlangTool::erlangFreeEterm(int count, ...) {
    va_list args;
    va_start(args, count);
    for (int i = 0; i < count; ++i) {
        auto test = va_arg(args, ETERM*);
        erl_free_compound(test);
//            if (test != NULL)
//                erl_free_compound(test);
//            else{
//
//            }
    }
}


ErlangTool::ErlangDbTool::ErlangDbTool() : m_fd(-1) {

}

ErlangTool::ErlangDbTool::ErlangDbTool(const std::string &nodeName, const std::string &cookie, const std::string &pName)
    : m_fd(-1), m_path(""), m_nodeName(nodeName), m_cookie(cookie), m_pName(pName) {
    initCNode();
}

ErlangTool::ErlangDbTool::ErlangDbTool(const std::string &path, const std::string &nodeName, const std::string &cookie,
                                       const std::string &pName)
    : m_fd(-1), m_path(path), m_nodeName(nodeName), m_cookie(cookie), m_pName(pName) {
    initCNode();
}


ErlangTool::ErlangDbTool::ErlangDbTool(const std::string &path, const std::string &nodeName, const std::string &cookie,
                                       const std::string &clusterID, const std::string &clusterName) :
    m_fd(-1), m_path(path), m_nodeName(nodeName), m_cookie(cookie), m_clusterID(clusterID), m_clusterName(clusterName) {

}


ErlangTool::ErlangDbTool::ErlangDbTool(const std::string &path, const std::string &nodeName, const std::string &cookie,
                                       const std::string &clusterID, const std::string &clusterName,
                                       const std::string &pName) :
    m_fd(-1), m_path(path), m_nodeName(nodeName), m_cookie(cookie), m_clusterID(clusterID), m_clusterName(clusterName),
    m_pName(pName) {
    initCNode();
}

ErlangTool::ErlangDbTool::~ErlangDbTool() {
    g_syncDbFile.close();
    erl_close_connection(m_fd);
}


void ErlangTool::ErlangDbTool::initCNode() {
    //--------------init db-------------------
    std::string str_SyncDbFile = "/opt/erlang/";
    str_SyncDbFile.append(m_nodeName.substr(0, m_nodeName.find("@"))).append(".db");
    g_syncDbFile.setDatabaseName(str_SyncDbFile.c_str());
    g_syncDbFile.open();

    erl_init(NULL, 0);
    struct in_addr addr;
    //#todo
    addr.s_addr = inet_addr("127.0.0.1");

    m_pName.append(std::to_string((int) getpid()));

    std::string t_cNodeName(m_pName);
    t_cNodeName.append("@127.0.0.1");
    m_cNodeName.swap(t_cNodeName);
    //m_pName
    if (erl_connect_xinit(const_cast<char *>(m_pName.c_str()), const_cast<char *>(m_pName.c_str()),
                          const_cast<char *>(m_cNodeName.c_str()), &addr,
                          const_cast<char *>(m_cookie.c_str()), 0) == -1) {
        ERR("erl_connect_xinit error" << m_pName << " " << m_cNodeName << " " << m_cookie);
        erl_err_quit("erl_connect_xinit");
    } else {
        INFO("erl_connect_xinit ok " << m_pName << " " << m_cNodeName << " " << m_cookie);
    }
}


int ErlangTool::ErlangDbTool::initErlang() {
    if (m_nodeName == "") {
        ERR("m_nodeName is null ");
        return 3;
    }
    m_ret = pingNode(m_nodeName, m_cookie);
    if (!m_ret) {
        if (dir_file_exists(m_path, true)) {
            std::string cmd = std::string("cd " + m_path + " && erl -name " + m_nodeName + " -setcookie  "
                                          + m_cookie + " -mnesia dir '\"" + m_path +
                                          "\"' -detached -noshell");// >>log
            std::cout << cmd << std::endl;
            system(cmd.c_str());
            std::cout << m_ret << std::endl;
            m_ret = waitNode();
            resetConn();
            return m_ret;
        } else {
            ERR("create file faile ");
            return 0;
        }
    } else {
        INFO("node is running");
        return 2;
    }
}

std::string ErlangTool::ErlangDbTool::getConfigJsonString() {
    Json::Value t_json;
    Json::FastWriter writer;

    t_json["\"path\""] = "\"" + m_path + "\"";
    t_json["\"nodeName\""] = "\"" + m_nodeName + "\"";
    t_json["\"cookie\""] = "\"" + m_cookie + "\"";
    t_json["\"clusterID\""] = "\"" + m_clusterID + "\"";
    t_json["\"clusterName\""] = "\"" + m_clusterName + "\"";

    std::string str_json = writer.write(t_json);

    return str_json.substr(0, str_json.length() - 1);
}

bool ErlangTool::ErlangDbTool::startNodeDb(std::string FatherNodeName, std::string DeviceId, std::string DevAdd) {
    LockG lock(m_mutex);
//            m_mutex.lock();
    m_ret = resetConn();
    if (m_ret) {
//                DeviceName = DeviceName.empty() ? m_nodeName : DeviceName;
    } else {
        //#todo error message
        ERR(" error " << m_ret << "  " << m_fd);
        return false;
    }

    ErlMessage emsg;    /* Incoming message */
    //hanshu canshu
    ETERM *arrlist[5];
    arrlist[0] = erl_mk_atom(m_nodeName.c_str());
    arrlist[1] = erl_mk_atom(FatherNodeName.c_str());
    arrlist[2] = erl_mk_atom(DeviceId.c_str());
    arrlist[3] = erl_mk_atom(m_clusterID.c_str());
    arrlist[4] = erl_mk_string(m_clusterName.c_str());
    ETERM *list = erl_mk_list(arrlist, 5);

//            std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << "  " << m_fd << std::endl;
//            erl_rpc(m_fd, "syncDB", "startNode", list);
    int ret = -1;
    ret = erl_rpc_to(m_fd, "syncDB", "startNode", list);
    if (ret == ERL_TICK) {
        ret = erl_rpc_from(m_fd, 9000000000, &emsg);
        //erl_close_connection(m_fd);
//                m_mutex.unlock();
        if (ret == ERL_MSG) {
            std::map<std::string, std::string> t_results;
            ETERM *key, *value;
            ETERM *tuplep[6];

            tuplep[0] = erl_element(2, emsg.msg);
            key = erl_element(1, tuplep[0]);
            value = erl_element(2, tuplep[0]);
//                printf("key:%s\n", ERL_ATOM_PTR(key));
            switch (checkETERMType(value)) {
                case ERL_ATOM: {
                    int atomSize = ERL_ATOM_SIZE(value);
                    char *atomValue = ERL_ATOM_PTR(value);
                    t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
//                        printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
                    break;
                }
                default:
                    ERR("error add case todo \n\r");
            }
            auto it = t_results.find("atomic");
            if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
//                        erlangFreeEterm(7, emsg.to, emsg.msg, emsg.from, list, key, value, tuplep[0]);
//                        erl_eterm_release();
                return true;
            } //if end
            else {
                INFO(" t_results size is " << t_results.size());
                for (auto &item : t_results) {
                    INFO("item is " << item.first << "  " << item.second);
                }
            }
        }//ret == ERL_MSG end
        else {
            ERR(" ret is " << ret);

        }
    } //ret == ERL_TICK

//            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
    return false;
}

bool ErlangTool::ErlangDbTool::removeNode() {
    LockG lock(m_mutex);
//            m_mutex.lock();
    m_ret = resetConn();
    if (!m_ret) {
        //#todo error message
        std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << "  " << m_fd << std::endl;
        return false;
    }
    int ret = -1;
    ErlMessage emsg;    /* Incoming message */
    //hanshu canshu
//            ETERM *arrlist[1];
//            arrlist[0] = erl_mk_atom(m_nodeName.c_str());
    ETERM *list = erl_mk_empty_list();// (arrlist, 0);

//            std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << "  " << m_fd << std::endl;
    ret = erl_rpc_to(m_fd, "syncDB", "removeNode", list);
    if (ret == ERL_TICK) {
        ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
        //erl_close_connection(m_fd);
//                m_mutex.unlock();
        if (ret == ERL_MSG) {
            std::map<std::string, std::string> t_results;
            ETERM *key, *value;
            ETERM *tuplep[6];

            tuplep[0] = erl_element(2, emsg.msg);
            key = erl_element(1, tuplep[0]);
            value = erl_element(2, tuplep[0]);
//                printf("key:%s\n", ERL_ATOM_PTR(key));
            switch (checkETERMType(value)) {
                case ERL_ATOM: {
                    int atomSize = ERL_ATOM_SIZE(value);
                    char *atomValue = ERL_ATOM_PTR(value);
                    t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
//                        printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
                    break;
                }
                default:
                    printf("error add case todo \n\r");
            }
            auto it = t_results.find("atomic");
            if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
                //删除本地文件
                if (!m_path.empty()) {
                    std::string cmd = std::string("rm -rf ").append(m_path);
                    //#todo
                    system(cmd.c_str());
                }
                erlangFreeEterm(7, emsg.to, emsg.msg, emsg.from, list, key, value, tuplep[0]);
                erl_eterm_release();
                return true;
            } //if end
        } //ret == ERL_MSG end
    } //ret == ERL_TICK

    erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
    return false;
}

bool ErlangTool::ErlangDbTool::modifyCluName(std::string CluId, std::string CluName) {
    LockG lock(m_mutex);
//            m_mutex.lock();
    m_ret = resetConn();
    if (!m_ret) {
        //#todo error message
        std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << "  " << m_fd << std::endl;
        return false;
    }
    ErlMessage emsg;             /* Incoming message */
    int ret = -1;
    ETERM *arrlist[2];
    arrlist[0] = erl_mk_atom(CluId.c_str());
    arrlist[1] = erl_mk_string(CluName.c_str());
    ETERM *list = erl_mk_list(arrlist, 2);

    ret = erl_rpc_to(m_fd, "syncDB", "modifyCluName", list);
    if (ret == ERL_TICK) {
        ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
        //erl_close_connection(m_fd);
//                m_mutex.unlock();
        if (ret == ERL_MSG) {
            std::map<std::string, std::string> t_results;

            ETERM *tail_list;
            ETERM *list_ret[1000], *arr_ret[2];
            ETERM *key, *value;
            ETERM *tuplep[6];

            arr_ret[0] = erl_element(2, emsg.msg);
            int erlLength = erl_length(arr_ret[0]);
            printf("arr_ret[0]:%d\n", erlLength);
            list_ret[0] = erl_hd(arr_ret[0]);
            tail_list = erl_tl(arr_ret[0]);
            for (int i = 0; i < erlLength; i++) {
                if (i > 0) {
                    list_ret[i] = erl_hd(tail_list);
                    tail_list = erl_tl(tail_list);
                }
//                    printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
                tuplep[0] = erl_hd(list_ret[i]);
                key = erl_element(1, list_ret[i]);
                value = erl_element(2, list_ret[i]);
//                    printf("key:%s\n", ERL_ATOM_PTR(key));

                switch (checkETERMType(value)) {
                    case ERL_ATOM: {
                        int atomSize = ERL_ATOM_SIZE(value);
                        char *atomValue = ERL_ATOM_PTR(value);
                        printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
                        t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
                        break;
                    }
                    default:
                        printf("error add case todo \n\r");
                }
                erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);

            }
            erlangFreeEterm(2, tail_list, arr_ret[0]);
            erl_eterm_release();
            auto it = t_results.find("atomic");
            if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
                return true;
            }
        }
    }
    erl_free_array(arrlist, 2);
//            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
    erl_eterm_release();
    return false;
}


ErlangTool::map_DevDataCache ErlangTool::ErlangDbTool::findAllNode() {
    LockG lock(m_mutex);
//            m_mutex.lock();
    m_ret = resetConn();
    if (!m_ret) {
        //#todo error message
        ERR(" error " << m_ret << "  " << m_fd);
        return map_DevDataCache();
    }
    map_DevDataCache devDataCache;
    int ret = -1;
    ErlMessage emsg;    /* Incoming message */
    //hanshu canshu
//            ETERM *arrlist[0];
//            arrlist[0] = erl_mk_atom(m_nodeName.c_str());
    ETERM *list = erl_mk_empty_list();//erl_mk_list(arrlist, 0);

    ret = erl_rpc_to(m_fd, "syncDB", "findAllNode", list);
    if (ret == ERL_TICK) {
        ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
        //erl_close_connection(m_fd);
//                m_mutex.unlock();
        if (ret == ERL_MSG) {
            ETERM *key, *value;
            ETERM *tuplep[20];
            ETERM *arr_ret[2], *list_ret[1000];
            ETERM *tail_list, *tail_tuple;
            arr_ret[0] = erl_element(2, emsg.msg);
            if (checkETERMType(arr_ret[0]) == ERL_LIST) {
                int erlLength = erl_length(arr_ret[0]);
//                    printf("arr_ret[0]:%d\n", erlLength);
                list_ret[0] = erl_hd(arr_ret[0]);
                tail_list = erl_tl(arr_ret[0]);
                for (int i = 0; i < erlLength; i++) {
                    if (i > 0) {
                        list_ret[i] = erl_hd(tail_list);
                        tail_list = erl_tl(tail_list);
                    }
                    if (checkETERMType(list_ret[i]) == ERL_LIST) {
                        SyncDB::Device_Info device_info;
                        int erlLength1 = erl_length(list_ret[i]);
//                            printf("list_ret[%d]:%d\n", i, erlLength1);
                        tuplep[0] = erl_hd(list_ret[i]);
                        tail_tuple = erl_tl(list_ret[i]);

                        for (int j = 0; j < erlLength1; j++) {
                            if (j > 0) {
                                tuplep[j] = erl_hd(tail_tuple);
                                tail_tuple = erl_tl(tail_tuple);
                            }
                            key = erl_element(1, tuplep[j]);
                            value = erl_element(2, tuplep[j]);
//                                printf("key:%s\n", erl_iolist_to_string(key));
                            switch (checkETERMType(value)) {
                                case ERL_ATOM: {
                                    device_info.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
                                    break;
                                }
                                case ERL_INTEGER: {
                                    device_info.setValue(erl_iolist_to_string(key),
                                                         std::to_string(ERL_INT_VALUE(value)));
                                    break;
                                }
                                case ERL_LIST: {
                                    device_info.setValue(erl_iolist_to_string(key),
                                                         erl_iolist_to_string(value));
                                    break;
                                }
                                default:
                                    ERR("error add case todo" << checkETERMType(value) << " key is "
                                                              << checkETERMType(key));
                            }
                            erlangFreeEterm(3, key, value, tuplep[j]);
                        }
//                            printf("\none list end\n\n\n\n");
                        // #todo this is have a bug
//                                device_info.create_by = "";
                        devDataCache.insert(std::make_pair(device_info.uuid, device_info));
                        erlangFreeEterm(1, tail_tuple);
                    } else {
                        ERR("type error " << checkETERMType(list_ret[i]));
                    }
                    erlangFreeEterm(1, list_ret[i]);
                }

                erlangFreeEterm(5, emsg.to, emsg.msg, emsg.from, tail_list, arr_ret[0]);
                erl_eterm_release();
                return devDataCache;
            } else {
                ERR(" error " << checkETERMType(arr_ret[0]));
            }
        }
    } else {
        ERR("ret != ERL_TICK");
    } //ret == ERL_TICK end
    erlangFreeEterm(3, emsg.to, emsg.msg, emsg.from);
    erl_eterm_release();
    return map_DevDataCache();
}

bool ErlangTool::ErlangDbTool::createDatabase(std::string TableType, std::string TableName, bool SyncType,
                                              std::string BwType, std::string StartTime, std::string EndTime) {
    LockG lock(m_mutex);
//            m_mutex.lock();
    m_ret = resetConn();
    if (!m_ret) {
        //#todo error message
        std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << "  " << m_fd << std::endl;
        return false;
    }
    std::string NewTableName = ((!SyncType) && TableName.find("lt_")) ? std::string("lt_").append(TableName)
                                                                      : TableName;

    ErlMessage emsg;             /* Incoming message */
    int ret = -1;
    ETERM *arrlist[6];
    arrlist[0] = erl_mk_atom(TableType.c_str());
    arrlist[1] = erl_mk_string(NewTableName.c_str());
    auto str = std::to_string(SyncType);
    arrlist[2] = erl_mk_atom(str.c_str());
    arrlist[3] = erl_mk_atom(BwType.c_str());
    arrlist[4] = erl_mk_atom(StartTime.c_str());
    arrlist[5] = erl_mk_atom(EndTime.c_str());
    ETERM *list = erl_mk_list(arrlist, 6);

    ret = erl_rpc_to(m_fd, "syncDB", "createDatabase", list);
    if (ret == ERL_TICK) {
        ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
        //erl_close_connection(m_fd);
//                m_mutex.unlock();
        if (ret == ERL_MSG) {
            std::map<std::string, std::string> t_results;

            ETERM *tail_list;
            ETERM *list_ret[1000], *arr_ret[2];
            ETERM *key, *value;
            ETERM *tuplep[6];

            arr_ret[0] = erl_element(2, emsg.msg);
            int erlLength = erl_length(arr_ret[0]);
            printf("arr_ret[0]:%d\n", erlLength);
            list_ret[0] = erl_hd(arr_ret[0]);
            tail_list = erl_tl(arr_ret[0]);
            for (int i = 0; i < erlLength; i++) {
                if (i > 0) {
                    list_ret[i] = erl_hd(tail_list);
                    tail_list = erl_tl(tail_list);
                }
//                    printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
                tuplep[0] = erl_hd(list_ret[i]);
                key = erl_element(1, list_ret[i]);
                value = erl_element(2, list_ret[i]);
//                    printf("key:%s\n", ERL_ATOM_PTR(key));

                switch (checkETERMType(value)) {
                    case ERL_ATOM: {
//                            int atomSize = ERL_ATOM_SIZE(value);
                        char *atomValue = ERL_ATOM_PTR(value);
//                            printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
                        t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
                        break;
                    }
                    default:
                        printf("error add case todo \n\r");
                }
                erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);

            }
            erlangFreeEterm(2, tail_list, arr_ret[0]);
            erl_eterm_release();
            auto it = t_results.find("atomic");
            if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
                return true;
            }
        }
    }
    erl_free_array(arrlist, 6);
//            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
    erl_eterm_release();
    return false;
}

bool ErlangTool::ErlangDbTool::createDatabase(std::string t_tableName, FieldValues &fieldValues) {
//    #todo 记得测试中文
    std::string strSql = getCreateFaceTableSql(t_tableName);
    strSql.append(getInsertSql("sys_o_tables", fieldValues));
    getExecSqlResult(strSql);
}


bool ErlangTool::ErlangDbTool::updateDatabase(std::string UUID, std::string TableType, std::string TableName,
                                              bool SyncType, std::string BwType, std::string StartTime,
                                              std::string EndTime) {
    LockG lock(m_mutex);
//            m_mutex.lock();
    m_ret = resetConn();
    if (!m_ret) {
        //#todo error message
        std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << "  " << m_fd << std::endl;
        return false;
    }
    std::string NewTableName = ((!SyncType) && TableName.find("lt_")) ? std::string("lt_").append(TableName)
                                                                      : TableName;

    ErlMessage emsg;             /* Incoming message */
    int ret = -1;
    ETERM *arrlist[7];
    arrlist[0] = erl_mk_atom(UUID.c_str());
    arrlist[1] = erl_mk_atom(TableType.c_str());
    arrlist[2] = erl_mk_string(NewTableName.c_str());
    auto str = std::to_string(SyncType);
    arrlist[3] = erl_mk_atom(str.c_str());
    arrlist[4] = erl_mk_atom(BwType.c_str());
    arrlist[5] = erl_mk_atom(StartTime.c_str());
    arrlist[6] = erl_mk_atom(EndTime.c_str());
    ETERM *list = erl_mk_list(arrlist, 7);

    ret = erl_rpc_to(m_fd, "syncDB", "updateDatabase", list);
    if (ret == ERL_TICK) {
        ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
        //erl_close_connection(m_fd);
//                m_mutex.unlock();
        if (ret == ERL_MSG) {
            std::map<std::string, std::string> t_results;

            ETERM *tail_list;
            ETERM *list_ret[1000], *arr_ret[2];
            ETERM *key, *value;
            ETERM *tuplep[6];

            arr_ret[0] = erl_element(2, emsg.msg);
            int erlLength = erl_length(arr_ret[0]);
            printf("arr_ret[0]:%d\n", erlLength);
            list_ret[0] = erl_hd(arr_ret[0]);
            tail_list = erl_tl(arr_ret[0]);
            for (int i = 0; i < erlLength; i++) {
                if (i > 0) {
                    list_ret[i] = erl_hd(tail_list);
                    tail_list = erl_tl(tail_list);
                }
//                    printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
                tuplep[0] = erl_hd(list_ret[i]);
                key = erl_element(1, list_ret[i]);
                value = erl_element(2, list_ret[i]);
//                    printf("key:%s\n", ERL_ATOM_PTR(key));

                switch (checkETERMType(value)) {
                    case ERL_ATOM: {
//                            int atomSize = ERL_ATOM_SIZE(value);
                        char *atomValue = ERL_ATOM_PTR(value);
//                            printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
                        t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
                        break;
                    }
                    default:
                        printf("error add case todo \n\r");
                }
                erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
            }
            erlangFreeEterm(2, tail_list, arr_ret[0]);
            erl_eterm_release();
            auto it = t_results.find("atomic");
            if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
                return true;
            }
        }
    }
    erl_free_array(arrlist, 7);
//            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
    erl_eterm_release();
    return false;
}

bool ErlangTool::ErlangDbTool::updateDatabase(std::string t_tableName, FieldValues &fieldValues) {
    //    #todo 记得测试中文
    std::string strSql = getUpdateFaceTableSql(t_tableName, fieldValues);
    return getExecSqlResult(strSql);

}

bool ErlangTool::ErlangDbTool::getExecSqlResult(const std::string &strSql) {
    ErlangTool::LockG lock(m_mutex);
//            m_mutex.lock();
    m_ret = resetConn();
    if (!m_ret) {
        //#todo error message
        std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << this->m_ret << "  " << this->m_fd
                  << std::endl;
        return false;
    }

    ErlMessage emsg;             /* Incoming message */
    int ret = -1;
    ETERM *arrlist[7];
    arrlist[0] = erl_mk_string(strSql.c_str());
    ETERM *list = erl_mk_list(arrlist, 1);

    ret = erl_rpc_to(m_fd, "syncDB", "exeSomeSql", list);
    if (ret == ERL_TICK) {
        ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
        //erl_close_connection(m_fd);
//                m_mutex.unlock();
        if (ret == ERL_MSG) {
            std::map<std::__cxx11::string, std::__cxx11::string> t_results;

            ETERM *tail_list;
            ETERM *list_ret[1000], *arr_ret[2];
            ETERM *key, *value;
            ETERM *tuplep[6];

            arr_ret[0] = erl_element(2, emsg.msg);
            int erlLength = erl_length(arr_ret[0]);
            printf("arr_ret[0]:%d\n", erlLength);
            list_ret[0] = erl_hd(arr_ret[0]);
            tail_list = erl_tl(arr_ret[0]);
            for (int i = 0; i < erlLength; i++) {
                if (i > 0) {
                    list_ret[i] = erl_hd(tail_list);
                    tail_list = erl_tl(tail_list);
                }
//                    printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
                tuplep[0] = erl_hd(list_ret[i]);
                key = erl_element(1, list_ret[i]);
                value = erl_element(2, list_ret[i]);
//                    printf("key:%s\n", ERL_ATOM_PTR(key));

                switch (ErlangTool::checkETERMType(value)) {
                    case ERL_ATOM: {
//                            int atomSize = ERL_ATOM_SIZE(value);
                        char *atomValue = ERL_ATOM_PTR(value);
//                            printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
                        t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
                        break;
                    }
                    default:
                        printf("error add case todo \n\r");
                }
                ErlangTool::erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
            }
            ErlangTool::erlangFreeEterm(2, tail_list, arr_ret[0]);
            erl_eterm_release();
            auto it = t_results.find("atomic");
            if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
                return true;
            }
        }
    }
    erl_free_array(arrlist, 1);
//            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
    erl_eterm_release();
    return false;
}

bool ErlangTool::ErlangDbTool::deleteDatabase(std::string TableType, std::string TableName, bool SyncType) {
    LockG lock(m_mutex);
//            m_mutex.lock();
    m_ret = resetConn();
    if (!m_ret) {
        //#todo error message
        ERR(" error " << m_ret << "  " << m_fd);
        return false;
    }
    std::string NewTableName = ((!SyncType) && TableName.find("lt_")) ? std::string("lt_").append(TableName)
                                                                      : TableName;

    ErlMessage emsg;             /* Incoming message */
    int ret = -1;

    ETERM *arrlist[2];
    arrlist[0] = erl_mk_atom(TableType.c_str());
    arrlist[1] = erl_mk_string(NewTableName.c_str());
    ETERM *list = erl_mk_list(arrlist, 2);

    ret = erl_rpc_to(m_fd, "syncDB", "deleteDatabase", list);
    if (ret == ERL_TICK) {
        ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
        //erl_close_connection(m_fd);
//                m_mutex.unlock();
        if (ret == ERL_MSG) {
            std::map<std::string, std::string> t_results;
            ETERM *tail_list;
            ETERM *list_ret[10], *arr_ret[2];
            ETERM *key, *value;
            ETERM *tuplep[6];
            arr_ret[0] = erl_element(2, emsg.msg);
            int erlLength = erl_length(arr_ret[0]);
            printf("arr_ret[0]:%d\n", erlLength);
            list_ret[0] = erl_hd(arr_ret[0]);
            tail_list = erl_tl(arr_ret[0]);
            for (int i = 0; i < erlLength; i++) {
                if (i > 0) {
                    list_ret[i] = erl_hd(tail_list);
                    tail_list = erl_tl(tail_list);
                }
//                    printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
                tuplep[0] = erl_hd(list_ret[i]);
                key = erl_element(1, list_ret[i]);
                value = erl_element(2, list_ret[i]);
//                    printf("key:%s\n", ERL_ATOM_PTR(key));
                switch (checkETERMType(value)) {
                    case ERL_ATOM: {
                        int atomSize = ERL_ATOM_SIZE(value);
                        char *atomValue = ERL_ATOM_PTR(value);
                        t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
                        printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
                        break;
                    }
                    default:
                        printf("error add case todo \n\r");
                }
                erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
            }
            erlangFreeEterm(2, tail_list, arr_ret[0]);
            auto it = t_results.find("atomic");
            if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
                return true;
            }
        }
    }
    erl_free_array(arrlist, 2);
    erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
    return false;
}


bool ErlangTool::ErlangDbTool::deleteDatabase(std::string t_tableName) {

    FieldValues fieldValues;
    fieldValues.insert(std::make_pair("uuid", t_tableName));
    fieldValues.insert(std::make_pair("del_flag", "1"));
    std::string strSql = getUpdateFaceTableSql("sys_o_tables", fieldValues);
    strSql.append("DROP TABLE '" + t_tableName + "';DROP TABLE '" + t_tableName + "_fea';");
    //    #todo 记得测试中文
    return getExecSqlResult(strSql);

}

// 和erlang交互
//ErlangTool::map_TabDataCache ErlangTool::ErlangDbTool::findAllDatabase() {
//    LockG lock(m_mutex);
////            m_mutex.lock();
//    m_ret = resetConn();
//    map_TabDataCache tabDataCache;
//    if (!m_ret) {
//        //#todo error message
//        std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << "  " << m_fd << std::endl;
//        return tabDataCache;
//    }
//    int ret = -1;
//    ErlMessage emsg;    /* Incoming message */
//    //hanshu canshu
////            ETERM *arrlist[0];
////            arrlist[0] = erl_mk_atom(m_nodeName.c_str());
//    ETERM *list = erl_mk_empty_list();//erl_mk_list(arrlist, 0);
//
//    std::cout << __FILE__ << __FUNCTION__ << __LINE__ << "  " << m_fd << std::endl;
//    ret = erl_rpc_to(m_fd, "syncDB", "findAllDatabase", list);
//    if (ret == ERL_TICK) {
//        ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
//        //erl_close_connection(m_fd);
////                m_mutex.unlock();
//        if (ret == ERL_MSG) {
//            ETERM *key, *value;
//            ETERM *tuplep[20];
//            ETERM *arr_ret[2], *list_ret[1000];
//            ETERM *tail_list, *tail_tuple;
//            arr_ret[0] = erl_element(2, emsg.msg);
//            if (checkETERMType(arr_ret[0]) == ERL_LIST) {
//                int erlLength = erl_length(arr_ret[0]);
//                list_ret[0] = erl_hd(arr_ret[0]);
//                tail_list = erl_tl(arr_ret[0]);
//                for (int i = 0; i < erlLength; i++) {
//                    if (i > 0) {
//                        list_ret[i] = erl_hd(tail_list);
//                        tail_list = erl_tl(tail_list);
//                    }
//                    if (checkETERMType(list_ret[i]) == ERL_LIST) {
//                        SyncDB::Table_Info table_info;
//                        int erlLength1 = erl_length(list_ret[i]);
//                        tuplep[0] = erl_hd(list_ret[i]);
//                        tail_tuple = erl_tl(list_ret[i]);
//
//                        for (int j = 0; j < erlLength1; j++) {
//                            if (j > 0) {
//                                tuplep[j] = erl_hd(tail_tuple);
//                                tail_tuple = erl_tl(tail_tuple);
//                            }
//                            key = erl_element(1, tuplep[j]);
//                            value = erl_element(2, tuplep[j]);
//                            switch (checkETERMType(value)) {
//                                case ERL_ATOM: {
//                                    table_info.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
//                                    break;
//                                }
//                                case ERL_INTEGER: {
//                                    table_info.setValue(erl_iolist_to_string(key),
//                                                        std::to_string(ERL_INT_VALUE(value)));
//                                    break;
//                                }
//                                case ERL_LIST: {
//                                    table_info.setValue(erl_iolist_to_string(key),
//                                                        erl_iolist_to_string(value));
//                                    break;
//                                }
//                                default:
//                                    printf("error add case todo %d\n\r", checkETERMType(value));
//                            }
////                                    erlangFreeEterm(3, key, value, tuplep[j]);
//                        }
////                                erlangFreeEterm(2, tail_tuple, list_ret[i]);
//
//                        // #todo this is have a bug
////                                table_info.create_by = "";
//                        tabDataCache.insert(std::make_pair(table_info.tableName, table_info));
//                    } else {
//                        std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " type error "
//                                  << checkETERMType(arr_ret[0])
//                                  << "  "
//                                  << std::endl;
//                    }
//                }
////                        erlangFreeEterm(2, tail_list, arr_ret[0]);
//                return tabDataCache; //ok
//            } else {
//                ERR(" error " << checkETERMType(arr_ret[0]));
//            }
//        }
//    }
////            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
//    return tabDataCache; //not ok
//}

//#todo
//直接和sqlite3 交互
ErlangTool::map_TabDataCache ErlangTool::ErlangDbTool::findAllDatabase() {
    map_TabDataCache tabDataCache;

    QString sql = QString::fromStdString(
        "SELECT  uuid,tableName,tableType,bwType,startTime,endTime,uploadFlag,cmpThreshold,enabled,create_by FROM sys_o_tables where del_flag=0;");
    QSqlQuery query(g_syncDbFile);
    query.prepare(sql);
    if (!query.exec()) {
        qDebug() << "getTableNameList" << __FILE__ << __LINE__ << query.lastError();
    } else {
        while (query.next()) {
            SyncDB::Table_Info t_table_info;
            t_table_info.uuid = query.value(0).toString().toStdString();
            t_table_info.tableName = query.value(1).toString().toStdString();
            t_table_info.tableType = query.value(2).toString().toStdString();
            t_table_info.bwType = query.value(3).toString().toStdString();
            t_table_info.startTime = query.value(4).toString().toStdString();
            t_table_info.endTime = query.value(5).toString().toStdString();
            t_table_info.uploadFlag = query.value(6).toString().toStdString();
            t_table_info.cmpThreshold = query.value(7).toString().toStdString();
            t_table_info.enabled = query.value(8).toString().toStdString();
            t_table_info.create_by = query.value(9).toString().toStdString();

            tabDataCache.insert(std::make_pair(t_table_info.uuid, t_table_info));
        }
    }
    return tabDataCache; //not ok
}

/***
 * @deprecated
 * @return
 */
ErlangTool::map_BwDataCache ErlangTool::ErlangDbTool::findAllTypeInfo() {
    return map_BwDataCache();
    LockG lock(m_mutex);
//            m_mutex.lock();
    m_ret = resetConn();
    if (!m_ret) {
        //#todo error message
        std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << "  " << m_fd << std::endl;
        return map_BwDataCache();
    }
    map_BwDataCache bwDataCache;
    int ret = -1;
    ErlMessage emsg;    /* Incoming message */
    ETERM *list = erl_mk_empty_list();//erl_mk_list(arrlist, 0);

//            std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << "  " << m_fd << std::endl;
    ret = erl_rpc_to(m_fd, "syncDB", "findAllTypeInfo", list);
    if (ret == ERL_TICK) {
        ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
        //erl_close_connection(m_fd);
//                m_mutex.unlock();
        if (ret == ERL_MSG) {
            ETERM *key, *value;
            ETERM *tuplep[20];
            ETERM *arr_ret[2], *list_ret[1000];
            ETERM *tail_list, *tail_tuple;
            arr_ret[0] = erl_element(2, emsg.msg);
            if (checkETERMType(arr_ret[0]) == ERL_LIST) {
                int erlLength = erl_length(arr_ret[0]);
//                    printf("arr_ret[0]:%d\n", erlLength);
                list_ret[0] = erl_hd(arr_ret[0]);
                tail_list = erl_tl(arr_ret[0]);
                for (int i = 0; i < erlLength; i++) {
                    if (i > 0) {
                        list_ret[i] = erl_hd(tail_list);
                        tail_list = erl_tl(tail_list);
                    }
                    if (checkETERMType(list_ret[i]) == ERL_LIST) {
                        SyncDB::Bw_Info bw_info;
                        int erlLength1 = erl_length(list_ret[i]);
//                            printf("list_ret[%d]:%d\n", i, erlLength1);
                        tuplep[0] = erl_hd(list_ret[i]);
                        tail_tuple = erl_tl(list_ret[i]);

                        for (int j = 0; j < erlLength1; j++) {
                            if (j > 0) {
                                tuplep[j] = erl_hd(tail_tuple);
                                tail_tuple = erl_tl(tail_tuple);
                            }
                            key = erl_element(1, tuplep[j]);
                            value = erl_element(2, tuplep[j]);
//                                printf("key:%s\n", erl_iolist_to_string(key));
                            switch (checkETERMType(value)) {
                                case ERL_ATOM: {
                                    bw_info.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
                                    break;
                                }
                                case ERL_INTEGER: {
                                    bw_info.setValue(erl_iolist_to_string(key),
                                                     std::to_string(ERL_INT_VALUE(value)));
                                    break;
                                }
                                case ERL_LIST: {
                                    bw_info.setValue(erl_iolist_to_string(key),
                                                     erl_iolist_to_string(value));
                                    break;
                                }
                                default:
                                    printf("error add case todo %d\n\r", checkETERMType(value));
                            }
//                                    erlangFreeEterm(3, key, value, tuplep[j]);
                        }
//                                erlangFreeEterm(2, tail_tuple, list_ret[i]);
//                            printf("\none list end\n\n\n\n");
                        // #todo this is have a bug
//                            bw_info.create_by = "";
                        bwDataCache.insert(std::make_pair(bw_info.tableName, bw_info));
                    } else {
                        std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " type error "
                                  << checkETERMType(arr_ret[0])
                                  << "  "
                                  << std::endl;
                    }
                }
//                        erlangFreeEterm(2, tail_list, arr_ret[0]);
                return bwDataCache;//ok
            } else {
                ERR(" error " << checkETERMType(arr_ret[0]));
            }
        }
    }
//            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
    return map_BwDataCache();
}

bool ErlangTool::ErlangDbTool::addPerson(std::string &UUID, std::string TableName, std::string Feature,
                                         std::string ImgUrl, std::string IdCard, std::string PersonName,
                                         std::string Age, std::string Sex, std::string PhoneNum) {
    LockG lock(m_mutex);
//            m_mutex.lock();
    m_ret = resetConn();
    if (!m_ret) {
        //#todo error message
        ERR(" error " << m_ret << "  " << m_fd << " ");
        return false;
    }
    int ret;
    ErlMessage emsg;    /* Incoming message */
    //hanshu canshu
    ETERM *arrlist[9];
    arrlist[0] = erl_mk_string(TableName.c_str());
    arrlist[1] = erl_mk_string(PersonName.c_str());
    arrlist[2] = erl_mk_string(Age.c_str());
    arrlist[3] = erl_mk_string(Sex.c_str());
    arrlist[4] = erl_mk_string(IdCard.c_str());
    arrlist[5] = erl_mk_string(PhoneNum.c_str());
    arrlist[6] = erl_mk_string(ImgUrl.c_str());
    arrlist[7] = erl_mk_string(UUID.c_str());
    arrlist[8] = erl_mk_string(Feature.c_str());
    std::string TmpUUid;

    ETERM *list = erl_mk_list(arrlist, 9);
    ret = erl_rpc_to(m_fd, "syncDB", "addPersonData", list);
    if (ret == ERL_TICK) {

        ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
//        UUID.clear();
        //erl_close_connection(m_fd);
//                m_mutex.unlock();
        if (ret == ERL_MSG) {
            ETERM *value;
            value = erl_element(2, emsg.msg);
            switch (checkETERMType(value)) {
                case ERL_LIST: {
                    TmpUUid = std::string(erl_iolist_to_string(value));
                    break;
                }
                case ERL_ATOM: {
                    TmpUUid = std::string(ERL_ATOM_PTR(value));
                    break;
                }
                default:
                    printf("error add case todo \n\r");
            }
            erl_free_term(value);
            if (TmpUUid.size() > 0) {
                UUID = TmpUUid;
                erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[8]);
                erl_free_array(arrlist, 8);
                erl_eterm_release();
                return true;
            }
        }
    }
    erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[8]);
    erl_free_array(arrlist, 8);
    erl_eterm_release();
    UUID = "";
    return false;
}

bool ErlangTool::ErlangDbTool::addPerson(std::string t_tableName, AddFaceData &faceData, FieldValues &fieldValues) {
//    #todo 记得测试中文
    std::string strSql = getInsertSql(t_tableName, fieldValues);
    fieldValues.clear();
    fieldValues.insert(make_pair("uuid", faceData.uuid));
    fieldValues.insert(make_pair("faceUrl", faceData.faceUrl));
    fieldValues.insert(make_pair("feature", faceData.feature_base64));

    std::string strSqlFea = getInsertSql(t_tableName + "_fea", fieldValues);
    strSql.append(strSqlFea);
    //    #todo 记得测试中文  只有人员信息表更新，特征更新暂时没做

    return getExecSqlResult(strSql);
}

bool ErlangTool::ErlangDbTool::updatePerson(std::string t_tableName, AddFaceData &faceData, FieldValues &fieldValues) {
//    #todo 记得测试中文
    std::string strSql = getUpdateFaceTableSql(t_tableName, fieldValues);
    fieldValues.clear();
    fieldValues.insert(make_pair("uuid", faceData.uuid));
    fieldValues.insert(make_pair("faceUrl", faceData.faceUrl));

    fieldValues.insert(make_pair("feature", faceData.feature_base64));

    std::string strSqlFea = getInsertSql(t_tableName + "_fea", fieldValues);
    strSql.append(strSqlFea);

    return getExecSqlResult(strSql);
}

ErlangTool::vec_AddDataCache
ErlangTool::ErlangDbTool::addPersons(std::string TableUuid, std::vector<SyncDB::AddPersonInfo> &tmpPer) {
    LockG lock(m_mutex);
//            m_mutex.lock();
    m_ret = resetConn();
    ErlangTool::vec_AddDataCache t_vec_addDataCache;
    if (!m_ret) {
        //#todo error message
        ERR(" error " << m_ret << "  " << m_fd << " ");
        return t_vec_addDataCache;
    }
    int ret;
    ErlMessage emsg;    /* Incoming message */
    ETERM *person_list[10];
    int loop = 0;
    for (auto &item :tmpPer) {
        ETERM *arrlist[4];
        arrlist[0] = erl_mk_atom(item.personid.c_str());
        arrlist[1] = erl_mk_atom(item.idcard.c_str());
        arrlist[2] = erl_mk_atom(item.personPic.c_str());
        arrlist[3] = erl_mk_string(item.feature.c_str());
        person_list[loop++] = erl_mk_tuple(arrlist, 4);
    }

    //hanshu canshu
    ETERM *arrvaluelist[2];
    arrvaluelist[0] = erl_mk_string(TableUuid.c_str());
    arrvaluelist[1] = erl_mk_list(person_list, loop);

    ETERM *list = erl_mk_list(arrvaluelist, 2);
    ret = erl_rpc_to(m_fd, "syncDB", "addPersonDatas", list);
    if (ret == ERL_TICK) {
        ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
        //erl_close_connection(m_fd);
//                m_mutex.unlock();
        if (ret == ERL_MSG) {
            ETERM *key, *value;
            ETERM *tuplep[20];
            ETERM *arr_ret[2], *list_ret[5000];
            ETERM *tail_list, *tail_tuple;
            arr_ret[0] = erl_element(2, emsg.msg);
            if (checkETERMType(arr_ret[0]) == ERL_LIST) {
                int erlLength = erl_length(arr_ret[0]);
//                        printf("arr_ret[0]:%d\n", erlLength);
                list_ret[0] = erl_hd(arr_ret[0]);
                tail_list = erl_tl(arr_ret[0]);
                for (int i = 0; i < erlLength; i++) {
//                            DBG(i);
                    if (i > 0) {
                        list_ret[i] = erl_hd(tail_list);
                        tail_list = erl_tl(tail_list);
                    }
                    if (tail_list == NULL)
                        break;
                    if (checkETERMType(list_ret[i]) == ERL_LIST) {
                        SyncDB::AddPersRet addPersRet;
                        int erlLength1 = erl_length(list_ret[i]);
//                                printf("list_ret[%d]:%d\n", i, erlLength1);
                        tuplep[0] = erl_hd(list_ret[i]);
                        tail_tuple = erl_tl(list_ret[i]);

                        for (int j = 0; j < erlLength1; j++) {
                            if (j > 0) {
                                tuplep[j] = erl_hd(tail_tuple);
                                tail_tuple = erl_tl(tail_tuple);
                            }
                            key = erl_element(1, tuplep[j]);
                            value = erl_element(2, tuplep[j]);
//                                    printf("key:%s\n", erl_iolist_to_string(key));

                            switch (checkETERMType(value)) {
                                case ERL_ATOM: {
                                    addPersRet.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
                                    break;
                                }
                                case ERL_LIST: {
                                    addPersRet.setValue(erl_iolist_to_string(key),
                                                        erl_iolist_to_string(value));
                                    break;
                                }
                                default:
                                    printf("error add case todo %d\n\r", checkETERMType(value));
                            }

//                                    erlangFreeEterm(2, key, value);
                        }
//                                printf("\none list end\n\n\n\n");
                        t_vec_addDataCache.push_back(addPersRet);
                    } else {
                        ERR(" type error " << checkETERMType(list_ret[i]));
                    }
                }
                erlangFreeEterm(4, emsg.msg, emsg.from, emsg.to, list);
                erl_eterm_release();
//                        sleep()
                return t_vec_addDataCache;
            } else {
                ERR(" error " << checkETERMType(arr_ret[0]));
            }
        } else {
            ERR("send Message is error");
        }
    }
    erlangFreeEterm(4, emsg.msg, emsg.from, emsg.to, list);
    erl_free_array(arrvaluelist, 2);
    erl_eterm_release();
    return t_vec_addDataCache;
}

bool ErlangTool::ErlangDbTool::delPerson(std::string UUID, std::string TableName) {
    LockG lock(m_mutex);
//            m_mutex.lock();
    m_ret = resetConn();
    if (!m_ret) {
        //#todo error message
        ERR(" error " << m_ret << "  " << m_fd << " ");
        return false;
    }
    int ret;
    ErlMessage emsg;    /* Incoming message */
    //hanshu canshu
    ETERM *arrlist[2];
//    arrlist[0] = erl_mk_atom(TableName.c_str());
//    arrlist[1] = erl_mk_atom(UUID.c_str());
    arrlist[0] = erl_mk_string(TableName.c_str());
    arrlist[1] = erl_mk_string(UUID.c_str());

    ETERM *list = erl_mk_list(arrlist, 2);
    ret = erl_rpc_to(m_fd, "syncDB", "deletePersonData", list);
    if (ret == ERL_TICK) {
        ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
        //erl_close_connection(m_fd);
//                m_mutex.unlock();
        if (ret == ERL_MSG) {
            std::map<std::string, std::string> t_results;
            ETERM *tail_list;
            ETERM *list_ret[10], *arr_ret[2];
            ETERM *key, *value;
            ETERM *tuplep[6];
            arr_ret[0] = erl_element(2, emsg.msg);
            int erlLength = erl_length(arr_ret[0]);
            printf("arr_ret[0]:%d\n", erlLength);
            list_ret[0] = erl_hd(arr_ret[0]);
            tail_list = erl_tl(arr_ret[0]);
            for (int i = 0; i < erlLength; i++) {
                if (i > 0) {
                    list_ret[i] = erl_hd(tail_list);
                    tail_list = erl_tl(tail_list);
                }
//                    printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
                tuplep[0] = erl_hd(list_ret[i]);
                key = erl_element(1, list_ret[i]);
                value = erl_element(2, list_ret[i]);
//                    printf("key:%s\n", ERL_ATOM_PTR(key));
                switch (checkETERMType(value)) {
                    case ERL_ATOM: {
                        int atomSize = ERL_ATOM_SIZE(value);
                        char *atomValue = ERL_ATOM_PTR(value);
                        t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
//                                printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
                        break;
                    }
                    default:
                        printf("error add case todo \n\r");
                }
                erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
            }
            erlangFreeEterm(2, tail_list, arr_ret[0]);
            auto it = t_results.find("atomic");
            if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
                return true;
            }
        }
    }
    erlangFreeEterm(4, emsg.msg, emsg.from, emsg.to, list);
    erl_free_array(arrlist, 2);
    erl_eterm_release();
    return false;
}

//ErlangTool::map_FaceDataCache ErlangTool::ErlangDbTool::loadFaceFeaData(std::string TableName) {
//    std::lock_guard<std::mutex> lock(m_mutex);
////            m_mutex.lock();
//    m_ret = resetConn();
//    if (!m_ret) {
//        //#todo error message
//        std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << "  " << m_fd << std::endl;
//        return map_FaceDataCache();
//    }
//    map_FaceDataCache dataCache;
//    int ret;
//    ErlMessage emsg;    /* Incoming message */
//    //hanshu canshu
//    ETERM *arrlist[1];
//    arrlist[0] = erl_mk_string(TableName.c_str());
//
//    ETERM *list = erl_mk_list(arrlist, 1);
//    ret = erl_rpc_to(m_fd, "syncDB", "loadFaceFeaData", list);
//
//    if (ret == ERL_TICK) {
//        ret = erl_rpc_from(m_fd, TIMEOUT * 100000, &emsg);
//        //erl_close_connection(m_fd);
////                m_mutex.unlock();
//        if (ret == ERL_MSG) {
//            ETERM *key, *value;
//            ETERM *tuplep[20];
//            ETERM *arr_ret[2], *list_ret[5000];
//            ETERM *tail_list, *tail_tuple;
//            arr_ret[0] = erl_element(2, emsg.msg);
//            if (checkETERMType(arr_ret[0]) == ERL_LIST) {
//                int erlLength = erl_length(arr_ret[0]);
////                        printf("arr_ret[0]:%d\n", erlLength);
//                list_ret[0] = erl_hd(arr_ret[0]);
//                tail_list = erl_tl(arr_ret[0]);
//                for (int i = 0; i < erlLength; i++) {
////                            DBG(i);
//                    if (i > 0) {
//                        list_ret[i] = erl_hd(tail_list);
//                        tail_list = erl_tl(tail_list);
//                    }
//                    if (tail_list == NULL)
//                        break;
//                    if (checkETERMType(list_ret[i]) == ERL_LIST) {
//                        SyncDB::Feature_Info feature_info;
//                        int erlLength1 = erl_length(list_ret[i]);
////                                printf("list_ret[%d]:%d\n", i, erlLength1);
//                        tuplep[0] = erl_hd(list_ret[i]);
//                        tail_tuple = erl_tl(list_ret[i]);
//                        for (int j = 0; j < erlLength1; j++) {
//                            if (j > 0) {
//                                tuplep[j] = erl_hd(tail_tuple);
//                                tail_tuple = erl_tl(tail_tuple);
//                            }
//                            key = erl_element(1, tuplep[j]);
//                            value = erl_element(2, tuplep[j]);
////                                    printf("key:%s\n", erl_iolist_to_string(key));
//
//                            switch (checkETERMType(value)) {
//                                case ERL_ATOM: {
//                                    feature_info.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
//                                    break;
//                                }
//                                case ERL_LIST: {
//                                    feature_info.setValue(erl_iolist_to_string(key),
//                                                          erl_iolist_to_string(value));
//                                    break;
//                                }
//                                default:
//                                    printf("error add case todo %d\n\r", checkETERMType(value));
//                            }
//
////                                    erlangFreeEterm(2, key, value);
//                        }
////                                printf("\none list end\n\n\n\n");
//                        dataCache.insert(std::move(std::make_pair(feature_info.id, feature_info)));
////                                break;
////                                erlangFreeEterm(1, list_ret[i]);
//                    } else {
//                        ERR(" type error " << checkETERMType(list_ret[i]));
//                    }
//                }
//                erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
//                erl_eterm_release();
////                        sleep()
//                return dataCache;
//            } else {
//                ERR(" error " << checkETERMType(arr_ret[0]));
//            }
//        } else {
//            ERR(" error " << ret << "  ");
//        }
//
//    }
//    erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
//    erl_eterm_release();
//    return map_FaceDataCache();
//};

//ErlangTool::map_FaceDataCache ErlangTool::ErlangDbTool::loadFaceFeaData2(std::string TableName) {
//    std::lock_guard<std::mutex> lock(m_mutex);
////            m_mutex.lock();
//    m_ret = resetConn();
//    if (!m_ret) {
//        //#todo error message
//        ERR(" error " << m_ret << "  " << m_fd);
//        return map_FaceDataCache();
//    }
//    map_FaceDataCache dataCache;
//    int ret;
//    ErlMessage emsg;    /* Incoming message */
//    //hanshu canshu
//    ETERM *arrlist[1];
////    arrlist[0] = erl_mk_atom(TableName.c_str());
//    arrlist[0] = erl_mk_string(TableName.c_str());
//
//    ETERM *list = erl_mk_list(arrlist, 1);
//    ret = erl_rpc_to(m_fd, "syncDB", "loadFaceFeaData2", list);
//
//    if (ret == ERL_TICK) {
//        ret = erl_rpc_from(m_fd, TIMEOUT * 100000, &emsg);
//        //erl_close_connection(m_fd);
////                m_mutex.unlock();
//        if (ret == ERL_MSG) {
//            ETERM *key, *value;
//            ETERM *tuplep[20];
//            ETERM *arr_ret[2], *list_ret[5000];
//            ETERM *tail_list, *tail_tuple;
//            arr_ret[0] = erl_element(2, emsg.msg);
//            if (checkETERMType(arr_ret[0]) == ERL_LIST) {
//                int erlLength = erl_length(arr_ret[0]);
////                        printf("arr_ret[0]:%d\n", erlLength);
//                list_ret[0] = erl_hd(arr_ret[0]);
//                tail_list = erl_tl(arr_ret[0]);
//                for (int i = 0; i < erlLength; i++) {
////                            DBG(i);
//                    if (i > 0) {
//                        list_ret[i] = erl_hd(tail_list);
//                        tail_list = erl_tl(tail_list);
//                    }
//                    if (tail_list == NULL)
//                        break;
//                    if (checkETERMType(list_ret[i]) == ERL_LIST) {
//                        SyncDB::Feature_Info feature_info;
////                                feature_info.id = "test";
////                                feature_info.create_by = "";
////                                feature_info.feature ="";
////                                feature_info.update_time = "";
////                                feature_info.create_time = "";
//
//                        int erlLength1 = erl_length(list_ret[i]);
////                                printf("list_ret[%d]:%d\n", i, erlLength1);
//                        tuplep[0] = erl_hd(list_ret[i]);
//                        tail_tuple = erl_tl(list_ret[i]);
//
//                        for (int j = 0; j < erlLength1; j++) {
//                            if (j > 0) {
//                                tuplep[j] = erl_hd(tail_tuple);
//                                tail_tuple = erl_tl(tail_tuple);
//                            }
//                            key = erl_element(1, tuplep[j]);
//                            value = erl_element(2, tuplep[j]);
////                                    printf("key:%s\n", erl_iolist_to_string(key));
//
//                            switch (checkETERMType(value)) {
//                                case ERL_ATOM: {
//                                    feature_info.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
//                                    break;
//                                }
//                                case ERL_LIST: {
//                                    feature_info.setValue(erl_iolist_to_string(key),
//                                                          erl_iolist_to_string(value));
//                                    break;
//                                }
//                                default:
//                                    printf("error add case todo %d\n\r", checkETERMType(value));
//                            }
//
////                                    erlangFreeEterm(2, key, value);
//                        }
////                                printf("\none list end\n\n\n\n");
//                        dataCache.insert(std::move(std::make_pair(feature_info.id, feature_info)));
////                                break;
////                                erlangFreeEterm(1, list_ret[i]);
//                    } else {
//                        ERR(" type error " << checkETERMType(list_ret[i]));
//                    }
//                }
////                erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
////                erl_eterm_release();
////                        sleep()
//                return dataCache;
//            } else {
//                ERR(" error " << checkETERMType(arr_ret[0]));
//            }
//        } else {
//            ERR(" error " << ret << "  ");
//        }
//
//    }
//    erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
//    erl_eterm_release();
//    return map_FaceDataCache();
//};

ErlangTool::map_FaceDataCache ErlangTool::ErlangDbTool::loadFaceFeaData(std::string TableName) {
    map_FaceDataCache dataCache;

    std::string str_tableUuid;

    auto tableInfoMap = findAllDatabase();

    for (auto &item : tableInfoMap) {
        if (item.second.tableName == TableName) {
            str_tableUuid = item.second.uuid;
            break;
        }
    }
    if (str_tableUuid.size() > 0) {
        QString sql = QString::fromStdString(
            "Select a.uuid as id ,a.faceUrl as img,a.feature,b.idCard as idcard,b.enabled,b.monitorLevel from '" +
            str_tableUuid +
            "_fea' as a ,'" + str_tableUuid + "' as b  where a.uuid = b.uuid and ( a.del_flag=0 AND b.del_flag=0);");
        QSqlQuery query(g_syncDbFile);
        query.prepare(sql);
        if (!query.exec()) {
            qDebug() << "getTableNameList" << __FILE__ << __LINE__ << query.lastError();
        } else {
            while (query.next()) {
                SyncDB::Feature_Info t_feature_info;
                t_feature_info.id = query.value(0).toString().toStdString();
                t_feature_info.img = query.value(1).toString().toStdString();
                t_feature_info.feature = query.value(2).toString().toStdString();
                t_feature_info.idcard = query.value(3).toString().toStdString();
                t_feature_info.enable = query.value(4).toString().toStdString();
                t_feature_info.monLevel = query.value(5).toString().toStdString();

                dataCache.insert(std::make_pair(t_feature_info.id, t_feature_info));
            }
            return dataCache;
        }
    }
    return map_FaceDataCache();
};

ErlangTool::map_FaceDataCache ErlangTool::ErlangDbTool::loadFaceFeaData2(std::string TableName) {

    map_FaceDataCache dataCache;

    std::string str_tableUuid;

    auto tableInfoMap = findAllDatabase();

    for (auto &item : tableInfoMap) {
        if (item.second.tableName == TableName) {
            str_tableUuid = item.second.uuid;
            break;
        }
    }
    if (str_tableUuid.size() > 0) {
//        QString sql = QString::fromStdString(
//            "Select b.uuid as id,b.faceUrl as img,a.idCard as idcard,a.enable,a.monitorLevel from '" + str_tableUuid +
//            "' as a, '" + str_tableUuid + "_fea' As b  where a.uuid = b.uuid and ( a.del_flag=0 AND b.del_flag=0);");
        QString sql = QString::fromStdString(
            "Select b.uuid as id,b.faceUrl as img,a.idCard as idcard from '" + str_tableUuid +
            "' as a, '" + str_tableUuid + "_fea' As b  where a.uuid = b.uuid and ( a.del_flag=0 AND b.del_flag=0);");
        QSqlQuery query(g_syncDbFile);
        query.prepare(sql);
        if (!query.exec()) {
            qDebug() << "getTableNameList" << __FILE__ << __LINE__ << query.lastError();
        } else {
            while (query.next()) {
                SyncDB::Feature_Info t_feature_info;
                t_feature_info.id = query.value(0).toString().toStdString();
                t_feature_info.img = query.value(1).toString().toStdString();
                t_feature_info.idcard = query.value(2).toString().toStdString();
//                t_feature_info.enable = query.value(3).toString().toStdString();
//                t_feature_info.monLevel = query.value(4).toString().toStdString();

                dataCache.insert(std::make_pair(t_feature_info.id, t_feature_info));
            }
            return dataCache;
        }
    }
    return map_FaceDataCache();
};

bool ErlangTool::ErlangDbTool::resetConn() {
    //#todo
    if (m_pName.size() <= 0) {
        srand(time(0));
        m_loop = rand() % 1000;

        int ret = -1;
        erl_init(NULL, 0);
//            m_loop %= 10;
//            m_loop++;
        ret = erl_connect_init(m_loop, const_cast<char *>(m_cookie.c_str()), 0);
        DBG("node name is   " << m_loop);
        if (-1 == ret) {
//            erl_err_quit("erl_connect_init");
            return false;
        }

//            std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << "  " << m_fd << std::endl;
        erl_close_connection(m_fd);
//            std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << "  " << m_fd << std::endl;
        m_fd = erl_connect(const_cast<char *>(m_nodeName.c_str()));
//            std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << "  " << m_fd << std::endl;
        if (0 > m_fd) {
//            erl_err_quit("erl_connect");
            return false;
        }
        return true;
    } else {
        erl_close_connection(m_fd);
        m_fd = erl_connect(const_cast<char *>(m_nodeName.c_str()));
        if (0 > m_fd) {
//            erl_err_quit("erl_connect");
//            std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << " error " << fd << std::endl;
            ERR("m_fd is   " << m_fd << " m_nodeName is" << m_nodeName);
            return false;
        }
//        std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << "  " << fd << std::endl;
        INFO("m_fd is   " << m_fd << " m_nodeName is" << m_nodeName);
        return true;
    }
}

bool ErlangTool::ErlangDbTool::waitNode() {
    std::cout << "start waitNode" << std::endl;
    int loop = 0;
    while (!m_ret && loop <= 4000) {
        m_ret = ErlangTool::pingNode(m_nodeName, m_cookie);
        if (m_ret) {
//                    std::cout << "startNodeDb" << std::endl;
        } else {
//                    std::cout << "init failer" << std::endl;
            usleep(100000);
            loop++;
        }
    }
    std::cout << "start waitNode" << std::endl;
    return m_ret;
}

void ErlangTool::ErlangDbTool::test(pthread_cond_t *t_pthcon, pthread_mutex_t *t_pthmut) {
    bool ret = setCNodeName();
    {
        std::thread th1([&] {
            int res;
            pthread_cond_t *t_pthCon = t_pthcon;
            pthread_mutex_t *t_pthMut = t_pthmut;

            int listen;                              /* Listen socket */
            int fd;                                  /* fd to Erlang node */
            ErlConnect conn;                         /* Connection data */

            int loop = 1;                            /* Loop flag */
            int got;                                 /* Result of receive */
            unsigned char buf[BUFSIZE];              /* Buffer for incoming message */
            ErlMessage emsg;                         /* Incoming message */

            ETERM *fromp, *tuplep, *fnp, *argp, *resp;

            int port;                                /* Listen port number */
            port = PORT;
            /* Make a listen socket */
            if ((listen = my_listen(port)) <= 0) {
                ERR("my_listen is error");
                erl_err_quit("my_listen");
            }
            if (erl_publish(port) == -1) {
                ERR("erl_publish is error");
                erl_err_quit("erl_publish");
            }
            if ((fd = erl_accept(listen, &conn)) == ERL_ERROR) {
                ERR("erl_accept is error");
                erl_err_quit("erl_accept");
            }
            INFO("Connected to " << conn.nodename);

            while (loop) {
//        std::cout << "hello world" << std::endl;
                got = erl_receive_msg(fd, buf, BUFSIZE, &emsg);
                if (got == ERL_TICK) {
                    /* ignore */
                } else if (got == ERL_ERROR) {
                    if ((fd = erl_accept(listen, &conn)) == ERL_ERROR)
                        erl_err_quit("erl_accept");
                    INFO("Connected to " << conn.nodename);
                } else {

                    if (emsg.type == ERL_REG_SEND) {
                        fromp = erl_element(2, emsg.msg);
                        tuplep = erl_element(3, emsg.msg);
                        fnp = erl_element(1, tuplep);
                        argp = erl_element(2, tuplep);

                        if (strncmp(ERL_ATOM_PTR(fnp), "update", 6) == 0) {
                            INFO("message is  " << ERL_ATOM_PTR(fnp));
                            std::string str1(ERL_ATOM_PTR(fnp));
//                            CBF(str1);
                            DBG("erlangCallBackFunc");
                            pthread_cond_signal(t_pthCon);
                            pthread_mutex_unlock(t_pthMut);
                            //call back func
                        } else {
                            ERR("message not is  update");
                        }
//                        resp = erl_format("{c1, {res,~i}}", res);
//                        erl_send(fd, fromp, resp);

                        erl_free_term(emsg.from);
                        erl_free_term(emsg.msg);
                        erl_free_term(fromp);
                        erl_free_term(tuplep);
                        erl_free_term(fnp);
                        erl_free_term(argp);
                        erl_free_term(resp);
                        erl_close_connection(fd);
                        if ((fd = erl_accept(listen, &conn)) == ERL_ERROR)
                            erl_err_quit("erl_accept");
                        INFO("Connected to " << conn.nodename);
                    }
                }

            }
        });
        th1.detach();
    }

}

bool ErlangTool::ErlangDbTool::setCNodeName() {
    LockG lock(m_mutex);
//            m_mutex.lock();
    m_ret = resetConn();
    if (!m_ret) {
        //#todo error message
        ERR(" error " << m_ret << "  " << m_fd);
        return false;
    }
    ErlMessage emsg;             /* Incoming message */
    int ret = -1;
    ETERM *arrlist[1];
    arrlist[0] = erl_mk_atom(m_cNodeName.c_str());
//    arrlist[0] = erl_mk_atom("c1@127.0.0.1");
    ETERM *list = erl_mk_list(arrlist, 1);
    ret = erl_rpc_to(m_fd, "syncDB", "setCNode", list);
    if (ret == ERL_TICK) {
        ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
        //erl_close_connection(m_fd);
//                m_mutex.unlock();
        if (ret == ERL_MSG) {
            std::map<std::string, std::string> t_results;

            ETERM *tail_list;
            ETERM *list_ret[1000], *arr_ret[2];
            ETERM *key, *value;
            ETERM *tuplep[6];

            arr_ret[0] = erl_element(2, emsg.msg);
            int erlLength = erl_length(arr_ret[0]);
            INFO("arr_ret[0]:  " << erlLength);
            list_ret[0] = erl_hd(arr_ret[0]);
            tail_list = erl_tl(arr_ret[0]);
            for (int i = 0; i < erlLength; i++) {
                if (i > 0) {
                    list_ret[i] = erl_hd(tail_list);
                    tail_list = erl_tl(tail_list);
                }
//                    printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
                tuplep[0] = erl_hd(list_ret[i]);
                key = erl_element(1, list_ret[i]);
                value = erl_element(2, list_ret[i]);
//                    printf("key:%s\n", ERL_ATOM_PTR(key));
                switch (checkETERMType(value)) {
                    case ERL_ATOM: {
                        int atomSize = ERL_ATOM_SIZE(value);
                        char *atomValue = ERL_ATOM_PTR(value);
                        INFO("value is a atom: atomSize: " << atomSize << " , atomValue:" << atomValue << " \n\r");
                        t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
                        break;
                    }
                    default:
                        ERR("error add case todo \n\r");
                }
                erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
            }
            erlangFreeEterm(2, tail_list, arr_ret[0]);
            erl_eterm_release();
            auto it = t_results.find("atomic");
            if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
                return true;
            } else {
                ERR("res is err ");
            }
        } else {
            ERR("recv mess error : ret != ERL_MSG");
        }
    } else {
        ERR("send mess error : ret != ERL_TICK");
    }
    erl_free_array(arrlist, 1);
//            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
    erl_eterm_release();
    return false;
}

bool ErlangTool::ErlangDbTool::sendMessage() {
    LockG lock(m_mutex);
//            m_mutex.lock();
    m_ret = resetConn();
    if (!m_ret) {
        //#todo error message
        ERR(" error " << m_ret << "  " << m_fd);
        return false;
    }
    ErlMessage emsg;             /* Incoming message */
    int ret = -1;
    ETERM *list = erl_mk_empty_list();
    ret = erl_rpc_to(m_fd, "syncDB", "sendMessage", list);
    if (ret == ERL_TICK) {
        ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
        //erl_close_connection(m_fd);
//                m_mutex.unlock();
        if (ret == ERL_MSG) {
            std::map<std::string, std::string> t_results;

            ETERM *tail_list;
            ETERM *list_ret[1000], *arr_ret[2];
            ETERM *key, *value;
            ETERM *tuplep[6];

            arr_ret[0] = erl_element(2, emsg.msg);
            int erlLength = erl_length(arr_ret[0]);
            INFO("arr_ret[0]:  " << erlLength);
            list_ret[0] = erl_hd(arr_ret[0]);
            tail_list = erl_tl(arr_ret[0]);
            for (int i = 0; i < erlLength; i++) {
                if (i > 0) {
                    list_ret[i] = erl_hd(tail_list);
                    tail_list = erl_tl(tail_list);
                }
//                    printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
                tuplep[0] = erl_hd(list_ret[i]);
                key = erl_element(1, list_ret[i]);
                value = erl_element(2, list_ret[i]);
//                    printf("key:%s\n", ERL_ATOM_PTR(key));
                switch (checkETERMType(value)) {
                    case ERL_ATOM: {
                        int atomSize = ERL_ATOM_SIZE(value);
                        char *atomValue = ERL_ATOM_PTR(value);
                        INFO("value is a atom: atomSize: " << atomSize << " , atomValue:" << atomValue << " \n\r");
                        t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
                        break;
                    }
                    default:
                        ERR("error add case todo \n\r");
                }
                erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
            }
            erlangFreeEterm(2, tail_list, arr_ret[0]);
            erl_eterm_release();
            auto it = t_results.find("atomic");
            if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
                return true;
            } else {
                ERR("res is err ");
            }
        } else {
            ERR("recv mess error : ret != ERL_MSG");
        }
    } else {
        ERR("send mess error : ret != ERL_TICK");
    }
//    erl_free_array(arrlist, 1);
//            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
    erl_eterm_release();
    return false;
}

ErlangTool::vec_PerExistRet ErlangTool::ErlangDbTool::personIsExistOnClu(std::string personUid) {
    ErlangTool::vec_PerExistRet t_vec_perExistRet;

    std::lock_guard<std::mutex> lock(m_mutex);
//            m_mutex.lock();
    m_ret = resetConn();
    if (!m_ret) {
        //#todo error message
        ERR(" error " << m_ret << "  " << m_fd);
        return t_vec_perExistRet;
    }

    int ret;
    ErlMessage emsg;    /* Incoming message */
    //hanshu canshu
    ETERM *arrlist[1];
    arrlist[0] = erl_mk_string(personUid.c_str());

    ETERM *list = erl_mk_list(arrlist, 1);
    ret = erl_rpc_to(m_fd, "syncDB", "singlePersonIsExists", list);

    if (ret == ERL_TICK) {
        ret = erl_rpc_from(m_fd, TIMEOUT * 100000, &emsg);
        //erl_close_connection(m_fd);
//                m_mutex.unlock();
        if (ret == ERL_MSG) {
            ETERM *key, *value;
            ETERM *tuplep[20];
            ETERM *arr_ret[2], *list_ret[5000];
            ETERM *tail_list, *tail_tuple;
            arr_ret[0] = erl_element(2, emsg.msg);
            if (checkETERMType(arr_ret[0]) == ERL_LIST) {
                int erlLength = erl_length(arr_ret[0]);
//                        printf("arr_ret[0]:%d\n", erlLength);
                list_ret[0] = erl_hd(arr_ret[0]);
                tail_list = erl_tl(arr_ret[0]);
                for (int i = 0; i < erlLength; i++) {
//                            DBG(i);
                    if (i > 0) {
                        list_ret[i] = erl_hd(tail_list);
                        tail_list = erl_tl(tail_list);
                    }
                    if (tail_list == NULL)
                        break;
                    if (checkETERMType(list_ret[i]) == ERL_LIST) {
                        SyncDB::PerExistRet perExistRet;

                        int erlLength1 = erl_length(list_ret[i]);
//                                printf("list_ret[%d]:%d\n", i, erlLength1);
                        tuplep[0] = erl_hd(list_ret[i]);
                        tail_tuple = erl_tl(list_ret[i]);

                        for (int j = 0; j < erlLength1; j++) {
                            if (j > 0) {
                                tuplep[j] = erl_hd(tail_tuple);
                                tail_tuple = erl_tl(tail_tuple);
                            }
                            key = erl_element(1, tuplep[j]);
                            value = erl_element(2, tuplep[j]);
//                                    printf("key:%s\n", erl_iolist_to_string(key));

                            switch (checkETERMType(value)) {
                                case ERL_ATOM: {
                                    perExistRet.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
                                    break;
                                }
                                case ERL_LIST: {
                                    perExistRet.setValue(erl_iolist_to_string(key),
                                                         erl_iolist_to_string(value));
                                    break;
                                }
                                default:
                                    printf("error add case todo %d\n\r", checkETERMType(value));
                            }
                        }
                        t_vec_perExistRet.push_back(perExistRet);
                    } else {
                        ERR(" type error " << checkETERMType(list_ret[i]));
                    }
                }
                erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
                erl_eterm_release();
                return t_vec_perExistRet;
            } else {
                ERR(" error " << checkETERMType(arr_ret[0]));
            }
        } else {
            ERR(" error " << ret << "  ");
        }
    }
    erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
    erl_eterm_release();
    return t_vec_perExistRet;
}

ErlangTool::vec_UpdPersRet
ErlangTool::ErlangDbTool::singlePersonUpdate(std::string NewPerId, std::string OldId, std::string Idcard,
                                             std::string PerPicUrl, std::string PerFea) {
    ErlangTool::vec_UpdPersRet t_vec_UpdPersRet;

    std::lock_guard<std::mutex> lock(m_mutex);
//            m_mutex.lock();
    m_ret = resetConn();
    if (!m_ret) {
        //#todo error message
        ERR(" error " << m_ret << "  " << m_fd);
        return t_vec_UpdPersRet;
    }

    int ret;
    ErlMessage emsg;    /* Incoming message */
    //hanshu canshu
    ETERM *arrlist[5];
    arrlist[0] = erl_mk_atom(NewPerId.c_str());
    arrlist[1] = erl_mk_atom(OldId.c_str());
    arrlist[2] = erl_mk_atom(Idcard.c_str());
    arrlist[3] = erl_mk_atom(PerPicUrl.c_str());
    arrlist[4] = erl_mk_string(PerFea.c_str());

    ETERM *list = erl_mk_list(arrlist, 5);
    ret = erl_rpc_to(m_fd, "syncDB", "singlePersonUpdate", list);

    if (ret == ERL_TICK) {
        ret = erl_rpc_from(m_fd, TIMEOUT * 100000, &emsg);
        //erl_close_connection(m_fd);
//                m_mutex.unlock();
        if (ret == ERL_MSG) {
            ETERM *key, *value;
            ETERM *tuplep[20];
            ETERM *arr_ret[2], *list_ret[5000];
            ETERM *tail_list, *tail_tuple;
            arr_ret[0] = erl_element(2, emsg.msg);
            if (checkETERMType(arr_ret[0]) == ERL_LIST) {
                int erlLength = erl_length(arr_ret[0]);
//                        printf("arr_ret[0]:%d\n", erlLength);
                list_ret[0] = erl_hd(arr_ret[0]);
                tail_list = erl_tl(arr_ret[0]);
                for (int i = 0; i < erlLength; i++) {
//                            DBG(i);
                    if (i > 0) {
                        list_ret[i] = erl_hd(tail_list);
                        tail_list = erl_tl(tail_list);
                    }
                    if (tail_list == NULL)
                        break;
                    if (checkETERMType(list_ret[i]) == ERL_LIST) {
                        SyncDB::UpdPersRet updPersRet;

                        int erlLength1 = erl_length(list_ret[i]);
//                                printf("list_ret[%d]:%d\n", i, erlLength1);
                        tuplep[0] = erl_hd(list_ret[i]);
                        tail_tuple = erl_tl(list_ret[i]);

                        for (int j = 0; j < erlLength1; j++) {
                            if (j > 0) {
                                tuplep[j] = erl_hd(tail_tuple);
                                tail_tuple = erl_tl(tail_tuple);
                            }
                            key = erl_element(1, tuplep[j]);
                            value = erl_element(2, tuplep[j]);
//                                    printf("key:%s\n", erl_iolist_to_string(key));

                            switch (checkETERMType(value)) {
                                case ERL_ATOM: {
                                    updPersRet.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
                                    break;
                                }
                                case ERL_LIST: {
                                    updPersRet.setValue(erl_iolist_to_string(key),
                                                        erl_iolist_to_string(value));
                                    break;
                                }
                                default:
                                    printf("error add case todo %d\n\r", checkETERMType(value));
                            }
                        }
                        t_vec_UpdPersRet.push_back(updPersRet);
                    } else {
                        ERR(" type error " << checkETERMType(list_ret[i]));
                    }
                }
                erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
                erl_eterm_release();
                return t_vec_UpdPersRet;
            } else {
                ERR(" error " << checkETERMType(arr_ret[0]));
            }
        } else {
            ERR(" error " << ret << "  ");
        }
    }
    erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
    erl_eterm_release();
    return t_vec_UpdPersRet;
}

static int ErlangTool::my_listen(int port) {
    int listen_fd;
    struct sockaddr_in addr;
    int on = 1;

    if ((listen_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
        return (-1);

    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

    memset((void *) &addr, 0, (size_t) sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(listen_fd, (struct sockaddr *) &addr, sizeof(addr)) < 0)
        return (-1);

    listen(listen_fd, 5);
    return listen_fd;
}