/**
 * Tencent is pleased to support the open source community by making Tars available.
 *
 * Copyright (C) 2016THL A29 Limited, a Tencent company. All rights reserved.
 *
 * Licensed under the BSD 3-Clause License (the "License"); you may not use this file except 
 * in compliance with the License. You may obtain a copy of the License at
 *
 * https://opensource.org/licenses/BSD-3-Clause
 *
 * Unless required by applicable law or agreed to in writing, software distributed 
 * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
 * CONDITIONS OF ANY KIND, either express or implied. See the License for the 
 * specific language governing permissions and limitations under the License.
 */

#include "QueryServer.h"
#include "QueryImp.h"

using namespace std;

QueryServer g_app;

TC_Config * g_pconf;
/////////////////////////////////////////////////////////////////

struct JsonProtocol
{
    
    static int parse(string &in, string &out)
    {
        TLOGINFO("JsonProtocol parse:" << in << endl);

        string::size_type jsonEnd = in.find("}");

        if (jsonEnd != string::npos )
        {
            out = in;
            in = "";
            return TC_EpollServer::PACKET_FULL;   //返回1表示收到的包已经完全
        }

        return TC_EpollServer::PACKET_ERR;        //返回-1表示收到包协议错误，框架会自动关闭当前连接
    }
};



void  QueryServer::initialize()
{
    //initialize application here:
    //...
    vector<string> v_dblist;
    vector<string> v_dbcountlist;

    g_pconf->getDomainVector("/tars/countdb", v_dbcountlist);

    size_t iDbNumber = v_dblist.size();

    size_t iDbCountNumber = v_dbcountlist.size();

    TLOGDEBUG("QueryServer::initialize stat dbstat size:" << iDbNumber << "|dbcount size:" << iDbCountNumber << endl);

    for(size_t i = 0; i < iDbCountNumber; i++)
    {
        TC_DBConf tcDBConf;

        string path= "/tars/countdb/" + v_dbcountlist[i];

        tcDBConf.loadFromMap(g_pconf->getDomainMap(path));

        _dbStatInfo.push_back(tcDBConf);
    }

    _activeDbInfo = _dbStatInfo;

    _dBThread = new DBThread();

    _dBThread->start();

    _queryFlag.insert("f_date");
    _queryFlag.insert("f_tflag");
    _queryFlag.insert("master_name");
    _queryFlag.insert("slave_name");
    _queryFlag.insert("slave_ip");
    _queryFlag.insert("interface_name");

    _insertInterval = TC_Common::strto<int>(g_pconf->get("/tars<interval>","5"));

    size_t iDbThreadPoolSize = TC_Common::strto<int>(g_pconf->get("/tars/threadpool<count_db_tpoolsize>","8"));

    size_t iTimeCheckPoolSize = TC_Common::strto<int>(g_pconf->get("/tars/threadpool<time_check_tpoolsize>","8"));

    size_t iQueryDbPoolSize = TC_Common::strto<int>(g_pconf->get("/tars/threadpool<query_countdb_tpoolsize>","4"));

    _timeCheck.init(iTimeCheckPoolSize);

    _timeCheck.start();

    _poolDb.init(iDbThreadPoolSize);

    _poolDb.start();

    _tpoolQueryDb = new QueryDbThread();

    _tpoolQueryDb->start(iQueryDbPoolSize);

    vector<string> vIpGroup = g_pconf->getDomainKey("/tars/notarsslavename");
    TLOGDEBUG("QueryServer::initialize vIpGroup size:" << vIpGroup.size() << endl);
    for (unsigned i = 0; i < vIpGroup.size(); i++)
    {
        _notTarsSlaveName.insert(vIpGroup[i]);
        TLOGDEBUG("QueryServer::initialize i:" << i << "|notarsslavename:" << vIpGroup[i] << endl);
    }
    addServant<QueryImp>(ServerConfig::Application + "." + ServerConfig::ServerName + ".NoTarsObj");
    addServantProtocol(ServerConfig::Application + "." + ServerConfig::ServerName + ".NoTarsObj", &JsonProtocol::parse);
}
/////////////////////////////////////////////////////////////////

void QueryServer::setActiveDb(const vector<TC_DBConf> &vDbInfo)
{
    TC_LockT<TC_ThreadMutex> lock(*this);
    _activeDbInfo = vDbInfo;
}

vector<TC_DBConf> QueryServer::getAllActiveDbInfo() const
{
    TC_LockT<TC_ThreadMutex> lock(*this);
    vector<TC_DBConf> vDbInfo;
    for(size_t i = 0; i < _activeDbInfo.size(); ++i)
    {
        vDbInfo.push_back(_activeDbInfo[i]);
    }

    return vDbInfo;
}

vector<TC_DBConf> QueryServer::getDbInfo() const
{
    TC_LockT<TC_ThreadMutex> lock(*this);
    return _dbStatInfo;
}

vector<TC_DBConf> QueryServer::getActiveDbInfo() const
{
    TC_LockT<TC_ThreadMutex> lock(*this);
    return _activeDbInfo;
}

uint32_t QueryServer::genUid()
{
    TC_LockT<TC_ThreadMutex> lock(*this);

    while (++_uniqId == 0);

    return _uniqId;
}

string QueryServer::dumpDbInfo(const vector<TC_DBConf>& vDbInfo) const
{
    ostringstream os;

    os <<endl;
    for(size_t i = 0; i < vDbInfo.size();i++)
    {
        os << "[charset]=[" <<vDbInfo[i]._charset <<"] "
           << "[dbhost]=[" <<vDbInfo[i]._host <<"] "
           << "[dbpass]=[" <<vDbInfo[i]._password <<"] "
           << "[dbport]=[" <<TC_Common::tostr(vDbInfo[i]._port) <<"] "
           << "[dbuser]=[" <<vDbInfo[i]._user <<"]"
           <<endl;
    }
    return os.str();
}

bool QueryServer::searchQueryFlag(const string &sKey)
{
    set<string>::const_iterator it = _queryFlag.find(sKey);
    if(it != _queryFlag.end())
    {
        return true;
    }
    return false;
}

set<string>& QueryServer::getNotTarsSlaveName()
{
    return _notTarsSlaveName;
}

/////////////////////////////////////////////////////////////////
void
QueryServer::destroyApp()
{
    //destroy application here:
    //...
    if(_dBThread)
    {
        delete _dBThread;
        _dBThread = NULL;
    }

    if(_tpoolQueryDb)
    {
        delete _tpoolQueryDb;
        _tpoolQueryDb = NULL;
    }

    bool b = _poolDb.waitForAllDone(1000);

    TLOGDEBUG("QueryServer::destroyApp waitForAllDone _poolDb return:" << b << "|getJobNum:" << _poolDb.getJobNum() << endl);

    _poolDb.stop();

    b = _timeCheck.waitForAllDone(1000);

    TLOGDEBUG("QueryServer::destroyApp waitForAllDone _timeCheck return:" << b << "|getJobNum:" << _timeCheck.getJobNum() << endl);

    _timeCheck.stop();
}
/////////////////////////////////////////////////////////////////
int
main(int argc, char* argv[])
{
    try
    {
        g_pconf =  & g_app.getConfig();
        g_app.main(argc, argv);
        TarsTimeLogger::getInstance()->enableRemote("inout",false);
        g_app.waitForShutdown();
    }
    catch (std::exception& e)
    {
        cerr << "std::exception:" << e.what() << std::endl;
    }
    catch (...)
    {
        cerr << "unknown exception." << std::endl;
    }
    return -1;
}
/////////////////////////////////////////////////////////////////