/*
	Je ne sais pas encore ce que doit faire ce programme. En gros.

	Cela pourrait s'appliquer à la chimie, mais peut-être à n'importe quoi.

	Si on prend une molécule. Disons H2 et qu'on le met en contact et O2 et qu'on déclenche
	une réaction, on obtient de la chaleur de l'eau (H2O).

	Est-ce possible de prendre les caractéristiques de base de H2 et les caractéristiques de base
	de O2 et de placer tout cela dans une matrice, faire une opération quelquoncque et on obtient
	les caractéristique de base du H20 et un quatrième colonne fournit d'autres caractéristiques tel
	la chaleur dégagée.

	Après avoir obtenu la colonne 3, on utilise un module de recherche pour trouver quel composé aurait
	les caractéristiques de la colonne 3. On peut alors prédire le résultat de la réaction.

	On peut aussi laisser la colonne 2 vide et remplir la colonne 3. En appliquant une solution inverse, on
	peut déduire la colonne 2 à partir de 1 et 3 et 4. Connaissant les caractéristiques de 2, on peut alors
	rechercher le composé qui a ces caractéristiques.

	Il faudrait que la solution fonctionne pour N composés produisant N résultats.

	Le programme actuel est passablement sans but ni idée. On va commencer à écrire un programme
	de solution matriciel et on va l'appliquer à l'écriture de musique (oui oui) et on verra
	où ça nous mènera.

	Une colonne est en fait une matrice. Dans le cas de la musique, chaque ligne commence par la durée
	en 1/64 suivit d'une ou plusieurs notes. Pour rendre les choses plus compliquée, le nombre de ligne
	dans chaque colonne est variable. Dans le cas de la musique, la somme des durées pour toutes les colonnes
	est la même, mais chaque ligne d'une colonne peut avoir une valeur différente.
*/
#include <stdio.h>
#include <string.h>
#include <tlmplib.h>
#include <vector>

using namespace std;

struct SAMPLE{
	int v[4];
	SAMPLE (const int _v[4]){
		memcpy (v,_v,sizeof(v));
	}
};

struct COLUMN {
	vector<SAMPLE> vs;
};


<mod>
int main (int argc, char *argv[])
{
	glocal int ret = 0;
	glocal.ret = <call tlmpprogram>(argc,argv);
	<f init>
		setproginfo ("protide","0","Solutionneur générique");
	</f>
	<f main>
		int ret = -1;
		glocal vector<COLUMN> cols;
		for (int i=0; i<argc; i++){
			glocal COLUMN col;
			<call loadfile>(argv[i],true);
			<f oneline>
				int duration, v[4];
				memset (v,0,sizeof(v));
				int n = sscanf (line,"%d %d %d %d %d",&duration,&v[0],&v[1],&v[2],&v[3]);
				if (n < 2){
					tlmp_error ("File %s, line %d, not enough values\n",info.filename,noline);
				}else{
					for (int i=0; i<duration; i++){
						glocal.col.vs.push_back(SAMPLE(v));
					}
				}
				return 0;
			</f>
			</call>
			glocal.cols.push_back(glocal.col);
		}
		unsigned size = glocal.cols[0].vs.size();
		bool some_errors = false;
		for (unsigned i=1; i<glocal.cols.size(); i++){
			unsigned i_size = glocal.cols[i].vs.size();
			if (glocal.cols[i].vs.size() != size){
				tlmp_error ("Column %u has different size than column 0: %u <> %u\n",i,size,i_size);
				some_errors = true;
			}
		}
		if (!some_errors){
			for (unsigned i=0; i<size; i++){
				printf ("%04d: ",i);
				for (unsigned j=0; j<glocal.cols.size(); j++){
					COLUMN &col = glocal.cols[j];
					printf ("{ %d %d %d %d } "
						,col.vs[i].v[0]
						,col.vs[i].v[1]
						,col.vs[i].v[2]
						,col.vs[i].v[3]);
				}
				printf ("\n");
			}
		}
		
		return ret;
	</f>
	</call>
	return glocal.ret;
}
</mod>