/*******************************************************************************
 * Copyright (c) 2016 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Created on: 17 déc. 2012
 *
 * Contributors:
 *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
 *   - Initial API and implementation
 ******************************************************************************/

#ifndef PRINTER_OUTSTREAM_H_
#define PRINTER_OUTSTREAM_H_

#include <fstream>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <stack>
#include <string>

#include <util/avm_debug.h>
#include <util/avm_util.h>

#include <printer/Manipulators.h>
#include <printer/WrapStream.h>


namespace sep
{


#define AVM_CHAR_SPC           " "

#define AVM_CHAR_TAB           " "
//#define AVM_CHAR_TAB         "\t"


class ParameterManager;
class Workflow;


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// OutStream
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

extern std::ostream * _avm_os_null_;


class OutStream
{

public:

	/**
	 * ATTRIBUTE
	 */
	std::ostream * OS;

	WrapOstream * WRAP_OS;

	AvmIndent INDENT;

	std::size_t DEPTH;

	std::stack< AvmIndent > STACK;

	SymbexValueCSS VALUE_ARRAY_CSS;
	SymbexValueCSS VALUE_PARAMS_CSS;
	SymbexValueCSS VALUE_STRUCT_CSS;


	/**
	 * CONSTRUCTOR
	 * Default
	 */
	OutStream(std::ostream * os = NULL,
			const std::string & tabs   = "",
			const std::string & _char_ = "\t",
			const std::string & eol    = "\n")
	: OS( os ),
	WRAP_OS( NULL ),
	INDENT( tabs, _char_ , eol ),
	DEPTH( 0 ),
	STACK( ),
	VALUE_ARRAY_CSS ( "[ ", " , ", " ]" ),
	VALUE_PARAMS_CSS( "( ", " , ", " )" ),
	VALUE_STRUCT_CSS( "{ ", " , ", " }" )
	{
		STACK.push( INDENT );
	}

	OutStream(std::ostream * os, const AvmIndent & indent)
	: OS( os ),
	WRAP_OS( NULL ),
	INDENT( indent ),
	DEPTH( 0 ),
	STACK( ),
	VALUE_ARRAY_CSS ( "[ ", " , ", " ]" ),
	VALUE_PARAMS_CSS( "( ", " , ", " )" ),
	VALUE_STRUCT_CSS( "{ ", " , ", " }" )
	{
		STACK.push( INDENT );
	}

	OutStream(std::ostream * os, const OutStream & aos)
	: OS( os ),
	WRAP_OS( NULL ),
	INDENT( aos.INDENT ),
	DEPTH( 0 ),
	STACK( ),
	VALUE_ARRAY_CSS ( "[ ", " , ", " ]" ),
	VALUE_PARAMS_CSS( "( ", " , ", " )" ),
	VALUE_STRUCT_CSS( "{ ", " , ", " }" )
	{
		STACK.push( INDENT );
	}


	OutStream(std::ostream & os, const AvmIndent & indent)
	: OS( & os ),
	WRAP_OS( NULL ),
	INDENT( indent ),
	DEPTH( 0 ),
	STACK( ),
	VALUE_ARRAY_CSS ( "[ ", " , ", " ]" ),
	VALUE_PARAMS_CSS( "( ", " , ", " )" ),
	VALUE_STRUCT_CSS( "{ ", " , ", " }" )
	{
		STACK.push( INDENT );
	}

//	OutStream(std::ostream & os,
//			const WrapData & wrapData, const AvmIndent & indent)
//	: OS( & os ),
//	WRAP_OS( new WrapOstream(os, wrapData) ),
//	INDENT( indent ),
//	DEPTH( 0 ),
//	STACK( ),
//	VALUE_ARRAY_CSS ( "[ ", " , ", " ]" ),
//	VALUE_PARAMS_CSS( "( ", " , ", " )" ),
//	VALUE_STRUCT_CSS( "{ ", " , ", " }" )
//	{
//		STACK.push( INDENT );
//
//		OS = WRAP_OS;
//	}

	OutStream(std::ostream & os, const OutStream & aos)
	: OS( & os ),
	WRAP_OS( NULL ),
	INDENT( aos.INDENT ),
	DEPTH( 0 ),
	STACK( ),
	VALUE_ARRAY_CSS ( "[ ", " , ", " ]" ),
	VALUE_PARAMS_CSS( "( ", " , ", " )" ),
	VALUE_STRUCT_CSS( "{ ", " , ", " }" )
	{
		STACK.push( INDENT );
	}

	OutStream(std::ostream & os,
			const std::string & tabs   = "",
			const std::string & _char_ = "\t",
			const std::string & eol    = "\n")
	: OS( & os ),
	WRAP_OS( NULL ),
	INDENT(tabs, _char_ , eol ),
	DEPTH( 0 ),
	STACK( ),
	VALUE_ARRAY_CSS ( "[ ", " , ", " ]" ),
	VALUE_PARAMS_CSS( "( ", " , ", " )" ),
	VALUE_STRUCT_CSS( "{ ", " , ", " }" )
	{
		STACK.push( INDENT );
	}

	/**
	 * DESTRUCTOR
	 */
	virtual ~OutStream()
	{
		delete( WRAP_OS );
	}


	/**
	 * OS
	 * delete / destroy
	 */
	inline virtual void deleteOS()
	{
		delete( OS );

		OS = NULL;
	}

	inline void destroy()
	{
		if( (OS != NULL) && (OS != _avm_os_null_) &&
			(OS != &(std::cout)) && (OS != &(std::cerr)) )
		{
			if( OS->good() )
			{
				(*OS) << std::flush;
			}

			deleteOS();
		}
	}


	/**
	 * OS
	 * fail / good
	 */
	inline virtual bool fail()
	{
		return( (OS == NULL) || OS->fail() );
	}

	inline virtual bool good()
	{
		return( (OS != NULL) && OS->good() );
	}


	/**
	 * OS
	 * isOpen / open / reopen
	 */
	inline bool isOpen()
	{
		return( (OS != NULL) &&
				(dynamic_cast< std::ofstream * >(OS) != NULL) &&
				dynamic_cast< std::ofstream * >(OS)->is_open() );
	}

	inline bool open(const std::string & aFileLocation,
			std::ios_base::openmode aMode)
	{
		OS = new std::ofstream(aFileLocation.c_str(), aMode);

		return( (OS != NULL) && OS->good() );
	}

	inline bool reopen(const std::string & aFileLocation,
			std::ios_base::openmode aMode)
	{
		if( isOpen() )
		{
			destroy();
		}

		return( open(aFileLocation.c_str(), aMode) );
	}


	/**
	 * TEST
	 * If is preferable...
	 */
	inline bool preferablySTR()
	{
		return( INDENT.preferablySTR() );
	}

	inline bool preferablyFQN()
	{
		return( INDENT.preferablyFQN() );
	}


	/**
	 * restore default Symbex Value CSS
	 */
	inline void restoreSymbexValueCSS()
	{
		VALUE_ARRAY_CSS  = DEFAULT_SYMBEX_VALUE_ARRAY_CSS;
		VALUE_PARAMS_CSS = DEFAULT_SYMBEX_VALUE_PARAMS_CSS;
		VALUE_STRUCT_CSS = DEFAULT_SYMBEX_VALUE_STRUCT_CSS;
	}

	inline void setSymbexValueCSS(const SymbexValueCSS & vac,
			const SymbexValueCSS & vpc, const SymbexValueCSS & vsc)
	{
		VALUE_ARRAY_CSS  = vac;
		VALUE_PARAMS_CSS = vpc;
		VALUE_STRUCT_CSS = vsc;
	}

	/**
	 * flush()
	 */
	inline virtual void flush() const
	{
		if( WRAP_OS != NULL )
		{
			WRAP_OS->flush();
		}

		if( OS != NULL )
		{
			OS->flush();
		}
	}


	/**
	 * operator<<
	 */
	// Need for polymorphism in functor like TAB or EOL family
	inline virtual OutStream & operator<<( const std::string & x )
	{
		( *OS ) << x;

		return( *this );
	}

	template< class T >
	inline OutStream & operator<<( const T & x )
	{
		( *OS ) << x;

		return( *this );
	}


	inline OutStream & operator<<( void (*op) ( OutStream & ) )
	{
		op( *this );

		return( *this );
	}

	inline OutStream & operator<<(
			std::ostream & (*op) ( std::ostream & ) )
	{
		op( *OS );

		return( *this );
	}


	inline static void backspace(std::ostream * os)
	{
		if( os == &(std::cout) )
		{
			( *os ) << '\b';
		}
		else if( os != NULL )
		{
			os->seekp(-1, std::ios::end);
		}
	}

	inline virtual void backspace()
	{
		OutStream::backspace( OS  );
	}


	inline void push()
	{
		if( /*STACK.empty() ||*/ (STACK.top() != INDENT) )
		{
			STACK.push( INDENT );
		}
		else
		{
			++(STACK.top().REF_COUNT);
		}
	}

	inline void pop()
	{
		INDENT = STACK.top();

		if( STACK.top().REF_COUNT == 1 )
		{
			STACK.pop();
		}
		else
		{
			--(STACK.top().REF_COUNT);
		}
	}


	/**
	 * MANIPULATORS
	 */
	inline OutStream & operator<<(const WrapData & newWrap)
	{
		if( good() )
		{
			if( WRAP_OS != NULL )
			{
				delete( WRAP_OS );
			}

			OS->flush();

			WRAP_OS = new WrapOstream(*OS, newWrap);

			OS = WRAP_OS;
		}

		return( *this );
	}

	inline void end_wrap()
	{
		if( good() && (WRAP_OS != NULL) )
		{
			OS = WRAP_OS->mOS;

			OS->flush();

			delete( WRAP_OS );

			WRAP_OS = NULL;
		}
	}


	inline OutStream & operator<<(const AvmIndent & newIndent)
	{
		push();

		INDENT = newIndent;

		return( *this );
	}


//	inline OutStream & operator<<(const AvmTAB & tab)
//	{
//		( *OS ) << INDENT.TABS;
//
//		for( ; tab.count > 1  ; --tab.count )
//		{
//			( *OS ) << INDENT.CHAR;
//		}
//
//		return( *this );
//	}
//
//	inline OutStream & operator<<(const AvmEOL & eol)
//	{
//		for( ; eol.count > 0  ; --eol.count )
//		{
//			( *OS ) << INDENT.EOL;
//		}
//
//		return( *this );
//	}


	inline OutStream & operator<<(const AvmINCR & incr)
	{
		OutStream::incr( incr.count );

		return( *this );
	}

	inline OutStream & operator<<(const AvmDECR & decr)
	{
		OutStream::decr( decr.count );

		return( *this );
	}


	/**
	 * <reference|pointer>.toStream( os )
	 */
	template< class T >
	inline OutStream & operator<<(const _refStream_< T > & obj)
	{
		obj.ref.toStream( *this );

		return( *this );
	}

	template< class T >
	inline OutStream & operator<<(const _ptrStream_< T > & obj)
	{
		if( obj.ptr != NULL )
		{
			obj.ptr->toStream( *this );
		}
		else
		{
			( *OS ) << INDENT.TABS << "to_stream(<null>)" << INDENT.EOL;
		}

		return( *this );
	}


	/**
	 * <reference|pointer>.strHeader( os )
	 */
	template< class T >
	inline OutStream & operator<<(const _refHeader_< T > & obj)
	{
		obj.ref.strHeader( *this );

		return( *this );
	}

	template< class T >
	inline OutStream & operator<<(const _ptrHeader_< T > & obj)
	{
		if( obj.ptr != NULL )
		{
			obj.ptr->strHeader( *this );
		}
		else
		{
			( *OS ) << "str_header(<null>)";
		}

		return( *this );
	}


	/**
	 * <reference|pointer>.strFQN( os )
	 */
	template< class T >
	inline OutStream & operator<<(const _refFQN_< T > & obj)
	{
		obj.ref.strFQN( *this );

		return( *this );
	}

	template< class T >
	inline OutStream & operator<<(const _ptrFQN_< T > & obj)
	{
		if( obj.ptr != NULL )
		{
			obj.ptr->strFQN( *this );
		}
		else
		{
			( *OS ) << INDENT.TABS << "str_fqn(<null>)" << INDENT.EOL;
		}

		return( *this );
	}


	/**
	 * INCR  <reference|pointer>.toStream( os )  DECR
	 */
	template< class T >
	inline OutStream & operator<<(const _refIncrIndent_< T > & obj)
	{
		incr();

		obj.ref.toStream( *this );

		decr();

		return( *this );
	}

	template< class T >
	inline OutStream & operator<<(const _ptrIncrIndent_< T > & obj)
	{
		if( obj.ptr != NULL )
		{
			incr();

			obj.ptr->toStream( *this );

			decr();
		}
		else
		{
			( *OS ) << INDENT.TABS << INDENT.CHAR
					<< "incr_stream(<null>)" << INDENT.EOL;
		}

		return( *this );
	}


	/**
	 * INCR< count >  <reference|pointer>.toStream( os )  DECR< count >
	 */
	template< class T >
	inline OutStream & operator<<(const _refIncrIndentCount_< T > & obj)
	{
		incr( obj.count );

		obj.ref.toStream( *this );

		decr( obj.count );

		return( *this );
	}

	template< class T >
	inline OutStream & operator<<(const _ptrIncrIndentCount_< T > & obj)
	{
		if( obj.ptr != NULL )
		{
			incr( obj.count );

			obj.ptr->toStream( *this );

			decr( obj.count );
		}
		else
		{
			OutStream::operator<<( tab(obj.count) );
			( *OS ) << "incr_count_stream(<null>)" << INDENT.EOL;
		}

		return( *this );
	}


	/**
	 * PUSH< AvmIndent >  <reference|pointer>.toStream( os )  POP< AvmIndent >
	 */
	template< class T >
	inline OutStream & operator<<(const _refIndent_< T > & obj)
	{
		obj.ref.toStream( OutStream::operator<<( obj.indent ) );

		pop();

		return( *this );
	}

	template< class T >
	inline OutStream & operator<<(const _ptrIndent_< T > & obj)
	{
		if( obj.ptr != NULL )
		{
			obj.ptr->toStream( OutStream::operator<<( obj.indent ) );

			pop();
		}
		else
		{
			( *OS ) << obj.indent.TABS << "push_stream_pop(<null>)" << obj.indent.EOL;
		}

		return( *this );
	}


	/**
	 * REPEAT
	 * COLUMN
	 * EMPHASIS
	 */
	template< class T >
	inline OutStream & repeat( const T & x , std::size_t count)
	{
		for( ; count > 0  ; --count )
		{
			( *OS ) << x;
		}

		return( *this );
	}

	template< class T >
	inline OutStream & operator<<(const AvmREPEAT< T > & aRepeat)
	{
		return( repeat< T >(aRepeat.pattern, aRepeat.count) );
	}

	OutStream & operator<<(const AvmEMPHASIS & emphasis);


	/**
	 * INCR
	 * TAB DEPTH
	 */
	inline void incr(std::size_t count)
	{
		INDENT.incr(count);

		DEPTH += count;
	}

	inline void incr()
	{
		INDENT.incr();

		DEPTH += 1;
	}


	inline OutStream & operator++()
	{
		incr();

		return( *this );
	}


	/**
	 * DECR
	 * TAB DEPTH
	 */
	inline void decr(std::size_t count)
	{
		INDENT.decr(count);

		DEPTH = ( DEPTH > count ) ? (DEPTH - count) : 0;
	}

	inline void decr()
	{
		INDENT.decr();

		DEPTH = ( DEPTH > 1 ) ? (DEPTH - 1) : 0;
	}


	inline OutStream & operator--()
	{
		decr();

		return( *this );
	}


	/**
	 * save current INDENT
	 * set newIndent
	 * x.toStream( os , arg )
	 * restore old INDENT
	 */
	template< class T , class P >
	inline OutStream & toStream(const T & x,
			const P & arg, const AvmIndent & newIndent)
	{
		push();

		INDENT = newIndent;

		x.toStream( *this , arg );

		pop();

		return( *this );
	}


	/**
	 * CAST
	 * std::ostream &
	 */
	inline operator std::ostream & () const
	{
		return( *OS );
	}


	/**
	 * LOAD
	 * DISPOSE
	 */
	static void load();
	static void dispose();

	/**
	 * CONFIGURE
	 */
	static bool configure(Workflow * aWorkflow);

};


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// CONSOLE PROMPT
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

extern const std::string & CONSOLE_DEBUG_PROMPT;
extern const std::string & CONSOLE_SEW_PROMPT;
extern const std::string & CONSOLE_CONFIG_PROMPT;
extern const std::string & CONSOLE_SYMBEX_PROMPT;


inline void _DBG_(OutStream & os)
{
	os << CONSOLE_DEBUG_PROMPT;
}

inline void _SEW_(OutStream & os)
{
	os << CONSOLE_SEW_PROMPT;
}

inline void _CFG_(OutStream & os)
{
	os << CONSOLE_CONFIG_PROMPT;
}

inline void _SBX_(OutStream & os)
{
	os << CONSOLE_SYMBEX_PROMPT;
}


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// SCOPE : for automatic PUSH / POP  AvmIndent
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

struct ScopeNewIndent
{
	OutStream & OS;

	AvmIndent INDENT;

	ScopeNewIndent(OutStream & os, const AvmIndent & indent)
	: OS( os ),
	// save current indent
	INDENT( os.INDENT )
	{
		// set new indent
		os.INDENT = indent;
	}

	ScopeNewIndent(OutStream & os,
			const std::string & tabs   = "",
			const std::string & _char_ = "\t",
			const std::string & eol    = "\n")
	: OS( os ),
	// save current indent
	INDENT( os.INDENT )
	{
		// set new indent
		os.INDENT = AvmIndent(tabs, _char_,eol);
	}

	~ScopeNewIndent()
	{
		// restore old indent
		OS.INDENT = INDENT;
	}
};


/**
 * SCOPE
 * for automatic INCREMENT / DECREMENT
 */
struct ScopeIncrIndent
{
	OutStream & OS;

	ScopeIncrIndent(OutStream & os)
	: OS( os )
	{
		// increment indent
		os.incr();
	}

	~ScopeIncrIndent()
	{
		// decrement indent
		OS.decr();
	}
};


/**
 * WrapData Manipulators
 */
inline void END_WRAP(OutStream & os)
{
	os.end_wrap();
}

inline void END_WRAP_EOL(OutStream & os)
{
	os.end_wrap();

	os << os.INDENT.EOL;
}

/**
 * AvmTAB
 */
inline void IGNORE_FIRST_TAB(OutStream & os)
{
	os.INDENT.IGNORE_FIRST_TAB = true;
}


inline void TAB(OutStream & os)
{
	if( os.INDENT.IGNORE_FIRST_TAB )
	{
		os.INDENT.IGNORE_FIRST_TAB = false;
	}
	else
	{
		os << os.INDENT.TABS;
	}
}

inline void TAB1(OutStream & os)
{
	if( os.INDENT.IGNORE_FIRST_TAB )
	{
		os.INDENT.IGNORE_FIRST_TAB = false;
	}
	else
	{
		os << os.INDENT.TABS;
	}
}


inline void TAB2(OutStream & os)
{
	os << os.INDENT.TABS << os.INDENT.CHAR;
}

inline void TAB3(OutStream & os)
{
	os << os.INDENT.TABS << os.INDENT.CHAR << os.INDENT.CHAR;
}

inline void TAB4(OutStream & os)
{
	os << os.INDENT.TABS << os.INDENT.CHAR << os.INDENT.CHAR
			<< os.INDENT.CHAR;
}

inline void TAB5(OutStream & os)
{
	os << os.INDENT.TABS << os.INDENT.CHAR << os.INDENT.CHAR
			<< os.INDENT.CHAR << os.INDENT.CHAR;
}


/**
 * ++TAB
 * --TAB
 */
inline void INCR_INDENT_TAB(OutStream & os)
{
	os.incr();

	os << os.INDENT.TABS;
}

inline void DECR_INDENT_TAB(OutStream & os)
{
	os.decr();

	os << os.INDENT.TABS;
}

inline void DECR_INDENT_TAB2(OutStream & os)
{
	os.decr();

	os << os.INDENT.TABS << os.INDENT.CHAR;
}


inline void INCR2_INDENT_TAB(OutStream & os)
{
	os.incr(2);

	os << os.INDENT.TABS;
}

inline void DECR2_INDENT_TAB(OutStream & os)
{
	os.decr(2);

	os << os.INDENT.TABS;
}

inline void DECR2_INDENT_TAB2(OutStream & os)
{
	os.decr(2);

	os << os.INDENT.TABS << os.INDENT.CHAR;
}


/**
 * TAB++
 * TAB--
 */
inline void TAB_INCR_INDENT(OutStream & os)
{
	os << os.INDENT.TABS;

	os.incr();
}

inline void TAB_DECR_INDENT(OutStream & os)
{
	os << os.INDENT.TABS;

	os.decr();
}


inline void TAB_INCR2_INDENT(OutStream & os)
{
	os << os.INDENT.TABS;

	os.incr(2);
}

inline void TAB_DECR2_INDENT(OutStream & os)
{
	os << os.INDENT.TABS;

	os.decr(2);
}


/**
 * INCR
 * DECR
 * INDENTATION
 */
inline void INCR_INDENT(OutStream & os)
{
	os.incr();
}

inline void DECR_INDENT(OutStream & os)
{
	os.decr();
}


inline void INCR2_INDENT(OutStream & os)
{
	os.incr(2);
}

inline void DECR2_INDENT(OutStream & os)
{
	os.decr(2);
}


inline void INCR3_INDENT(OutStream & os)
{
	os.incr(3);
}

inline void DECR3_INDENT(OutStream & os)
{
	os.decr(3);
}

/**
 * NEW
 * END
 * INDENTATION
 */
inline AvmIndent NEW_INDENT(
		const std::string & tabs   = "",
		const std::string & _char_ = "\t",
		const std::string & eol    = "\n")
{
	return( AvmIndent(tabs, _char_, eol) );
}

inline AvmIndent & NEW_INDENT(AvmIndent & indent)
{
	return( indent );
}


inline AvmIndent NEW_LTRIM_INDENT(const AvmIndent & indent)
{
	return( AvmIndent("", indent.CHAR, indent.EOL) );
}

inline AvmIndent NEW_LTRIM_INDENT(OutStream & os)
{
	return( AvmIndent("", os.INDENT.CHAR, os.INDENT.EOL) );
}


inline void END_INDENT(OutStream & os)
{
	os.pop();
}

inline void END_INDENT_EOL(OutStream & os)
{
	os.pop();

	os << os.INDENT.EOL;

AVM_IF_DEBUG_LEVEL_GTE_MEDIUM
	os << std::flush;
AVM_ENDIF_DEBUG_LEVEL_GTE_MEDIUM
}


/**
 * BackSpace
 */
inline void BACKSPACE(OutStream & os)
{
	os.backspace();
}

inline void BACKSPACE_TAB(OutStream & os)
{
	os.backspace();

	os << os.INDENT.TABS;
}


/**
 * AvmEOL
 */
inline void EOL(OutStream & os)
{
	os << os.INDENT.EOL;

AVM_IF_DEBUG_LEVEL_GTE_MEDIUM
	os << std::flush;
AVM_ENDIF_DEBUG_LEVEL_GTE_MEDIUM
}

inline void EOL_TAB(OutStream & os)
{
	os << os.INDENT.EOL << os.INDENT.TABS;

AVM_IF_DEBUG_LEVEL_GTE_MEDIUM
	os << std::flush;
AVM_ENDIF_DEBUG_LEVEL_GTE_MEDIUM
}

inline void EOL_TAB2(OutStream & os)
{
	os << os.INDENT.EOL << os.INDENT.TABS << os.INDENT.CHAR;

AVM_IF_DEBUG_LEVEL_GTE_MEDIUM
	os << std::flush;
AVM_ENDIF_DEBUG_LEVEL_GTE_MEDIUM
}

inline void EOL_TAB3(OutStream & os)
{
	os << os.INDENT.EOL << os.INDENT.TABS
			<< os.INDENT.CHAR << os.INDENT.CHAR;

AVM_IF_DEBUG_LEVEL_GTE_MEDIUM
	os << std::flush;
AVM_ENDIF_DEBUG_LEVEL_GTE_MEDIUM
}

inline void EOL_FLUSH(OutStream & os)
{
	os << os.INDENT.EOL << std::flush;
}


inline void EOL2(OutStream & os)
{
	os << os.INDENT.EOL << os.INDENT.EOL;

AVM_IF_DEBUG_LEVEL_GTE_MEDIUM
	os << std::flush;
AVM_ENDIF_DEBUG_LEVEL_GTE_MEDIUM
}

inline void EOL2_TAB(OutStream & os)
{
	os << os.INDENT.EOL << os.INDENT.EOL << os.INDENT.TABS;

AVM_IF_DEBUG_LEVEL_GTE_MEDIUM
	os << std::flush;
AVM_ENDIF_DEBUG_LEVEL_GTE_MEDIUM
}

inline void EOL2_FLUSH(OutStream & os)
{
	os << os.INDENT.EOL << os.INDENT.EOL << std::flush;
}


/**
 * ++TAB
 * --TAB
 */
inline void INCR_EOL(OutStream & os)
{
	os.incr();

	os << os.INDENT.EOL;

AVM_IF_DEBUG_LEVEL_GTE_MEDIUM
	os << std::flush;
AVM_ENDIF_DEBUG_LEVEL_GTE_MEDIUM
}

inline void DECR_EOL(OutStream & os)
{
	os.decr();

	os << os.INDENT.EOL;

AVM_IF_DEBUG_LEVEL_GTE_MEDIUM
	os << std::flush;
AVM_ENDIF_DEBUG_LEVEL_GTE_MEDIUM
}


inline void EOL_INCR_INDENT(OutStream & os)
{
	os << os.INDENT.EOL;

AVM_IF_DEBUG_LEVEL_GTE_MEDIUM
	os << std::flush;
AVM_ENDIF_DEBUG_LEVEL_GTE_MEDIUM

	os.incr();
}

inline void EOL_DECR_INDENT(OutStream & os)
{
	os << os.INDENT.EOL;

AVM_IF_DEBUG_LEVEL_GTE_MEDIUM
	os << std::flush;
AVM_ENDIF_DEBUG_LEVEL_GTE_MEDIUM

	os.decr();
}


inline void EOL_INCR2_INDENT(OutStream & os)
{
	os << os.INDENT.EOL;

AVM_IF_DEBUG_LEVEL_GTE_MEDIUM
	os << std::flush;
AVM_ENDIF_DEBUG_LEVEL_GTE_MEDIUM

	os.incr(2);
}

inline void EOL_DECR2_INDENT(OutStream & os)
{
	os << os.INDENT.EOL;

AVM_IF_DEBUG_LEVEL_GTE_MEDIUM
	os << std::flush;
AVM_ENDIF_DEBUG_LEVEL_GTE_MEDIUM

	os.decr(2);
}

inline void EOL_FLUSH_DECR_INDENT(OutStream & os)
{
	os << os.INDENT.EOL << std::flush;

	os.decr();
}


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// StringOutStream
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

class StringOutStream  :  public OutStream
{

protected:
	/**
	 * ATTRIBUTE
	 */
	std::ostringstream oss;


public:
	/**
	 * CONSTRUCTOR
	 * Default
	 */
	StringOutStream(const AvmIndent & indent = AVM_TAB_INDENT)
	: OutStream( oss , indent )
	{
		//!! NOTHING
	}

	StringOutStream(
			const std::string & tabs,
			const std::string & _char_ = "\t",
			const std::string & eol    = "\n")
	: OutStream( oss , tabs , _char_ , eol )
	{
		//!! NOTHING
	}

	StringOutStream(const WrapData & wrapData,
			const AvmIndent & indent = AVM_TAB_INDENT)
	: OutStream( oss , indent )
	{
		OutStream::operator<<( wrapData );
	}


	/**
	 * DESTRUCTOR
	 */
	virtual ~StringOutStream()
	{
		//!! NOTHING
	}


	/**
	 * str()
	 */
	inline std::string str() const
	{
		OutStream::flush();

		return( oss.str() );
	}

	inline void str(const std::string & buf)
	{
		OutStream::flush();

		oss.str( buf );
	}

	/**
	 * c_str()
	 */
	inline const char * c_str() const
	{
		OutStream::flush();

		return( oss.str().c_str() );
	}


	/**
	 * CAST
	 * std::string
	 * const char *
	 */
	inline operator std::string () const
	{
		OutStream::flush();

		return( oss.str() );
	}

//	inline operator const char * () const
//	{
//		OutStream::flush();
//
//		return( oss.str().c_str() );
//	}


	/**
	 * operator<<
	 */
	template< class T >
	inline StringOutStream & operator<<( const T & x )
	{
		OutStream::operator<<( x );

		return( *this );
	}


	inline StringOutStream & operator<<(
			void (*op) ( StringOutStream & ) )
	{
		op( *this );

		return( *this );
	}

	inline StringOutStream & operator<<( void (*op) ( OutStream & ) )
	{
		op( *this );

		return( *this );
	}

	inline StringOutStream & operator<<(
			std::ostream & (*op) ( std::ostream & ) )
	{
		op( *this );

		return( *this );
	}

};

/**
 * TYPEDEF
 * to_string() template replacement by OSS()
 */
typedef StringOutStream  OSS;


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

class NullOutStream  :  public OutStream
{

public:
	/**
	 * CONSTRUCTOR
	 * Default
	 */
	NullOutStream()
	: OutStream( )
	{
		//!! NOTHING
	}

	/**
	 * DESTRUCTOR
	 */
	virtual ~NullOutStream()
	{
		//!! NOTHING
	}


	/**
	 * operator<<
	 */
	template< class T >
	inline NullOutStream & operator<<(const T & x)
	{
		return( *this );
	}

};


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// PairOutStream
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

class PairOutStream
{

public:
	/**
	 * ATTRIBUTES
	 */
	OutStream & OS1;
	OutStream & OS2;


public:
	/**
	 * CONSTRUCTOR
	 * Default
	 */
	PairOutStream(OutStream & os1, OutStream & os2)
	: OS1( os1 ) , OS2( os2 )
	{
		//!! NOTHING
	}


	/**
	 * DESTRUCTOR
	 */
	virtual ~PairOutStream()
	{
		//!! NOTHING
	}


	/**
	 * operator<<
	 */
	template< class T >
	inline PairOutStream & operator<<( const T & x )
	{
		OS1 << x;
		OS2 << x;

		return( *this );
	}


	inline PairOutStream & operator<<( void (*op) ( OutStream & ) )
	{
		op( OS1 );
		op( OS2 );

		return( *this );
	}

	inline PairOutStream & operator<<(
			std::ostream & (*op) ( std::ostream & ) )
	{
		op( OS1 );
		op( OS2 );

		return( *this );
	}


	inline virtual void backspace()
	{
		OS1.backspace();
		OS2.backspace();
	}

};


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// TripleOutStream
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

class TripleOutStream
{

public:
	/**
	 * ATRIBUTES
	 */
	OutStream & OS1;
	OutStream & OS2;
	OutStream & OS3;


public:
	/**
	 * CONSTRUCTOR
	 * Default
	 */
	TripleOutStream(OutStream & os1, OutStream & os2, OutStream & os3)
	: OS1( os1 ) , OS2( os2 ) , OS3( os3 )
	{
		//!! NOTHING
	}


	/**
	 * DESTRUCTOR
	 */
	virtual ~TripleOutStream()
	{
		//!! NOTHING
	}


	/**
	 * operator<<
	 */
	template< class T >
	inline TripleOutStream & operator<<( const T & x )
	{
		OS1 << x;
		OS2 << x;
		OS3 << x;

		return( *this );
	}


	inline TripleOutStream & operator<<( void (*op) ( OutStream & ) )
	{
		op( OS1 );
		op( OS2 );
		op( OS3 );

		return( *this );
	}

	inline TripleOutStream & operator<<(
			std::ostream & (*op) ( std::ostream & ) )
	{
		op( OS1 );
		op( OS2 );
		op( OS3 );

		return( *this );
	}


	inline virtual void backspace()
	{
		OS1.backspace();
		OS2.backspace();
		OS3.backspace();
	}

};


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// operator<<
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

#define AVM_OS_STREAM( T )  \
inline OutStream & operator<<(OutStream & os, const T & anElement) \
{ \
	anElement.toStream( os ); \
	return( os ); \
} \
inline StringOutStream & operator<<(StringOutStream & os, const T & anElement) \
{ \
	anElement.toStream( os ); \
	return( os ); \
} \
inline PairOutStream & operator<<(PairOutStream & os, const T & anElement) \
{ \
	anElement.toStream( os.OS1 ); \
	anElement.toStream( os.OS2 ); \
	return( os ); \
} \
inline TripleOutStream & operator<<(TripleOutStream & os, const T & anElement) \
{ \
	anElement.toStream( os.OS1 ); \
	anElement.toStream( os.OS2 ); \
	anElement.toStream( os.OS3 ); \
	return( os ); \
}


#define AVM_OS_STREAM_COLLECTION( T )  \
inline OutStream & operator<<(OutStream & os, const T & anElement) \
{ \
	T::const_iterator endIt = anElement.end(); \
	for( T::const_iterator it = anElement.begin() ; it != endIt ; ++it ) \
	{ \
		os << (*it); \
	} \
	return( os ); \
} \
inline PairOutStream & operator<<(PairOutStream & os, const T & anElement) \
{ \
	T::const_iterator endIt = anElement.end(); \
	for( T::const_iterator it = anElement.begin() ; it != endIt ; ++it ) \
	{ \
		os << (*it); \
	} \
	return( os ); \
} \
inline TripleOutStream & operator<<(TripleOutStream & os, const T & anElement) \
{ \
	T::const_iterator endIt = anElement.end(); \
	for( T::const_iterator it = anElement.begin() ; it != endIt ; ++it ) \
	{ \
		os << (*it); \
	} \
	return( os ); \
} \


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// SAVE & REDIRECT & RESTORE STREAMBUF
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

// save original stream::sbuf
// redirect stream::sbuf
#define STREAMBUF_SAVE_REDIRECT( originalStream , targetStream ) \
		std::streambuf * saveSBUF = originalStream.rdbuf(); \
		originalStream.rdbuf( targetStream.rdbuf() );


// restore the original stream::sbuf
#define STREAMBUF_RESTORE( originalStream ) \
		originalStream.rdbuf( saveSBUF );


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// GLOBAL PRE-DEFINED STREAM
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

/**
 * UTIL VARIABLE
 * AVM_OS_NULL
 */
extern std::ostream * _avm_os_null_;

extern NullOutStream AVM_OS_NULL;


/**
 * AVM COUT & CERR & DEBUG
 */
extern OutStream AVM_OS_COUT;

extern OutStream AVM_OS_CERR;

extern OutStream AVM_OS_DEBUG;


/**
 * AVM LOG & TRACE FILE LOCATION
 */
extern std::string AVM_LOG_FILE_LOCATION;

extern std::string AVM_TRACE_FILE_LOCATION;


/**
 * UTIL VARIABLE
 * AVM_OS_LOG
 */
extern std::ostream * _avm_os_log_;

extern OutStream AVM_OS_LOG;


/**
 * UTIL VARIABLE
 * AVM_OS_TRACE
 */
extern std::ostream * _avm_os_trace_;

extern OutStream AVM_OS_TRACE;


/**
 * UTIL VARIABLE
 * AVM_OS_WARN as AVM_OS_CERR & AVM_OS_TRACE
 */
typedef PairOutStream WarnOutstreamT;

extern WarnOutstreamT  AVM_OS_WARN;

/**
 * UTIL VARIABLE
 * AVM_OS_INFO as AVM_OS_COUT & AVM_OS_TRACE
 */
typedef PairOutStream  InfoOutstreamT;

extern InfoOutstreamT AVM_OS_INFO;

/**
 * UTIL VARIABLE
 * AVM_OS_CLOG as AVM_OS_COUT & AVM_OS_LOG
 */
typedef PairOutStream  CLogOutstreamT;

extern InfoOutstreamT AVM_OS_CLOG;

/**
 * UTIL VARIABLE
 * AVM_OS_TDD
 * for Test Driven Development
 */
extern std::ostream * _avm_os_tdd_;

extern OutStream AVM_OS_TDD;


} /* namespace sep */
#endif /* PRINTER_OUTSTREAM_H_ */