#ifndef SOCKETSERVER_H_
#define SOCKETSERVER_H_

#include <jthread-1.2.1/src/jthread.h>
#include "MonitorModulesResults.h"
#include "MonitorConfiguration.h"
#include "memlock.h"

#include "MonitorSignals.h"
#ifdef PLUGINS
	#include "plugins/mplugin.h"
#endif

#ifdef _WIN32
	/* Headerfiles für Windows */
	#include <winsock2.h>
	#include <io.h>
#else
	/* Headerfiles für Unix/Linux */
	#include <sys/types.h>
	#include <sys/socket.h>
	#include <netinet/in.h>
	#include <netdb.h>
	#define closesocket(s) close(s)
#endif

/* sofern lua aktiviert ist ? -> ifdef noetig ? */
#include "lua.hpp"

#define MAX_CLIENTS 50
#define RECV_BUFFER 512
#define MAX_COMMANDLINE 1024
#define MAX_PARAMS 9


class ThreadBase : public JThread
{
public:
	ThreadBase(int LOCKNUM);
	virtual ~ThreadBase();
	virtual void *Thread() = 0 ;
	virtual void addResult(ModuleResultBase* pRes)=0 ;

	MonitorConfiguration *m_MonitorConfiguration ;
protected:
	virtual void ResetThreadVars(){} ;
	MEMLOCK m_Lock ;
	bool m_exitThread ;
	int m_iLockNum ;
	bool createLock() ;
	void releaseLock() ;
};


/**
 * @brief Repraesentiert immer genau einen verbunden Client.
 *
 * Der SocketThread wird fuer jeden verbundenen Client gestartet. Er prueft die Anmeldung
 * und gibt die Daten weiter, die vom Master-Thread SocketServer an ihn weitergeleitet werden
 */
class SocketThread : public ThreadBase
{
public:
	enum SocketMode {monitord,crusader,fms32pro} ;

	//SocketThread(int LOCKNUM, int PortNum);
	SocketThread(MonitorConfiguration *config, int LOCKNUM, int PortNum, SocketMode ServerMode=monitord);
	virtual ~SocketThread();
	virtual void *Thread() ;
	virtual void addResult(ModuleResultBase* pRes) ;
	void setFD(int fd) ;
	void addOutputText(std::string outText) ;
	void closeSocket() ;

	std::string getClientLogin() ;
	std::string getClientIP() ;
	bool isClientAuthenticated() ;
	struct sockaddr_in m_client; // war sockaddr_in

protected:
	MonitorConfiguration m_MonitorConfig;
	SocketMode m_ServerMode ;
	bool m_authenticated ;
	int m_fd;
	int m_iPortNum ;
	char m_CommandBuffer[MAX_COMMANDLINE] ;
	int m_cmd;
	int m_paramCount ;
	std::string m_cmdString;
	std::string m_cmdParam[MAX_PARAMS] ;
	std::string m_sClientIP ;
	std::vector<std::string> m_outputStrings ;
	std::string m_loginname ;

	virtual std::string createFMSOutputString(ModuleResultBase Result); //< Erstellt die Ausgaben fuer FMS
	virtual std::string createPOCSAGOutputString(ModuleResultBase Result); //< Erstellt die Ausgaben fuer POCSAG
	virtual std::string createZVEIOutputString(ModuleResultBase Result); //< Erstellt die Ausgaben fuer ZVEI
	std::string createOutputString(ModuleResultBase Result) ;

	virtual void ResetThreadVars() ;
	void say(const std::string& something) ;
	void say(const char* something) ;
	virtual void sayWelcome() ;
	virtual void sayGoodbye() ;
	void createSocket() ;
	virtual void processInput() ;

	// Kommandos auf reine HEX Characters pruefen
	//
	bool paramIsHex(int param) ;
	bool paramIsBase64(int param) ;
	bool HexToString(int param, std::string& result) ;
	bool StringToHex(const std::string& input, std::string &result) ;

	void doLogout() ; 	// 299
};

/**
 * @brief Oeffnet den TCP Socket und nimmt Verbindungsanfragen an.
 *
 * Der SocketServer oeffnet den listening port und startet fuer jeden Client, der sich
 * verbindet einen Thread vom Typ SocketThread.
 */

class SocketServer : public JThread
{
public:
	SocketServer(MonitorConfiguration* config, int iLockStartwert=0);
	SocketServer(MonitorConfiguration* config, std::string FilterFileName , int iLockStartwert=0);
	virtual ~SocketServer();
	virtual void *Thread() ;
	unsigned int m_iPort ;
	int m_iLockStartwert ;
	SocketThread::SocketMode m_ServerModus ;
	MEMLOCK m_queueLock ;
	MODULERESULTSET m_queue ;
	void addResult(ModuleResultBase* pRes) ;
	bool m_bWantStop ;
protected:
	int m_sock ;
	struct sockaddr_in m_server ;
	SocketThread* socketThread[MAX_CLIENTS] ;
	MonitorConfiguration *m_MonitorConfiguration ;
	bool createListeningSocket() ;
	void initSocketThreads() ;

	bool m_bSkipDispatching ;
	#ifdef LUA
		lua_State *L;
		bool m_bUseLUAScript ;
	#endif
} ;


/**
 * @brief Verwaltet alle SocketModule
 */

typedef std::vector< SocketServer*> tMonitorSocketServerVector ;

class MonitorSocketsManager
{
public:


	MonitorSocketsManager() ;
	virtual ~MonitorSocketsManager() ;
	bool addModule(SocketServer* pServer);
	bool removeModule(SocketServer *pServer) ;
	bool dispatchResult(ModuleResultBase *pRes) ;
protected:
	MEMLOCK m_MemLock ;
	tMonitorSocketServerVector m_Modules ;
	bool m_bStop ;
};

extern MonitorSocketsManager *GlobalMonitorSocketsManager ;
MonitorSocketsManager* GetSocketsManager()  ;

// in SocketServer.cpp als globale Variable definiert
//extern tMonitorSocketServerVector globalRegisteredSocketServers ;



#endif /*SOCKETSERVER_H_*/