/*
	Essai de faire un template qui remplacerait ceci.

	auto tb = str_splitline(line,',');
	if (tb.size() == 3){
		int a1 = atoi(tb[0].c_str());
		const char *a2 = tb[1].c_str();
		int a3 = atoi(tb[0].c_str());
		...
	}

	auto [ err,a1,a2,a3 ] = splitline(line,',',int,char*,int);
	if (!err){
	}


	Finalement, on a choisit
	int a1,a2;
	unsigned a3;
	string msg;
	if (splitline(line,',',a1,a2,a3,msg)){
	}

	On a ajouté les pseudo fonction limits et enums qui permette de restreindre les valeurs acceptables.
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <tlmplib.h>
#include <string>
#include <vector>
#include <tuple>
#include <iostream>
#include <algorithm>

using namespace std;


void assign(bool &ok, unsigned &a, const string &v)
{
	if (isdigit(v[0])){
		a = atoi(v.c_str());
	}else{
		a = 0;
		ok = false;
	}
}
void assign(bool &ok, int &a, const string &v)
{
	if (isdigit(v[0]) || v[0] == '-'){
		a = atoi(v.c_str());
	}else{
		a = 0;
		ok = false;
	}
}
void assign(bool &ok, bool &a, const string &v)
{
	if (v == "true"){
		a = true;
	}else if (v == "false"){
		a = false;
	}else{
		a = false;
		ok = false;
	}
}
inline void assign(bool &ok, string &a, const string &v)
{
	a = v;
}

inline void reset (unsigned &a)
{
	a = 0;
}
inline void reset (int &a)
{
	a = 0;
}
inline void reset (string &a)
{
	a.clear();
}
inline void reset (bool &a)
{
	a = false;
}
#if 0
template<typename T, typename T1, typename ... Ts>
bool is_any_of(T t, T1 t1, Ts ... ts){
        return is_any_of(t,t1) || is_any_of(t,ts...);
}
#endif

#if 0
template<>
tuple<bool> splitline(const vector<string> &tb,unsigned off)
{
	printf ("bool off=%u\n",off);
	return {true};
}
#endif

#if 0
template<typename T1>
tuple<bool,T1> tb_splitline(const vector<string> &tb, unsigned off)
{
	T1 a1;
	bool ok = false; 
	if (tb.size()==off+1){
		ok = true;
		assign(ok,a1,tb[0]);
	}else{
		reset (a1);
	}
	return {ok,a1};
}
#endif

#if 0
template<typename T1, typename ... Ts>
tuple<bool,T1,Ts ...> tb_splitline(const vector<string> &tb,unsigned off)
{
	printf ("bool,... off=%u\n",off);
	tuple<bool,T1,Ts...> ret;
	T1 a1;
	get<0>(ret) = false; 
	if (tb.size()>off){
		get<0>(ret) = true;
		assign(get<0>(ret),a1,tb[off]);
		auto s = tb_splitline<Ts...>(tb,off+1);
		if (!get<0>(s)) get<0>(ret) = false;
	}else{
		reset (a1);
	}
	return ret;
}
template<typename T1, typename T2, typename T3>
tuple<bool,T1,T2,T3> splitline(const char *line, char split)
{
	auto tb = str_splitline(line,split);
	return tb_splitline<T1,T2,T3>(tb,0);
}
#endif
#if 0
template<typename T1>
tuple<bool,T1> tb_splitline(const vector<string> &tb, unsigned off)
{
	printf ("bool,... off=%u\n",off);
	tuple<bool,T1> ret;
	get<0>(ret) = false; 
	if (tb.size()>off){
		get<0>(ret) = true;
		assign(get<0>(ret),get<1>(ret),tb[off]);
	}else{
		reset (get<1>(ret));
	}
	return ret;
}

template<typename ... TS>
tuple<bool,TS...> splitline(const char *line, char split)
{
	auto tb = str_splitline(line,split);
	return tb_splitline<TS>(tb,0)...;
}

#endif

template<typename T>
class enums_t;
template<typename T>
enums_t<T> enums(T &val, std::initializer_list<T> elements);

template<typename T>
class enums_t{
public:
	T &val;
	std::initializer_list<T> vals;
private:
	friend enums_t enums<T> (T &_val, std::initializer_list<T> elements);
	enums_t(T &_val, std::initializer_list<T> elements):val(_val),vals(elements){}
};
	
template<typename T>
enums_t<T> enums(T &val, std::initializer_list<T> elements){
	return enums_t<T>(val,elements);
}
template<typename T>
void assign(bool &ok, enums_t<T> &a, const string &v)
{
	assign(ok,a.val,v);
	if (ok && find(a.vals.begin(),a.vals.end(),a.val)==a.vals.end()) ok = false;
}
template<typename T>
inline void reset (enums_t<T> &a)
{
	reset(a.val);
}

#if 0
template<typename T>
class limits_t{
public:
	T &val;
	T min;
	T max;
	limits_t(T &_val, T _min, T _max):val(_val),min(_min),max(_max){
		printf ("c1 val=%p\n",&val);
	}
	#if 0
	limits_t() = delete;
	limits_t(const limits_t<T> &t):val(t.val),min(t.min),max(t.max){
		printf ("c2 val=%p\n",&val);
	}
	limits_t & operator = (const limits_t<T> &) = delete;
	#endif
};
#endif
template<typename T>
void assign(bool &ok, limits_t<T> &a, const string &v)
{
	assign(ok,a.val,v);
	if (ok && (a.val < a.min || a.val > a.max)) ok = false;
}
template<typename T>
inline void reset (limits_t<T> &a)
{
	reset(a.val);
}
#if 0
template<typename T>
limits_t<T> limits(T &a, T min, T max){
	return limits_t<T>(a,min,max);
}
#endif
bool tb_splitline (const vector<string> &tb, unsigned off)
{
	//printf ("tb0 %s\n",__PRETTY_FUNCTION__);
	return tb.size() == off;
}

template<typename T, typename ... TS>
bool tb_splitline (const vector<string> &tb, unsigned off, T & v, TS&& ... vs)
{
	//printf ("tb1 off=%u tb.size()=%lu %s\n",off,tb.size(),__PRETTY_FUNCTION__);
	bool ok = false;
	if (off < tb.size()){
		ok = true;
		assign (ok,v,tb[off]);
		if (ok) ok = tb_splitline(tb,off+1,vs...);
	}
	return ok;
}
template<typename ... TS>
bool splitline (const char *line, char split, TS&& ... vs)
{
	auto tb = str_splitline(line,split);
	return tb_splitline (tb,0,forward<TS>(vs)...);
}

<mod>
int main (int argc, char *argv[])
{
	glocal int ret = -1;
	glocal const char *split = ",";
	glocal.ret = <call tlmpprogram>(argc,argv);
	<f init>
		setproginfo ("","0.0","...");
		setarg ('s',"split","split",glocal.split,false);
	</f>
	<f main>
		int ret = -1;
		for (int i=0; i<argc; i++){
			const char *line = argv[i];
			printf ("line=%s\n",line);
			{
				unsigned a1;
				unsigned a2;
				string s;
				limits_t<unsigned> lima2(a2,1,10);
				#if 0
					enums_t<unsigned> enuma2 (a2,{1u,3u,5u});
					printf ("enuma2 %p %p size=%lu\n",&a2,&enuma2.val,enuma2.vals.size());
					for (auto u:enuma2.vals) printf ("vals %u\n",u);
				#endif
				printf ("a2=%p lima2=%p\n",&a2,&lima2.val);
				if (splitline(line,glocal.split[0],a1,s,limits(a2,1u,10u))){
					printf ("%u %s %d\n",a1,s.c_str(),a2);
				}else{
					printf ("Echec\n");
				}
				#if 0
					if (splitline(line,glocal.split[0],a1,s,enuma2)){
						printf ("%u %s %d\n",a1,s.c_str(),a2);
					}else{
						printf ("Echec\n");
					}
				#endif
				if (splitline(line,glocal.split[0],a1,s,enums(a2,{10u,12u,14u}))){
					printf ("%u %s %d\n",a1,s.c_str(),a2);
				}else{
					printf ("Echec\n");
				}
			}
			#if 0
			{
				auto v = splitline<int,string,int>(line,',');
				if (get<0>(v)){
					printf ("%d %s %d\n",get<1>(v),get<2>(v).c_str(),get<3>(v));
				}else{
					printf ("Echec\n");
				}
			}
			{
				auto [ok,a,b,c] = splitline<int,string,int>(line,',');
				if (ok){
					printf ("%d %s %d\n",a,b.c_str(),c);
				}else{
					printf ("Echec\n");
				}
			}
			{
				bool ok;
				int a,c;
				string b;
				tie(ok,a,b,c) = splitline<int,string,int>(line,',');
				if (ok){
					printf ("%d %s %d\n",a,b.c_str(),c);
				}else{
					printf ("Echec\n");
				}
			}
			#endif
		}
		return ret;
	</f>
	</call>
	return glocal.ret;
}
</mod>