/*
	Alternative pour remplacer une longue série de if
		if (val == "cmd1"){
			...
		}else if (val == "cmd2"){
			...
		}

	La solution selone n'est pas plus simple à utiliser qu'un paquet de if et est moins souple. On ne peut pas faire
	break. Mais on peut passer une variable provenant du parent qui peut être testé dans la boucle (s'il y a une boucle).

	La solution SELONE découple l'exécution des cas de l'appel. Cela pourrait offrir certains avantages:

	SELONE sel(...);
	if (...){
		if (...){
			sel.test(val);
		}
	}else{
		sel.test(val);
	}

	La solution SELONE pourrait faire certaines validations. Comme on peut déclarer la variable static,
	ces validations ne coute pas grand chose. On peut vérifier que le cas * est bien à la fin. On ne pas le mettre dans
	le vecteur opts et appelé la fonction si aucune autre n'est appelé. On pourrait aussi 'compiler' les valeurs pour créer une solution
	plus rapide. Par exemple, on pourrait mettre les valeurs dans des string c++ qui sont plus rapide pour comparer parce
	qu'elle contiennent la longueur. On pourrait trier les valeurs dans le tableau et avoir un accès indexés.

	On peut ajouter de l'instrumentation à SELONE sans pertuber le code appelant.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <misc.h>
#include <tlmplib.h>
#include <string>
#include <helper.h>
#include <functional>
#include "getnow.h"
#include <map>

using namespace std;


void selone_foo();
extern long selone_foo_val;

template<typename F>
void selone(PARAM_STRING val, PARAM_STRING opt1, F f)
{
	if (is_eq(opt1,"*") || is_eq(val,opt1)){
		f();
	}
}
template<typename F, typename ...TS>
void selone(PARAM_STRING val, PARAM_STRING opt1, F f, TS ... ts)
{
	static_assert ((sizeof...(ts)%2) == 0,"fonction selone: Les arguments vont par paires");
	if (is_eq(val,opt1)){
		f();
	}else{
		selone(val,ts...);
	}
}

using flambda = function<void()>;
#if 0
template<typename F>
void selone_fill (vector<pair<PARAM_STRING,flambda>> &opts, flambda &inval, PARAM_STRING opt, F f){
	if (is_eq(opt,"*")){
		inval = f;
	}else{
		opts.emplace_back(opt,f);
	}
}


template<typename F, typename ...TS>
void selone_fill (vector<pair<PARAM_STRING,flambda>> &opts, flambda &inval, PARAM_STRING opt, F f, TS ... ts){
	selone_fill (opts,inval,opt,f);
	selone_fill (opts,inval,ts...);
}
#endif

bool operator < (PARAM_STRING p1, PARAM_STRING p2)
{
	return strcmp(p1.ptr,p2.ptr) < 0;
}

template<typename F, typename ...TS>
class SELONE{
	vector<pair<PARAM_STRING,flambda>> opts;
	map<PARAM_STRING,flambda> mapopts;
	flambda inval;
	template<typename FF>
	void fill (PARAM_STRING opt, FF f){
		if (is_eq(opt,"*")){
			inval = f;
		}else{
			opts.emplace_back(opt,f);
			mapopts[opt] = f;
		}
	}
	template<typename FF, typename ...TTS>
	void fill (PARAM_STRING opt, FF f, TTS ... ts){
		fill (opt,f);
		fill (ts...);
	}
public:
	SELONE(PARAM_STRING opt1, F f, TS ...ts){
		fill (opt1,f,ts...);
		//selone_fill (opts,inval,opt1,f,ts...);
	}
	void test(PARAM_STRING val) const {
		#if 1
			auto it = mapopts.find(val);
			if (it == mapopts.end()){
				inval();
			}else{
				it->second();
			}
		#else
			bool found = false;
			for (auto &o:opts){
				if (is_eq(o.first,val)){
					o.second();
					found = true;
					break;
				}
			}
			if (!found && inval) inval();
		#endif
	}
};
		


<mod>
int main (int argc, char *argv[])
{
	glocal int ret = -1;
	glocal bool perf = false;
	glocal const char *opt = "optv19";
	glocal int nbrep = 1000000;
	glocal.ret = <call tlmpprogram>(argc,argv);
	<f init>
		setproginfo ("","0.0","...");
		setarg ('p',"perf","Test performance",glocal.perf,false);
		setarg ('n',"nbrep","Nombre de répétition",glocal.nbrep,false);
		setarg ('o',"opt","Option cherchée",glocal.opt,false);
	</f>
	<f main_noarg>
		int ret = -1;
		if (glocal.perf){
			ret = 0;
			printf ("Test de performance, nbrep=%d\n",glocal.nbrep);
			{
				static SELONE sel(
					#include "/tmp/selone-opts.h"
					);
				auto start = getnow();
				selone_foo_val = 0;
				for (int i=0; i<glocal.nbrep; i++){
					sel.test(glocal.opt);
				}
				auto end = getnow();
				showtime ("objet SELONE",start,end);
				printf ("selone_foo_val=%ld\n",selone_foo_val);
			}
			{
				auto start = getnow();
				selone_foo_val = 0;
				for (int i=0; i<glocal.nbrep; i++){
					selone(glocal.opt,
					#include "/tmp/selone-opts.h"
					);

				}
				auto end = getnow();
				showtime ("fonction selone",start,end);
				printf ("selone_foo_val=%ld\n",selone_foo_val);
			}
		}else{
			usage();
		}
		return ret;
	</f>
	<f main>
		int ret = -1;
		static SELONE sel("v1",[]() {
				printf ("sel v1\n");
			 }
			,"v2",[]() {
				printf ("sel v2\n");
			 }
			,"v3",[&ret]() {
				printf ("sel v3, ret = 0\n");
				ret = 0;
			 }
			,"v4",[](){
				printf ("sel v4\n");
			 }	
			,"*",[](){
				printf ("sel inval\n");
			 }	
			,"v5",[](){
				printf ("sel v5\n");
			 }	
			);
		for (int i=0; i<argc; i++){
			selone(argv[i]
				,"v1",[]() {
					printf ("v1\n");
				 }
				,"v2"s,[]() {
					printf ("v2\n");
				 }
				,"v3",[]() {
					printf ("v3\n");
				 }
				,"v4",[](){
					printf ("v4\n");
				 }	
				,"*",[](){
					printf ("inval\n");
				 }	
				);
			sel.test(argv[i]);
		}
		printf ("ret=%d\n",ret);
		return ret;
	</f>
	</call>
	return glocal.ret;
}
</mod>