#ifndef BU_OPT_PARSER_H
#define BU_OPT_PARSER_H

#include "bu/fstring.h"
#include "bu/list.h"
#include "bu/hash.h"
#include "bu/signals.h"
#include "bu/array.h"
#include "bu/membuf.h"
#include "bu/formatter.h"

namespace Bu
{
	typedef Bu::Array<Bu::FString> StrArray;
	class OptParser
	{
	private:
		class _ValueProxy
		{
		public:
			_ValueProxy();
			virtual ~_ValueProxy();

			virtual void setValue( const Bu::FString & )=0;
			virtual _ValueProxy *clone()=0;
		};

		template<typename ptype>
		class ValueProxy : public _ValueProxy
		{
		public:
			ValueProxy( ptype &v ) :
				v( v )
			{
			}

			virtual ~ValueProxy()
			{
			}

			virtual void setValue( const Bu::FString &sVal )
			{
				Bu::MemBuf mb( sVal );
				Bu::Formatter f( mb );
				f >> v;
			}
			
			virtual _ValueProxy *clone()
			{
				return new ValueProxy<ptype>( v );
			}

		private:
			ptype &v;
		};

	public:
		typedef Signal1<int, StrArray> OptionSignal;
		class Option
		{
		public:
			Option();
			Option( const Option &rSrc );
			virtual ~Option();

			char cOpt;
			Bu::FString sOpt;
			Bu::FString sHelp;
			OptionSignal sUsed;
			bool bShortHasParams;
			_ValueProxy *pProxy;
			Bu::FString sOverride;
		};
	
	private:
		typedef Bu::List<Option> OptionList;
		typedef Bu::Hash<char, Option *> ShortOptionHash;
		typedef Bu::Hash<Bu::FString, Option *> LongOptionHash;
		
		class Banner
		{
		public:
			Bu::FString sText;
			bool bFormatted;
			OptionList::const_iterator iAfter;
		};

		typedef Bu::List<Banner> BannerList;

	public:
		OptParser();
		virtual ~OptParser();

		void parse( int argc, char **argv );

		void addOption( const Option &opt );
		
		template<typename vtype>
		void addOption( vtype &var, char cOpt, const Bu::FString &sOpt,
				const Bu::FString &sHelp )
		{
			Option o;
			o.cOpt = cOpt;
			o.sOpt = sOpt;
			o.pProxy = new ValueProxy<vtype>( var );
			o.bShortHasParams = true;
			o.sHelp = sHelp;
			addOption( o );
		}
		
		template<typename vtype>
		void addOption( vtype &var, const Bu::FString &sOpt,
				const Bu::FString &sHelp )
		{
			addOption( var, '\0', sOpt, sHelp );
		}
		
		template<typename vtype>
		void addOption( vtype &var, char cOpt, const Bu::FString &sHelp )
		{
			addOption( var, cOpt, "", sHelp );
		}

		void addOption( OptionSignal sUsed, char cOpt, const Bu::FString &sOpt,
				const Bu::FString &sHelp )
		{
			Option o;
			o.cOpt = cOpt;
			o.sOpt = sOpt;
			o.sUsed = sUsed;
			o.sHelp = sHelp;
			addOption( o );
		}
		
		void addOption( OptionSignal sUsed, const Bu::FString &sOpt,
				const Bu::FString &sHelp )
		{
			addOption( sUsed, '\0', sOpt, sHelp );
		}
		
		void addOption( OptionSignal sUsed, char cOpt,
				const Bu::FString &sHelp )
		{
			addOption( sUsed, cOpt, "", sHelp );
		}

		void setOverride( char cOpt, const Bu::FString &sOverride );
		void setOverride( const Bu::FString &sOpt,
				const Bu::FString &sOverride );
		
//		void addOption( char cOpt, const Bu::FString &sOpt, 
		
		void addHelpOption( char c='h', const Bu::FString &s="help",
				const Bu::FString &sHelp="This help." );
		void addHelpBanner( const Bu::FString &sText, bool bFormatted=true );

		int optHelp( StrArray aParams );

	private:
		Bu::FString format( const Bu::FString &sIn, int iWidth, int iIndent );

		OptionList lOption;
		ShortOptionHash hsOption;
		LongOptionHash hlOption;
		BannerList lBanner;
	};
};

#endif