#include "precompile.h"

#include <a8/openssl.h>
#include <a8/mutable_xobject.h>

#include "guild.h"
#include "guildmgr.h"
#include "cs_msgid.pb.h"
#include "cs_proto.pb.h"
#include "ss_proto.pb.h"
#include "IMListener.h"
#include "asynctaskmgr.h"
#include "dbengine.h"
#include "jsondatamgr.h"
#include "player.h"
#include "playermgr.h"
#include "app.h"
#include "typeconvert.h"
#include "handlermgr.h"

#include "framework/cpp/httpclientpool.h"

class AsyncGuildTask
{
public:
    int socket_handle = 0;
    long long guild_id = 0;
    time_t time = 0;
    ss::SS_IM_ForwardGuildCMMsg forward_msg;

    void Execute(Guild* guild)
    {
        f8::NetMsgHandler* handler = f8::GetNetMsgHandler(&HandlerMgr::Instance()->guild_msghandler,
                                                          forward_msg.msgid());
        if (handler && handler->handlerid == HID_Guild) {
            f8::MsgHdr hdr;
            hdr.seqid = 0;
            hdr.msgid = forward_msg.msgid();
            hdr.socket_handle = socket_handle;
            hdr.ip_saddr = 0;
            hdr.buf = forward_msg.payload().data();
            hdr.buflen = forward_msg.payload().size();
            hdr.offset = 0;
            hdr.hum = nullptr;
            hdr.user_data = &forward_msg;
            ProcessNetMsg(handler, guild, hdr);
        }
    }

    void OnError()
    {
        ss::SS_CommonError respmsg;
        respmsg.set_errcode(SERVER_INTERNAL_ERROR);
        respmsg.set_errmsg("服务器内部错误");
        GuildMgr::Instance()->ForwardGuildSMMsg(socket_handle,
                                                forward_msg.context(),
                                                forward_msg.msgid(),
                                                respmsg);
    }
};

void GuildMgr::Init()
{

}

void GuildMgr::UnInit()
{

}

void GuildMgr::_SS_IM_ForwardGuildCMMsg(f8::MsgHdr& hdr, const ss::SS_IM_ForwardGuildCMMsg& msg)
{
    if (msg.msgid() < cs::CMMessageId_e::_CMGuildMsgBegin ||
        msg.msgid() > cs::CMMessageId_e::_CMGuildMsgEnd) {
        return;
    }
    if (!IsValidGuildId(msg.guild_id())) {
        ss::SS_CommonError respmsg;
        respmsg.set_errcode(SERVER_INTERNAL_ERROR);
        respmsg.set_errmsg("服务器内部错误");
        ForwardGuildSMMsg(hdr.socket_handle, msg.context(), msg.msgid(), respmsg);
        return;
    }
    AsyncGuildTask *task = new AsyncGuildTask();
    task->forward_msg = msg;
    CreateAsyncTask(hdr.socket_handle, msg.guild_id(), task);
}

void GuildMgr::CreateAsyncTask(int socket_handle, long long guild_id, AsyncGuildTask* task)
{
    Guild* guild = GetGuild(guild_id);
    if (guild) {
        task->Execute(guild);
        delete task;
        return;
    }
    task->socket_handle = socket_handle;
    task->guild_id = guild_id;
    task->time = App::Instance()->nowtime;
    auto itr = task_hash_.find(guild_id);
    if (itr != task_hash_.end()) {
        itr->second.push_back(task);
    } else {
        task_hash_[guild_id] = std::list<AsyncGuildTask*>({task});
        LoadGuild(guild_id);
    }
}

void GuildMgr::LoadGuild(long long guild_id)
{
    if (GetGuild(guild_id)) {
        return;
    }
    if (pending_guild_hash_.find(guild_id) != pending_guild_hash_.end()) {
        return;
    }
    pending_guild_hash_.insert(guild_id);

    auto on_ok =
        [] (a8::XParams& param, const f8::DataSet* data_set)
        {
            GuildMgr::Instance()->pending_guild_hash_.erase(param.sender);
            if (data_set) {
                for (auto& row : *data_set) {
                    GuildMgr::Instance()->CreateGuild
                        (
                         a8::XValue(row[0]), //gameid
                         a8::XValue(row[1]), //guild_id
                         row[3], //guild_name
                         a8::XValue(row[4]), //guild_lv
                         a8::XValue(row[5]), //guild_exp
                         a8::XValue(row[6]), //guild_badge
                         a8::XValue(row[7]), //guild_apply_num
                         row[8], //guild_members
                         row[9], //guild_notice
                         row[10], //guild_declaration
                         row[11], //guild_log
                         row[12], //owner_id
                         row[13], //owner_name
                         row[14], //owner_avatar_url
                         row[15], //creator_id
                         row[16], //creator_name
                         row[17], //creator_avatar_url
                         row[18], //guild_data
                         a8::XValue(19), //guild_status
                         a8::XValue(20) //createtime
                         );
                    break;
                }
            }
        };
    auto on_error =
        [] (a8::XParams& param, int error_code, const std::string& error_msg)
        {
            GuildMgr::Instance()->pending_guild_hash_.erase(param.sender);
            auto itr = GuildMgr::Instance()->task_hash_.find(param.sender);
            if (itr != GuildMgr::Instance()->task_hash_.end()) {
                for (auto task : itr->second) {
                    task->OnError();
                    delete task;
                }
                GuildMgr::Instance()->task_hash_.erase(itr);
            }
           };

    a8::XObject conn_info = DBEngine::Instance()->GetConnInfo(guild_id);
    DBEngine::Instance()->ExecAsyncQuery
        (
         conn_info,
         "SELECT gameid, guild_id, guild_name, guild_lv, guild_exp, guild_badge, guild_apply_num, "
         "  guild_members, guild_notice, guild_declaration, guild_log, "
         "  owner_id, owner_name, owner_avatar_url, "
         "  creator_id, creator_name, creator_avatar_url, guild_data, guild_status, createtime "
         "WHERE guild_id=%d;",
         {
             guild_id
         },
         a8::XParams()
         .SetSender(guild_id),
         on_ok,
         on_error,
         guild_id
         );
}

bool GuildMgr::IsValidGuildId(long long guild_id)
{
    return JsonDataMgr::Instance()->GetIMInstanceId(guild_id) == App::Instance()->instance_id;
}

Guild* GuildMgr::GetGuild(long long guild_id)
{
    auto itr = id_hash_.find(guild_id);
    return itr != id_hash_.end() ? itr->second : nullptr;
}

void GuildMgr::ForwardGuildSMMsg(int socket_handle,
                                 const ss::MFIMMsgConext& context,
                                 int msgid,
                                 const ::google::protobuf::Message& smmsg)
{
    ss::SS_IM_ForwardGuildSMMsg msg;
    *msg.mutable_context() = context;
    msg.set_msgid(msgid);
    smmsg.SerializeToString(msg.mutable_payload());
    IMListener::Instance()->SendMsg(socket_handle, msg);
}

void GuildMgr::CreateGuild(int gameid,
                           long long guild_id,
                           const std::string& guild_name,
                           int guild_lv,
                           int guild_exp,
                           int guild_badge,
                           int guild_apply_num,
                           const std::string& guild_members,
                           const std::string& guild_notice,
                           const std::string& guild_declaration,
                           const std::string& guild_log,
                           const std::string& owner_id,
                           const std::string& owner_name,
                           const std::string& owner_avatar_url,
                           const std::string& creator_id,
                           const std::string& creator_name,
                           const std::string& creator_avatar_url,
                           const std::string& guild_data,
                           int guild_status,
                           int createtime
                           )
{
    if (GetGuild(guild_id)) {
        abort();
    }
    Guild* guild = new Guild;
    guild->gameid_ = gameid;
    guild->guild_id_ = guild_id;
    guild->guild_name_ = guild_name;
    guild->guild_lv_ = guild_lv;
    guild->guild_exp_ = guild_exp;
    guild->guild_badge_ = guild_badge;
    guild->guild_apply_num_ = guild_apply_num;
    guild->guild_notice_ = guild_notice;
    guild->guild_declaration_ = guild_declaration;
    guild->owner_id_ = owner_id;
    guild->owner_name_ = owner_name;
    guild->owner_avatar_url_ = owner_avatar_url;
    guild->creator_id_ = creator_id;
    guild->creator_name_ = creator_name;
    guild->creator_avatar_url_ = creator_avatar_url;
    guild->guild_status_ = guild_status;
    guild->createtime_ = createtime;
    //guild_members
    guild->Deserialize(guild_data, guild_log);
    id_hash_[guild_id] = guild;
}