Gui.h

#pragma once

#include <vector>
#include <string>
#include <functional>
#include <JSON.h>
#include <typeinfo> // for types in templates
#include <memory>
#include <DataBuffer.h>

// forward declarations
class WSServer;

class Gui
{
        private:

                std::vector<DataBuffer> _buffers;
                std::unique_ptr<WSServer> ws_server;

                bool wsIsConnected = false;

                void ws_connect();
                void ws_disconnect();
                void ws_onControlData(const char* data, unsigned int size);
                void ws_onData(const char* data, unsigned int size);
                int doSendBuffer(const char* type, unsigned int bufferId, const void* data, size_t size);

                unsigned int _port;
                std::string _addressControl;
                std::string _addressData;
                std::wstring _projectName;

                // User defined functions
                std::function<bool(JSONObject&, void*)> customOnControlData;
                std::function<bool(const char*, unsigned int, void*)> customOnData;

                void* controlCallbackArg = nullptr;
                void* binaryCallbackArg = nullptr;

        public:
                Gui();
                Gui(unsigned int port, std::string address);
                ~Gui();

                int setup(unsigned int port = 5555, std::string address = "gui");
                int setup(std::string projectName, unsigned int port = 5555, std::string address = "gui");
                void cleanup();

                bool isConnected(){ return wsIsConnected; };

                // BUFFERS
                unsigned int setBuffer(char bufferType, unsigned int size);
                DataBuffer& getDataBuffer(unsigned int bufferId);

                void setControlDataCallback(std::function<bool(JSONObject&, void*)> callback, void* callbackArg=nullptr){
                        customOnControlData = callback;
                        controlCallbackArg = callbackArg;
                };

                void setBinaryDataCallback(std::function<bool(const char*, unsigned int, void*)> callback, void* callbackArg=nullptr){
                        customOnData = callback;
                        binaryCallbackArg = callbackArg;
                };
                int sendControl(JSONValue* root);

                template<typename T, typename A>
                int sendBuffer(unsigned int bufferId, std::vector<T,A> & buffer);
                template <typename T, size_t N>
                int sendBuffer(unsigned int bufferId, T (&buffer)[N]);
                template <typename T>
                int sendBuffer(unsigned int bufferId, T* ptr, size_t count);
                template <typename T>
                int sendBuffer(unsigned int bufferId, T value);
};

template<typename T, typename A>
int Gui::sendBuffer(unsigned int bufferId, std::vector<T,A> & buffer)
{
        const char* type = typeid(T).name();
        return doSendBuffer(type, bufferId, (const void*)buffer.data(), (buffer.size()*sizeof(T)));
}

template <typename T, size_t N>
int Gui::sendBuffer(unsigned int bufferId, T (&buffer)[N])
{
        const char* type = typeid(T).name();
        return doSendBuffer(type, bufferId, (const void*)buffer, N*sizeof(T));
}

template <typename T>
int Gui::sendBuffer(unsigned int bufferId, T* ptr, size_t count){
        const char* type = typeid(T).name();
        return doSendBuffer(type, bufferId, ptr, count * sizeof(T));
}

template <typename T>
int Gui::sendBuffer(unsigned int bufferId, T value)
{
        const char* type = typeid(T).name();
        return doSendBuffer(type, bufferId, (const void*)&value, sizeof(T));
}