NATIVES_SRC: java_messages.h

/*
 * Message.h
 *
 *  Created on: Aug 18, 2009
 *      Author: nenko
 */

#ifndef MESSAGE_H_
#define MESSAGE_H_

#ifdef __WIN32__
       #define WINDOWS
#endif

#ifdef __WIN64__
       #define WINDOWS
#endif

#ifdef WINDOWS
       #include <io.h>
       #include <fcntl.h>
#endif

#include <cstring>
#include "util.h"

enum CommandIds {
        STOP_COMMAND_ID = 0, START_COMMAND_ID
};

enum ResponseIds {
        OK_RESPONSE_ID = 0, ERROR_RESPONSE_ID
};

class Message {
protected:
        int id;
public:
        vector<byte> const data;

        Message(vector<byte> const& _data, int& pos) :
                data(_data) {
                //the position should be in the beginning before reading
                assert(pos == 0);
                id = readInt(data, pos);
        }

        Message(vector<byte> const& _data) :
                data(_data) {
                int pos = 0;
                id = readInt(data, pos);
        }

        virtual ~Message() {
        }

        int getId() {
                return id;
        }

        static int readInt(vector<byte> const& data, int& pos) {
                int res = 0;
                res |= data[pos++] << 0;
                res |= data[pos++] << 8;
                res |= data[pos++] << 16;
                res |= data[pos++] << 24;
                return res;
        }

        /*
         * Passing the 3rd argument (result) by reference to avoid returning the vector and copying
         * res must be empty
         */
        static void readBinData(vector<byte> const& data, int& pos, vector<byte>& res) {
                int len = readInt(data, pos);
                res.resize (len);
                memcpy (&res[0], &data[pos], len);
                pos += len;
        }

        //TODO currently will work only for ascii
        static string readStringUtf8(vector<byte> const& data, int& pos) {
                string res = "";
                int len = readInt(data, pos);
                for (int i = 0; i < len; ++i) {
                        res += char(data.at(pos++));
                }
                return res;
        }

        static void writeInt(vector<byte>& data, int value) {
                data.push_back(byte(value >> 0));
                data.push_back(byte(value >> 8));
                data.push_back(byte(value >> 16));
                data.push_back(byte(value >> 24));
                //fprintf(stderr, "int to be put: %d; bytes putted: %d %d %d %d\n", value, value >> 0, value >> 8, value >> 16, value >> 24);
//                              data.at(0), data.at(1), data.at(2), data.at(3));
        }

        //the third argument is added, because otherwise this was not consistent with readBinData
        static void writeBinData(vector<byte>& data, const vector<byte>& source, bool withSize = true) {
                if(withSize) {
                        writeInt(data, (int)source.size());
                }
                int sz = data.size ();
                data.resize (sz + source.size());
                memcpy (&data[sz], &source[0], source.size());
        }

        static void writeStringUtf8(vector<byte>& data, string const& value) {
                writeInt(data, value.size());
                for (int i = 0; i < (int) value.size(); ++i) {
                        data.push_back(value[i]);
                }
        }

};

// response do not need polymorphism 
class Response: public Message {
public:
        Response(vector<byte> const& _data) :
                Message(_data) {
        }

        static Response createOk() {
                vector<byte> data;
                writeInt(data, OK_RESPONSE_ID);
                return Response(data);
        }

        static Response createError(string const& message) {
                vector<byte> data;
                writeInt(data, ERROR_RESPONSE_ID);
                writeStringUtf8(data, message);
                return Response(data);
        }
};

// with polymorphism
class Command: public Message {
protected:
        Command(vector<byte> const& _data, int& pos) :
                Message(_data, pos) {
        }
public:
        virtual Response execute() = 0;
};

//TODO: this start and stop are not very useful
class StartCommand: public Command {
public:
        StartCommand(vector<byte> const& _data, int& pos) :
                Command(_data, pos) {
                assert(getId() == START_COMMAND_ID);
                assert(pos == (int)_data.size());
        }

        virtual Response execute();
};

//StartCommand and StopCommand should be handled by polymorphism 

class StopCommand: public Command {
public:
        StopCommand(vector<byte> const& _data, int& pos) :
                Command(_data, pos) {
                assert(getId() == STOP_COMMAND_ID);
        }

        virtual Response execute();
};

class JavaBridge {
        static JavaBridge* instance;
public:
        JavaBridge() {
                assert(instance == NULL);
                instance = this;
        }
        virtual ~JavaBridge() {
                instance = NULL;
        }

        virtual Command* createCommand(int id, vector<byte> const& data, int& pos) {
                switch (id) {
                case START_COMMAND_ID:
                        return new StartCommand(data, pos);
                case STOP_COMMAND_ID:
                        return new StopCommand(data, pos);
                default:
                        cerr << "bad id: " << id << endl;
                        throw runtime_error("Unknown command id!");
                }
        }

        void sendResponse(Response const& response) {
                int size = response.data.size();
                fwrite(&size, sizeof(int), 1, stdout);
                fwrite(&response.data[0], 1, response.data.size(), stdout);
                fflush(stdout);
        }

        //the caller is responsible to delete the returned command!
        Command* readCommand() {
                //fprintf(stderr, "readCommand(): begin reading command\n"); fflush(stderr);
                int size;
//              cin.read((char*) &size, sizeof(int));
        int rc = fread(&size, sizeof(int), 1, stdin);
        assert(rc == 1);
                //fprintf(stderr, "readCommand(): size = %d\n", size); fflush(stderr);
                vector<byte> data(size);

                rc = fread(&data[0], 1, size, stdin);
                int pos = 0;
                int id = Message::readInt(data, pos);
                pos = 0; //reset pos            
                //fprintf(stderr, "readCommand(): end reading command\n"); fflush(stderr);
                return createCommand(id, data, pos);
        }

        void mainLoop() {
//              cerr << "mainLoop()" << endl;

#ifdef WINDOWS
        _setmode( _fileno( stdin ), _O_BINARY );
            _setmode( _fileno( stdout ), _O_BINARY );
#endif

                while (true) {
                        //BEGIN_TIME;
                        Command *cmd = readCommand();
                        //                      cerr << "received command_id: " << cmd->getId() << "; executing..."     << endl;
                        assert(cmd != NULL);

                        try {
                                Response res = cmd->execute();
                                //                      cerr << "sending response: " << res.getId() << " for command id: "      << cmd->getId() << endl;
                                sendResponse(res);
                                if (cmd->getId() == STOP_COMMAND_ID) {
                                        // Temporary solution until we figure out how to kill threads
                                        exit(0);
                                        break;
                                }
                        }
                        catch(runtime_error const& ex) {
                                sendResponse(Response::createError(ex.what()));
                        }
                        //END_TIME("JavaMessages::mainLoop() loop");
                        delete cmd;
                }

        }

        static JavaBridge& getInstance() {
                return *instance;
        }

        virtual Response doStart() {
                return Response::createOk();
        }

        virtual Response doStop() {
                return Response::createOk();
        }
};

#endif /* MESSAGE_H_ */