#include <a8/a8.h>

#include "framework/cpp/protoutils.h"

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

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

namespace f8
{
    int Net_GetMessageId(::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;
        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 {
            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);
    }

    int Net_SendMsg(a8::TcpClient* tcp_client, unsigned seqid, unsigned short msgid, ::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->rpc_error_code = 0;
        msg.SerializeToArray(buff + sizeof(PackHead), packlen);
        tcp_client->SendBuff(buff, sizeof(PackHead) + packlen);
        free(buff);
        return sizeof(PackHead) + packlen;
    }

    int Net_SendMsg(a8::TcpListener* tcp_listener, unsigned short socket_handle, unsigned int seqid,
                    unsigned short msgid, ::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->rpc_error_code = 0;
        msg.SerializeToArray(buff + sizeof(PackHead), packlen);
        tcp_listener->SendClientMsg(socket_handle, buff, sizeof(PackHead) + packlen);
        free(buff);
        return sizeof(PackHead) + packlen;
    }

    int Net_BroadcastMsg(a8::TcpListener* tcp_listener, unsigned int seqid,
                         unsigned short msgid, ::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->rpc_error_code = 0;
        msg.SerializeToArray(buff + sizeof(PackHead), packlen);
        tcp_listener->BroadcastMsg(buff, sizeof(PackHead) + packlen);
        free(buff);
        return sizeof(PackHead) + packlen;
    }

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

        char* buff = (char*)malloc(sizeof(WSProxyPackHead_S) + packlen);
        WSProxyPackHead_C* head = (WSProxyPackHead_C*)buff;
        head->packlen = packlen;
        head->msgid = msgid;
#if 1
        head->seqid = 0;
#else
        head->seqid = seqid;
#endif
        head->magic_code = MAGIC_CODE;
#if 0
        head->rpc_error_code = error_code;
#endif
#if 1
        head->socket_handle = 0;
#else
        head->socket_handle = child_socket_handle;
#endif

        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();
        assert(packlen < 1024 * 60);

        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->reserved = 0;

        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;
    }
}