/*
   sys/consoleinterface.h
   This file is part of the Osirion project and is distributed under
   the terms of the GNU General Public License version 2.
*/

#ifndef __INCLUDED_SYS_CONSOLEINTERFACE_H__
#define __INCLUDED_SYS_CONSOLEINTERFACE_H__

#include <iostream>
#include <string>
#include <streambuf>
#include <ostream>
#include <sstream>
#include <deque>

#include "sys/sys.h"


namespace sys
{

/// true if console timestamps are enabled
bool console_timestamps();

/// enable or disable consle timestamps
void set_console_timestamps(const bool timestamps);

/// true if ANSI colors are enabled
bool ansi();

/// enable or disable ANSI colors
void set_ansi(bool enable = true);

#ifdef HAVE_DEBUG_MESSAGES

/// enable or disable debug messages

#endif

/* -- ConsoleBuffer ------------------------------------------------ */

typedef std::char_traits<char> Traits;

/// buffer back-end for console output
class ConsoleBuffer : public std::basic_streambuf<char, Traits >
{
public:
	const std::string & str() const {
		return con_buffer;
	}

protected:
	/// stream overflow
	virtual int overflow(int c = Traits::eof());

private:
	std::string		con_buffer;
};


/* -- ConsoleStream ------------------------------------------------ */

/// provides global streams for console output
class ConsoleStream : public std::basic_ostream<char, Traits >
{
public:
	ConsoleStream();
	~ConsoleStream();

	inline ConsoleBuffer & buf() {
		return con_buffer;
	}

private:
	ConsoleBuffer		con_buffer;
};

/// global console output stream
extern ConsoleStream		con_out;


/* -- Console ------------------------------------------------------ */


/// interface for the client and server Console classes
class ConsoleInterface
{
public:
	/// default constructor
	ConsoleInterface();

	/// default destructor
	virtual ~ConsoleInterface();

	/// set maximal number of lines in the log
	void set_logsize(const size_t logsize);

	/// return rcon state
	inline bool rcon() {
		return consoleinterface_rcon;
	}

	/// enable or disable rcon
	void set_rcon(bool enable = true);

	typedef std::deque<std::string> Queue;

	inline Queue & rconbuf() {
		return consoleinterface_rconbuf;
	}

	inline Queue & log() {
		return consoleinterface_log;
	}

	/// a pointer to the current console instance
	static ConsoleInterface *instance();

	/// incoming text event handler
	void event_text(const std::string & text);

	/// ncurses resize event
	virtual void resize() {};

protected:
	/// print one line of text
	virtual void print(const std::string & text);

private:
	/// console singleton
	static ConsoleInterface *consoleinterface_instance;

	bool			consoleinterface_rcon;
	Queue			consoleinterface_rconbuf;

	Queue			consoleinterface_log;
	size_t			consoleinterface_logsize;
};

} // namespace sys

#define con_print sys::con_out << "^N"
#define con_warn sys::con_out << "^W"
#define con_error sys::con_out << "^R"
#ifdef HAVE_DEBUG_MESSAGES
#define con_debug sys::con_out << "^D"
#else
#define con_debug if (0) *(std::ostream*)(0)
#endif


#endif // __INCLUDED_SYS_CONSOLEINTERFACE_H__