CCats/cli/include/ioman.h

#ifndef IOMAN_H
#define IOMAN_H

#include "cmdman.h"
#include "fileman.h"

#include <boost/asio.hpp>
#include <condition_variable>
#include <json/json.h>
#include <mutex>
#include <string>
#include <thread>
#include <vector>

using boost::asio::ip::tcp;

/**
 * @class IoMan
 *
 * Input/Output manager
 *
 * Provides the glue logic for getting user and network input
 * as well as providing user and network output
 */
class IoMan {
	/* this is technically private and protected stuff which needs to be public
	 * for the readline callback */
public:
	/**
	 * Type of message to be output
	 */
	enum OutMsgType { normal, error, debug };
	/**
	 * Output msg to the user, treating it as type
	 */
	virtual void printMessage(std::string msg, OutMsgType type);
	/**
	 * Flag wether to keep the main thread running
	 * Matching mutex to provide syncthonizes access
	 */
	bool runmain;
	std::mutex mainmutex;
	/**
	 * Vector to hold input generated/fetched locally (e.g. from the user)
	 * Matching condition variable to wake up waiting threads
	 * Matching mutex to provide synchronized access
	 */
	std::mutex localmutex;
	std::vector<std::string> localinput;
	std::condition_variable localcv;

private:
	/**
	 * Internal state to provide class-wide asio networking functionality
	 */
	boost::asio::io_service ios;
	boost::asio::streambuf recvbuf;
	boost::system::error_code errcode;
	tcp::socket *tcpsock;
	/**
	 * The IP and port to connect to
	 * Flag telling wether one is connected
	 */
	std::string ipstring;
	unsigned short port;
	bool connected;
	/**
	 * Instances of CmdMan and FileMan to process user input and handle File I/O
	 */
	CmdMan cmdman;
	FileMan fileman;

	/**
	 * Thread handles for processing local and network input as well as generating
	 * responses to both Matching mutexes for the flags wether the threads should
	 * keep running Function prototypes for the main thread functions
	 */
	std::thread tinput, tnetwork, tresponse;
	std::mutex inputmutex, networkmutex, responsemutex;
	bool runinput, runnetwork, runresponse;
	void networkMain();
	void inputMain();
	void responseMain();

	/**
	 * Vector to hold preprocessed input from the network
	 * Matching condition variable to wake up waiting threads
	 * Matching mutex to provide synchronized access
	 */
	std::vector<Json::Value> netinput;
	std::mutex netmutex;
	std::condition_variable netcv;

	/**
	 * Class-wide json functionality
	 */
	Json::CharReader *reader;
	Json::StreamWriterBuilder wbuilder;
	string jsonerror;

	/**
	 * Enum for internal login and version state
	 * Variables for keeping said state
	 * Matching mutex and condition variable
	 */
	enum Status { off, on, err };
	Status versionstatus;
	Status loginstatus;
	std::mutex initmutex;
	std::condition_variable initcv;

	/**
	 * Tokenizes input based on space as seperator
	 * Respects double-quoted tokens
	 * Returns a vector with the tokens as elements in order
	 */
	std::vector<std::string> tokenizeInput(std::string in);

protected:
	/**
	 * Prompt messages for readline prompt
	 */
	virtual void printWelcomeMessage() = 0;
	virtual std::string getCmdPrompt() = 0;
	// following prompts currently not in use because login happens by entering
	// command
	//~  virtual std::string getUserPrompt() = 0;
	//~  virtual std::string getPassPrompt() = 0;

public:
	/**
	 * Constructor and destructor
	 */
	IoMan(char *ipcstring);
	virtual ~IoMan();

	/**
	 * Establish connection to server and perform vesion check
	 * Return true if successful, false otherwise
	 */
	bool init();

	/**
	 * Main loop, call init first
	 */
	void run();

	/**
	 * Establish connection to server
	 * Return true if successful, false otherwise
	 */
	bool connect();
	/**
	 * Disconnect from a connected server
	 */
	void disconnect();
};

#endif