/*
 * Should be a great addition to boost. But what about the uglyness of the print_T macro?
 * Is there any way to solve this problem without suckage?
 * Templating or function wrapping the type() and typeid() is not really feasible is it?
 * I don't really wanna implement the merge function without actually knwoing what to do about the "dynamic typing" of the boost::any
 * The most important flaw is, that it only works for the types that are hard-coded.
 * Sort of defeats the point of "dynamic typing".
 */

#include <queue>
#include <iostream>


#include "boost/config.hpp"

#define BOOST_PROGRAM_OPTIONS_SOURCE
#include "boost/program_options.hpp"
#include "boost/program_options/config.hpp"
#include "boost/program_options/parsers.hpp"
#include "boost/filesystem/operations.hpp"



namespace boost
{
	namespace program_options
	{
		using namespace std;

		// writes contents of m that is defined in desc into os
		
		template<class charT>
		void
		persist_to_config_file(std::basic_ostream<charT>& os, const options_description& desc, const variables_map& m)
		{ 
			typedef map<const string, vector<const option_description*> > gmap;
			gmap groups;

			const vector<boost::shared_ptr<option_description> >& options = desc.options();
			
			
			// build the group map and add the respective options
			for (unsigned i = 0; i < options.size(); ++i)
			{
				const option_description& d = *options[i];
				const string ln = d.long_name();
				if(ln.empty()) continue;
				
				size_t j = ln.find_last_of('.');
				string group_key = j<ln.size()?ln.substr(0,j):"";
				gmap::iterator gi;

				if((gi = groups.find(group_key)) == groups.end())
				{
					gmap::mapped_type v;
					v.push_back(&d);
					groups[group_key]=v;
				}
				else gi->second.push_back(&d);
			}

			// write out the map
			for(gmap::const_iterator ci = groups.begin(); ci != groups.end(); ++ci)
			{
				if(ci->first.size())os<<"\n["<<ci->first<<"]"<<endl;
				gmap::mapped_type v(ci->second);
				
				for(int i = 0; i<v.size();++i)
				{
					const option_description& d = *v[i];
					const string &ln = d.long_name();
					
					if(!m.count(ln))continue;
					
					variable_value vv = m[ln];
					
					if(vv.defaulted())continue;
					
					size_t j = ln.find_last_of('.');
					string key = ln.substr(j+1,ln.size());
					os<<key;
					
					if(vv.empty()){ os<<endl; continue; }	// empty options just get their name written as a flag
					
					os<<" = ";

// now here is major suckage, how to get the types back in a nice way and make it generic?
#define	print_T(T) if(vv.value().type() == typeid(T)){ os<<vv.as<T>(); goto endline; }
			print_T(bool)
			print_T(signed char)
			print_T(unsigned char)
			print_T(signed short)
			print_T(unsigned short)
			print_T(signed int)
			print_T(unsigned int)
			print_T(signed long)
			print_T(unsigned long)
			print_T(signed long long)
			print_T(unsigned long long)
			print_T(float)
			print_T(double)
			print_T(char*)
			print_T(string)
#undef prinf_T

	endline:
					os<<endl;

				}
			}
		}
		
		// writes contents of m that is defined in desc into os
		// preserves file structure and comments

		template<class charT>
		void
		merge_to_config_file(std::basic_iostream<charT>& ios, const options_description& desc, const variables_map& m)
		{
		}

		template
		BOOST_PROGRAM_OPTIONS_DECL void
		persist_to_config_file(std::basic_ostream<char>& os, const options_description& desc, const variables_map& m);
		
		template
		BOOST_PROGRAM_OPTIONS_DECL void
		merge_to_config_file(std::basic_iostream<char>& ios, const options_description& desc, const variables_map& m);

	}
}