#include <expected>
#include <string>
#include <cstring>
#include <iostream>

#include <control.pb.h>

#include <rpcclient.hpp>
#include <nethandler.hpp>
#include <service.hpp>
#include <logger.hpp>
#include <rpcheader.hpp>


class TestRPCHandler : public NetHandler {
public:
        std::expected<void, std::string> Handle(std::string& req, std::string& res) override;
};

std::expected<void, std::string>  TestRPCHandler::Handle(std::string& rawReq, std::string& rawRes) {
        control::HelloRequest pbReq;
        pbReq.ParseFromString(rawReq);
        logger.Log(std::format("rpcName: {}", pbReq.meta().rpcname()));
        logger.Log(std::format("req message: {}", pbReq.message()));

        control::HelloResult pbRes;
        pbRes.set_message("Johnny!");
        logger.Log(std::format("res message: {}", pbRes.message()));

        auto resMeta = pbRes.mutable_meta();
        resMeta->set_error(false);
        pbRes.SerializeToString(&rawRes);
        return {};
}



class TestSocketHandler : public SocketHandler {
private:
        NetHandler* nextHandler;
public:
        TestSocketHandler(NetHandler& rcpHandler);
        virtual void Handle(int sock) override;
        virtual ~TestSocketHandler(void) override;
};

TestSocketHandler::TestSocketHandler(NetHandler& rpcHandler) {
        nextHandler = &rpcHandler;
}

TestSocketHandler::~TestSocketHandler(void) {};


void TestSocketHandler::Handle(int sock) {
        logger.Log(std::format("Handler {} start", sock));

        const int headerSize = rpcHeaderSize;
        std::string inRawHeader(headerSize, '\0');
        int rsize = 0;
        if ((rsize = read(sock, inRawHeader.data(), inRawHeader.size())) < 0) {
                logger.Log("Error read");
                close(sock);
                return;
        }
        logger.Log(std::format("header read size {}", rsize));

        RPCHeader inHeader;
        inHeader.Decode(inRawHeader);
        int inPacketSize = inHeader.PacketSize();
        logger.Log(std::format("rpc packet size {}", inPacketSize));

        std::string inRawRequest(inPacketSize, '\0');
        if ((rsize = read(sock, inRawRequest.data(), inRawRequest.size())) < 0) {
                logger.Log("Error read");
                close(sock);
                return;
        }
        logger.Log(std::format("rpc packet rsize {}", rsize));

        std::string outRawResult;
        nextHandler->Handle(inRawRequest, outRawResult);

        RPCHeader outHeader(outRawResult.size());
        auto rawPacket = outHeader.Encode();
        rawPacket.append(outRawResult);

        int wsize = 0;
        if ((wsize = write(sock, rawPacket.data(), rawPacket.size())) < 0) {
                logger.Log("Error write");
                close(sock);
                return;
        }

        logger.Log(std::format("Handler {} done", sock));
        close(sock);
}

int main(int argc, char** argv) {
        Service svc(1025);
        auto bindres = svc.Bind();
        if (!bindres) {
                std::cerr << bindres.error() << std::endl;
                return 1;
        }

        TestRPCHandler rcpHandler;
        TestSocketHandler socketHandler(rcpHandler);
        auto listres = svc.Listen(&socketHandler);
        if (!listres) {
                std::cerr << listres.error() << std::endl;
                return 1;
        }
}