#include "precompile.h"

#include "framework/cpp/protoutils.h"

#include <a8/tcpclient.h>
#include <a8/asynctcpclient.h>
#include <a8/tcplistener.h>

#include <google/protobuf/message.h>
#include <google/protobuf/descriptor.h>

namespace f8
{

    MsgHdr* MsgHdr::Clone()
    {
        MsgHdr* hdr = (MsgHdr*)malloc(sizeof(MsgHdr));
        *hdr = *this;
        if (hdr->buflen > 0) {
            hdr->buf = (char*)malloc(hdr->buflen);
            memmove((void*)hdr->buf, (void*)buf, buflen);
        }
        return hdr;
    }

    void MsgHdr::Destroy(MsgHdr* hdr)
    {
        if (hdr->buf) {
            free((void*)hdr->buf);
        }
        free((void*)hdr);
    }

    int Net_GetMessageId(const ::google::protobuf::Message& msg)
    {
        std::string msgname;
        {
            std::string full_msgname = msg.GetTypeName();
            std::vector<std::string> strings;
            a8::Split(full_msgname, strings, '.');
            msgname = strings[strings.size() - 1];
        }
        assert(msgname.size() > 2);
        if (msgname.size() < 2) {
            abort();
            return 0;
        }
        std::string msgid_enum_name;
        #ifdef MATCHVS
        if (msgname[0] == 'C' && msgname[1] == 'M') {
            msgid_enum_name = "kingsomevs.CMMessageId_e";
        } else if (msgname[0] == 'S' && msgname[1] == 'M') {
            msgid_enum_name = "kingsomevs.SMMessageId_e";
        } else if (msgname[0] == 'S' && msgname[1] == 'S') {
            msgid_enum_name = "ss.SSMessageId_e";
        #else
        if (msgname[0] == 'C' && msgname[1] == 'M') {
            msgid_enum_name = "cs.CMMessageId_e";
        } else if (msgname[0] == 'S' && msgname[1] == 'M') {
            msgid_enum_name = "cs.SMMessageId_e";
        } else if (msgname[0] == 'S' && msgname[1] == 'S') {
            msgid_enum_name = "ss.SSMessageId_e";
        } else if (msgname[0] == 'I' && msgname[1] == 'M') {
            msgid_enum_name = "im.IMMessageId_e";
        #endif
        } else {
            assert(false);
            abort();
            return 0;
        }

        auto msgid_enum = ::google::protobuf::DescriptorPool::generated_pool()->FindEnumTypeByName(msgid_enum_name);
        assert(msgid_enum);
        if (!msgid_enum) {
            abort();
            return 0;
        }
        auto msgid_value = msgid_enum->FindValueByName("_" + msgname);
        assert(msgid_value);
        if (!msgid_value) {
            abort();
            return 0;
        }
        return msgid_value->number();
    }

    void Net_PackMsg(unsigned short msgid, ::google::protobuf::Message& msg, std::string& out)
    {
        int packlen = msg.ByteSize();

        out.resize(sizeof(PackHead) + packlen);
        char* buff = (char*)out.data();
        PackHead* head = (PackHead*)buff;
        head->packlen = packlen;
        head->msgid = msgid;
        head->magic_code = MAGIC_CODE;
        msg.SerializeToArray(buff + sizeof(PackHead), packlen);
    }

    void Net_PackMsgOld(unsigned short msgid, ::google::protobuf::Message& msg, std::string& out)
    {
        int packlen = msg.ByteSize();

        out.resize(sizeof(PackHeadOld) + packlen);
        char* buff = (char*)out.data();
        PackHeadOld* head = (PackHeadOld*)buff;
        head->packlen = packlen;
        head->msgid = msgid;
        head->magiccode = MAGIC_CODE;
        msg.SerializeToArray(buff + sizeof(PackHeadOld), packlen);
    }

    int Net_SendMsg(a8::TcpClient* tcp_client, unsigned seqid, unsigned short msgid,
                    const ::google::protobuf::Message& msg)
    {
        int packlen = msg.ByteSize();

        char* buff = (char*)malloc(sizeof(PackHead) + packlen);
        PackHead* head = (PackHead*)buff;
        head->packlen = packlen;
        head->msgid = msgid;
        head->seqid = seqid;
        head->magic_code = MAGIC_CODE;
        head->ext_len = packlen >> 16;
        msg.SerializeToArray(buff + sizeof(PackHead), packlen);
        tcp_client->SendBuff(buff, sizeof(PackHead) + packlen);
        free(buff);
        return sizeof(PackHead) + packlen;
    }

    int Net_SendMsgOld(a8::TcpClient* tcp_client, unsigned int seqid,
                       unsigned short msgid, ::google::protobuf::Message& msg)
    {
        int packlen = msg.ByteSize();

        char* buff = (char*)malloc(sizeof(f8::PackHeadOld) + packlen);
        f8::PackHeadOld* head = (f8::PackHeadOld*)buff;
        head->packlen = packlen;
        head->msgid = msgid;
        head->magiccode = MAGIC_CODE;
        msg.SerializeToArray(buff + sizeof(f8::PackHeadOld), packlen);
        tcp_client->SendBuff(buff, sizeof(f8::PackHeadOld) + packlen);
        free(buff);
        return sizeof(f8::PackHeadOld) + packlen;
    }

    int Net_SendMsg(a8::AsyncTcpClient* tcp_client, unsigned seqid, unsigned short msgid,
                    const ::google::protobuf::Message& msg)
    {
        int packlen = msg.ByteSize();
        assert(packlen < 1024 * 60);

        char* buff = (char*)malloc(sizeof(PackHead) + packlen);
        PackHead* head = (PackHead*)buff;
        head->packlen = packlen;
        head->msgid = msgid;
        head->seqid = seqid;
        head->magic_code = MAGIC_CODE;
        head->ext_len = 0;
        msg.SerializeToArray(buff + sizeof(PackHead), packlen);
        tcp_client->SendBuff(buff, sizeof(PackHead) + packlen);
        free(buff);
        return sizeof(PackHead) + packlen;
    }

    int Net_SendBigMsg(a8::TcpClient* tcp_client, unsigned seqid, unsigned short msgid,
                    ::google::protobuf::Message& msg)
    {
        int packlen = msg.ByteSize();

        char* buff = (char*)malloc(sizeof(f8::BigPackHead) + packlen);
        f8::BigPackHead* head = (f8::BigPackHead*)buff;
        head->packlen = packlen;
        head->msgid = msgid;
        head->seqid = seqid;
        head->magic_code = MAGIC_CODE;
        head->rpc_error_code = 0;
        msg.SerializeToArray(buff + sizeof(f8::BigPackHead), packlen);
        tcp_client->SendBuff(buff, sizeof(f8::BigPackHead) + packlen);
        free(buff);
        return sizeof(f8::BigPackHead) + packlen;
    }

    int Net_SendMsg(a8::TcpListener* tcp_listener, unsigned short socket_handle, unsigned int seqid,
                    unsigned short msgid, const ::google::protobuf::Message& msg)
    {
        int packlen = msg.ByteSize();

        char* buff = (char*)malloc(sizeof(PackHead) + packlen);
        PackHead* head = (PackHead*)buff;
        head->packlen = packlen;
        head->msgid = msgid;
        head->seqid = seqid;
        head->magic_code = MAGIC_CODE;
        head->ext_len = packlen >> 16;
        msg.SerializeToArray(buff + sizeof(PackHead), packlen);
        tcp_listener->SendClientMsg(socket_handle, buff, sizeof(PackHead) + packlen);
        free(buff);
        return sizeof(PackHead) + packlen;
    }

    int Net_SendMsgOld(a8::TcpListener* tcp_listener, unsigned short socket_handle, unsigned int seqid,
                       unsigned short msgid, ::google::protobuf::Message& msg)
    {
        int packlen = msg.ByteSize();

        char* buff = (char*)malloc(sizeof(PackHeadOld) + packlen);
        PackHeadOld* head = (PackHeadOld*)buff;
        head->packlen = packlen;
        head->msgid = msgid;
        head->magiccode = MAGIC_CODE;
        msg.SerializeToArray(buff + sizeof(PackHeadOld), packlen);
        tcp_listener->SendClientMsg(socket_handle, buff, sizeof(PackHeadOld) + packlen);
        free(buff);
        return sizeof(PackHeadOld) + packlen;
    }

    int Net_SendBigMsg(a8::TcpListener* tcp_listener, unsigned short socket_handle, unsigned int seqid,
                       unsigned short msgid, ::google::protobuf::Message& msg)
    {
        int packlen = msg.ByteSize();

        char* buff = (char*)malloc(sizeof(f8::BigPackHead) + packlen);
        f8::BigPackHead* head = (f8::BigPackHead*)buff;
        head->packlen = packlen;
        head->msgid = msgid;
        head->seqid = seqid;
        head->magic_code = MAGIC_CODE;
        head->rpc_error_code = 0;
        msg.SerializeToArray(buff + sizeof(f8::BigPackHead), packlen);
        tcp_listener->SendClientMsg(socket_handle, buff, sizeof(f8::BigPackHead) + packlen);
        free(buff);
        return sizeof(f8::BigPackHead) + packlen;
    }

    int Net_BroadcastMsg(a8::TcpListener* tcp_listener, unsigned int seqid,
                         unsigned short msgid, ::google::protobuf::Message& msg)
    {
        int packlen = msg.ByteSize();

        char* buff = (char*)malloc(sizeof(PackHead) + packlen);
        PackHead* head = (PackHead*)buff;
        head->packlen = packlen;
        head->msgid = msgid;
        head->seqid = seqid;
        head->magic_code = MAGIC_CODE;
        head->ext_len = packlen >> 16;
        msg.SerializeToArray(buff + sizeof(PackHead), packlen);
        tcp_listener->BroadcastMsg(buff, sizeof(PackHead) + packlen);
        free(buff);
        return sizeof(PackHead) + packlen;
    }

    int Net_BroadcastBigMsg(a8::TcpListener* tcp_listener, unsigned int seqid,
                            unsigned short msgid, ::google::protobuf::Message& msg)
    {
        int packlen = msg.ByteSize();

        char* buff = (char*)malloc(sizeof(f8::BigPackHead) + packlen);
        f8::BigPackHead* head = (f8::BigPackHead*)buff;
        head->packlen = packlen;
        head->msgid = msgid;
        head->seqid = seqid;
        head->magic_code = MAGIC_CODE;
        head->rpc_error_code = 0;
        msg.SerializeToArray(buff + sizeof(f8::BigPackHead), packlen);
        tcp_listener->BroadcastMsg(buff, sizeof(f8::BigPackHead) + packlen);
        free(buff);
        return sizeof(f8::BigPackHead) + packlen;
    }

    int Net_SendProxyCMsg(a8::TcpClient* tcp_client, unsigned short socket_handle,
                          unsigned short msgid, ::google::protobuf::Message& msg)
    {
        int packlen = msg.ByteSize();
        assert(packlen < 1024 * 60);

        char* buff = (char*)malloc(sizeof(WSProxyPackHead_C) + packlen);
        memset(buff, 0, sizeof(WSProxyPackHead_C));
        WSProxyPackHead_C* head = (WSProxyPackHead_C*)buff;
        head->packlen = packlen;
        head->msgid = msgid;
        head->seqid = 0;
        head->magic_code = MAGIC_CODE;
        head->ip_saddr = 0;
        head->socket_handle = socket_handle;

        if (packlen > 0) {
            msg.SerializeToArray(buff + sizeof(WSProxyPackHead_C), packlen);
        }
        tcp_client->SendBuff(buff, sizeof(WSProxyPackHead_C) + packlen);
        free(buff);
        return sizeof(WSProxyPackHead_C) + packlen;
    }

    int Net_SendProxyCMsg(a8::AsyncTcpClient* tcp_client, unsigned short socket_handle,
                          unsigned short msgid, ::google::protobuf::Message& msg)
    {
        int packlen = msg.ByteSize();
        assert(packlen < 1024 * 60);

        char* buff = (char*)malloc(sizeof(WSProxyPackHead_C) + packlen);
        memset(buff, 0, sizeof(WSProxyPackHead_C));
        WSProxyPackHead_C* head = (WSProxyPackHead_C*)buff;
        head->packlen = packlen;
        head->msgid = msgid;
        head->seqid = 0;
        head->magic_code = MAGIC_CODE;
        head->ip_saddr = 0;
        head->socket_handle = socket_handle;

        if (packlen > 0) {
            msg.SerializeToArray(buff + sizeof(WSProxyPackHead_C), packlen);
        }
        tcp_client->SendBuff(buff, sizeof(WSProxyPackHead_C) + packlen);
        free(buff);
        return sizeof(WSProxyPackHead_C) + packlen;
    }

    int Net_SendProxyMsg(a8::TcpListener* tcp_listener, int socket_handle,
                         unsigned int seqid, unsigned short error_code,
                         unsigned short msgid, ::google::protobuf::Message& msg)
    {
        unsigned short parent_socket_handle = (socket_handle >> 16) & 0xFFFF;
        unsigned short child_socket_handle = socket_handle & 0xFFFF;

        int packlen = msg.ByteSize();

        char* buff = (char*)malloc(sizeof(WSProxyPackHead_S) + packlen);
        WSProxyPackHead_S* head = (WSProxyPackHead_S*)buff;
        head->packlen = packlen;
        head->msgid = msgid;
        head->seqid = seqid;
        head->magic_code = MAGIC_CODE;
        head->rpc_error_code = error_code;
        head->socket_handle = child_socket_handle;
        head->ext_len = packlen >> 16;

        msg.SerializeToArray(buff + sizeof(WSProxyPackHead_S), packlen);
        tcp_listener->SendClientMsg(parent_socket_handle, buff, sizeof(WSProxyPackHead_S) + packlen);
        free(buff);
        return sizeof(WSProxyPackHead_S) + packlen;
    }

    int Net_SendProxyMsg(a8::TcpListener* tcp_listener, int socket_handle,
                         unsigned int seqid, unsigned short error_code,
                         unsigned short msgid, const std::string& data)
    {
        unsigned short parent_socket_handle = (socket_handle >> 16) & 0xFFFF;
        unsigned short child_socket_handle = socket_handle & 0xFFFF;

        int packlen = data.size();

        char* buff = (char*)malloc(sizeof(WSProxyPackHead_S) + packlen);
        WSProxyPackHead_S* head = (WSProxyPackHead_S*)buff;
        head->packlen = packlen;
        head->msgid = msgid;
        head->seqid = seqid;
        head->magic_code = MAGIC_CODE;
        head->rpc_error_code = error_code;
        head->socket_handle = child_socket_handle;
        head->ext_len = packlen >> 16;

        if (data.size() > 0) {
            memcpy(buff + sizeof(WSProxyPackHead_S), data.data(), data.size());
        }
        tcp_listener->SendClientMsg(parent_socket_handle, buff, sizeof(WSProxyPackHead_S) + packlen);
        free(buff);
        return sizeof(WSProxyPackHead_S) + packlen;
    }

}