/*
	Essai de faire une classe constexpr analysant la chaine de controle d'un printf

	But:
		Faire comme un printf
		Permettre de passer des types arbitraires pourront facilement
			être compatible
			(juste à ajouter une fonction non member myfcnv)
		Validation à la compilation de la chaîne de contrôle et du nombre
			d'arguments
		Si la chaîne de contrôle n'est pas une constante, le nombre d'argument
			est validable lors de l'exécution et les paramètres sont
			correctement formattés.
			Pas encore fait. Uniquement la chaîne constante est faite.
		Il faut que ça soit facile de créer ses propres fonctions 'à la printf'
			en utilisant ce projet. Pas encore fait.


Requiert c++17. On doit utiliser un lambda pour passer la chaîne de contrôle.
La performance est proche de printf.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <tlmplib.h>
#include <string>
#include <vector>
#include <array>
#include <functional>
#include "getnow.h"

using namespace std;

struct PARSEELM{
	enum ELMTYPE {is_sequence,is_int,is_unsigned,is_bool,is_string, is_float} type;
	size_t pos;
	size_t skip;
	short val1;
	unsigned short val2;
	#if 0
	PARSEELM(){
		type = is_sequence;
		val1 = 0;
		val2 = 0;
	} 
	#endif
};
using arrayctl = array<PARSEELM,10>;
constexpr arrayctl parse (const char *s)
{
	arrayctl ret={{{PARSEELM::is_sequence,0,0,0,0}}};	//,{PARSEELM::is_sequence,0,0,0,0},{PARSEELM::is_sequence,0,0,0,0},{PARSEELM::is_sequence,0,0,0,0},{PARSEELM::is_sequence,0,0,0,0}}};
	const char *start = s;
	for (unsigned n=0; n<ret.size(); n++){
		for (; *s != '\0'; s++){
			if (*s == '%'){
				//static_assert(n<5,"Trop de %");
				ret[n].pos = s-start;
				s++;
				bool sign = false;
				if (*s == '-'){
					sign = true;
					s++;
				}	
				while (isdigit(*s)){
					ret[n].val1 = ret[n].val1*10 + *s - '0';
					s++;
				}
				if (sign) ret[n].val1 = -ret[n].val1;
				if (*s == '.'){
					s++;
					while (isdigit(*s)){
						ret[n].val2 = ret[n].val2*10 + *s - '0';
						s++;
					}
				}
				if (*s == 'd'){
					ret[n].type = PARSEELM::is_int;
				}else if (*s == 'u'){
					ret[n].type = PARSEELM::is_unsigned;
				}else if (*s == 'b'){
					ret[n].type = PARSEELM::is_bool;
				}else if (*s == 'f'){
					ret[n].type = PARSEELM::is_float;
				}else if (*s == 's'){
					ret[n].type = PARSEELM::is_string;
				}
				s++;
				ret[n].skip = s-start;
				break;
			}
		}
	}
	return ret;
}
constexpr unsigned nbelm(const arrayctl &t)
{
	unsigned ret=0;
	for (; ret < t.size(); ret++){
		if (t[ret].type == PARSEELM::is_sequence) break;
	}
	return ret;
}

struct PARSE{
	const char *pt;
	arrayctl p;
	constexpr PARSE(const char *_pt, arrayctl _p)
		:pt(_pt),p(_p)
	{
	}
	constexpr PARSE(const char *_pt)
		:pt(_pt),p(parse(_pt))
	{
	}
	constexpr unsigned nbelm() const{
		return ::nbelm(p);
	}
	void dump (const char *name) const{
		printf ("name=%s nbelm=%u pt=%s\n",name,nbelm(),pt);
		for (auto &v:p) printf ("\ttype=%u pos=%lu skip=%lu val1=%u val2=%u\n",v.type,v.pos,v.skip,v.val1,v.val2);
	}
};

#if 0
constexpr PARSE parse2 (const char *s)
{
	PARSE ret(s,{{{PARSEELM::is_sequence,0,0,0,0},{PARSEELM::is_sequence,0,0,0,0},{PARSEELM::is_sequence,0,0,0,0},{PARSEELM::is_sequence,0,0,0,0},{PARSEELM::is_sequence,0,0,0,0}}});
	return ret;
}
#endif

struct myfarg{
	std::function<void(unsigned,unsigned)> f;
	myfarg(){}
	myfarg(std::function<void(unsigned,unsigned)> &&_f) : f(move(_f)){}
};
	
static FILE *fout = stdout;
static bool no_output = false;
	

//int myfdo(const PARSE &p, const vector<myfarg> &args)
int myfdo(const PARSE &p, const myfarg args[])
{
	size_t lastpos = 0;
	for (unsigned i=0; i<p.p.size(); i++){
		const PARSEELM &pe = p.p[i];
		if (pe.type == PARSEELM::is_sequence) break;
		if (!no_output){
			size_t pos = pe.pos;
			if (lastpos < pos){
				fwrite (p.pt+lastpos,1,pos-lastpos,fout);
			}
			auto &arg = args[i];
			switch(pe.type){
			case PARSEELM::is_int:
				arg.f(pe.val1,pe.val2);
				break;
			case PARSEELM::is_unsigned:
				arg.f(pe.val1,pe.val2);
				break;
			case PARSEELM::is_bool:
				arg.f(pe.val1,pe.val2);
				break;
			case PARSEELM::is_string:
				arg.f(pe.val1,pe.val2);
				break;
			case PARSEELM::is_float:
				arg.f(pe.val1,pe.val2);
				break;
			case PARSEELM::is_sequence:
				break;
			}
		}
		lastpos = pe.skip;
	}
	if (!no_output) fputs (p.pt+lastpos,fout);
	return 0;
}
static const char *itoa(int v)
{
	static char buf[20];
	#if 0
		buf[0] = '0';
		buf[1] = '\0';
		return buf;
	#endif
	if (v == 0){
		buf[0] = '0';
		buf[1] = '\0';
		return buf;
	}else{
		buf[19] = '\0';
		char *pt = buf+19;;
		while (v != 0){
			pt--;
			*pt = (v % 10)+'0';
			v = v/10;
		}
		return pt;
	}
}


void myfcnv(short p1, short p2, const char *v)
{
	if (p1 == 0){
		fputs (v,fout);
	}else if (p1 < 0){
		p1 = -p1;
		short l=0;
		while (*v != '\0'){
			fputc(*v++,fout);
			l++;
		}
		for (; l<p1; l++) fputc(' ',fout);	
	}else{
		int len = strlen(v);
		for (; len < p1; len++) fputc(' ',fout);
		fputs (v,fout);
	}
}
void myfcnv(short p1, short p2, int v)
{
	myfcnv(p1,p2,itoa(v));
}
void myfcnv(short p1, short p2, unsigned v)
{
	myfcnv(p1,p2,itoa(v));
}
void myfcnv(short p1, short p2, double v)
{
	if (p1 == 0 && p2 == 0){
		fprintf (fout,"%lf",v);
	}else if (p1 != 0 && p2 == 0){
		fprintf(fout,"%*lf",p1,v);
	}else{
		fprintf(fout,"%*.*lf",p1,p2,v);
	}
}
void myfcnv(short p1, short p2, const string &v)
{
	myfcnv(p1,p2,v.c_str());
}
struct STRING2{
	string a,b;
	STRING2(const char *_a, const char *_b)
		: a(_a), b(_b)
	{
	}
	STRING2(const STRING2 &) = default;
	STRING2(STRING2 &&) = default;
};

void myfcnv(short p1, short p2, const STRING2 &v)
{
	char tmp[v.a.size()+1+v.b.size()+1];
	strcpy(tmp,v.a.c_str());
	tmp[v.a.size()]=':';
	strcpy(tmp+v.a.size()+1,v.b.c_str());
	myfcnv(p1,p2,tmp);
}

template<typename F, typename T1>
int myf(F f, T1 v1)
{
	constexpr PARSE p(f());
	static_assert(p.nbelm()==1,"nbelm != 1");
	myfarg args[]={
		myfarg([&v1](short p1,short p2){ myfcnv(p1,p2,v1);}),
		};
	myfdo(p,args);
	return 0;
}
template<typename F, typename T1, typename T2>
int myf(F f, T1 v1, T2 v2)
{
	constexpr PARSE p(f());
	static_assert(p.nbelm()==2,"nbelm != 2");
	myfarg args[]={
		myfarg([&v1](short p1,short p2){ myfcnv(p1,p2,v1);}),
		myfarg([&v2](short p1,short p2){ myfcnv(p1,p2,v2);})
		};
	myfdo(p,args);
	return 0;
}
template<typename F, typename T1, typename T2, typename T3>
int myf(F f, T1 v1, T2 v2, T3 v3)
{
	constexpr PARSE p(f());
	static_assert(p.nbelm()==3,"nbelm != 3");
	myfarg args[]={
		myfarg([&v1](short p1,short p2){ myfcnv(p1,p2,v1);}),
		myfarg([&v2](short p1,short p2){ myfcnv(p1,p2,v2);}),
		myfarg([&v3](short p1,short p2){ myfcnv(p1,p2,v3);})
		};
	myfdo(p,args);
	return 0;
}
template<typename F, typename T1, typename T2, typename T3, typename T4>
int myf(F f, T1 v1, T2 v2, T3 v3, T4 v4)
{
	constexpr PARSE p(f());
	static_assert(p.nbelm()==4,"nbelm != 4");
	myfarg args[]={
		myfarg([&v1](short p1,short p2){ myfcnv(p1,p2,v1);}),
		myfarg([&v2](short p1,short p2){ myfcnv(p1,p2,v2);}),
		myfarg([&v3](short p1,short p2){ myfcnv(p1,p2,v3);}),
		myfarg([&v4](short p1,short p2){ myfcnv(p1,p2,v4);})
		};
	myfdo(p,args);
	return 0;
}

static void testmy(unsigned nbrep)
{
	for (unsigned i=0; i<nbrep; i++){
		myf([](){ return "allo %1d %2u\n";},i,2);
		myf([](){ return "allo %1d %2u s=%15s\n";},1,i,"allo");
		//myf([](){ return "allo %1d %2u s=%15s total=%5.2f\n";},1,i,"allo",1.4);
		//myf([](){ return "allo %1d %2u s=%-15s total=%5.2f\n";},i,i,string("allo"),1.4);
	}
}
static void testprintf (unsigned nbrep)
{
	for (unsigned i=0; i<nbrep; i++){
		fprintf (fout,"allo %1d %2u\n",i,2);
		fprintf (fout,"allo %1d %2u s=%15s\n",1,i,"allo");
		//printf ("allo %1d %2u s=%15s total=%5.2f\n",1,i,"allo",1.4);
		//printf ("allo %1d %2u s=%-15s total=%5.2f\n",i,i,string("allo").c_str(),1.4);
	}
}
<mod>
int main (int argc, char *argv[])
{
	glocal int ret = -1;
	glocal unsigned nbrep = 1000;
	glocal bool tonull = false;
	glocal.ret = <call tlmpprogram>(argc,argv);
	<f init>
		setproginfo ("","0.0","...");
		setarg ('n',"nbrep","Nombre de repetition",glocal.nbrep,false);
		setarg ('o',"tonull","Output to /dev/null",glocal.tonull,false);
		setarg ('N',"nooutput","No call to write anything",no_output,false);
	</f>
	<f main_noarg>
		if (glocal.tonull) fout = fopen ("/dev/null","w");
		#if 0
		constexpr arrayctl p = parse ("allo %d %u s=%15s total=%5.2f");
		for (auto &v:p) printf ("type=%u pos=%lu skip=%lu val1=%u val2=%u\n",v.type,v.pos,v.skip,v.val1,v.val2);
		myf (p,"allo %d %u s=%15s total=%5.2f\n",1,2);
		#endif
		//constexpr PARSE p2 = parse2("allo %d %u s=%15s total=%5.2f\n");
		constexpr PARSE p3("allo %d %u s=%15s total=%5.2f\n");

		//p2.dump("p2");
		p3.dump("p3");
		STRING2 s2("allo","comment");
		myf([](){return "s2=%30sXXX\n";},s2);
		myf([](){return "s2=%-30sXXX\n";},s2);
		{
			testmy(glocal.nbrep);
			long long start = getnow();
			testmy(glocal.nbrep);
			long long end = getnow();
			showtime ("myf",start,end);
		}
		{
			testprintf (glocal.nbrep);
			long long start = getnow();
			testprintf (glocal.nbrep);
			long long end = getnow();
			showtime ("printf",start,end);
		}
		return 0;
	</f>
	<f main>
		int ret = -1;
		return ret;
	</f>
	</call>
	return glocal.ret;
}
</mod>