// filesystem.cpp : Defines the entry point for the application.
//

#include "stdafx.h"
#include "resource.h"
#include <stdio.h>
#include <stdlib.h>
#include <commctrl.h>
#include <shellapi.h>

LRESULT CALLBACK DialogPrincipal(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);

typedef struct		{
	char nom[32], nom_pc[MAX_PATH];
	int taille;
	char reserve[32];							//Pour une utilisation ultérieure (flags)
} FICHIER;

typedef struct		{
	char nom[32];
	int offset;
	int taille;
} PETIT_FICHIER;

typedef struct		{
	FICHIER *f;
	int nbFichiers;
} TAF;

HWND gblHDlg;
#define MAX_PROJECT_FILE_LENGTH 256
char projectFileName[MAX_PROJECT_FILE_LENGTH], dataFileName[MAX_PROJECT_FILE_LENGTH + 10];

const char test_format[]="**** Game boy advance filesystem by Brünni ****";
const char version[]="1.00";

void Debug(const char *format, ...)		{
	char      vbuf[1024];
	va_list   arg_ptr;
	va_start(arg_ptr, format);
	_vsnprintf(vbuf, sizeof(vbuf), format, arg_ptr);
	MessageBox(NULL,vbuf,"Débogage",0);
}

void Erreur(const char *format, ...)		{
	char      vbuf[1024];
	va_list   arg_ptr;
	va_start(arg_ptr, format);
	_vsnprintf(vbuf, sizeof(vbuf), format, arg_ptr);
	MessageBox(NULL,vbuf,"Erreur",MB_ICONERROR);
}

void Etat(const char *format, ...)		{
	char      vbuf[1024];
	va_list   arg_ptr;
	va_start(arg_ptr, format);
	_vsnprintf(vbuf, sizeof(vbuf), format, arg_ptr);
	SetDlgItemText(gblHDlg,IDC_ETAT,vbuf);
}


/*void LitChne(char *str, size_t nbMax, FILE *f)			{
	char c;

	nbMax--;						//Pour le zéro de fin

	do		{
		c=fgetc(f);

		if (c=='\"')
			break;

		*str++=c;
	} while(--nbMax);
	
	*str=0;
}


void LitArgument(char *str, size_t nbMax, FILE *f)			{
	char c;

	nbMax--;						//Pour le zéro de fin

	do		{
		c=fgetc(f);

		if (c==' ' || c=='	')
			continue;

		if (c==',' || c=='}' || c==')' || c==']')
			break;

		*str++=c;
	} while(--nbMax);
	
	*str=0;
}*/


#define MAX_FICHIERS 1024

/*//TAF (Table d'allocation des fichiers) == FAT <_<
TAF *LitTAF()			{
	int idx;
	FILE *f;
	char str[1000];
	FICHIER *table_alloc=(FICHIER*)malloc(MAX_FICHIERS*sizeof(FICHIER));
	TAF *taf=(TAF*)malloc(sizeof(TAF));

	taf->f=table_alloc;
	memset(table_alloc,0,MAX_FICHIERS*sizeof(FICHIER));

	f=fopen("taf.h","r");

	while(!feof(f))		{
		fgets(str,sizeof(str),f);
		str[strlen(str)-1]=0;
		if (!strcmp(str,"FICHIER liste_fichiers[]=		{"))
			break;
	}

	idx=0;

	while(!feof(f))			{

		//Petit contrôle de format
		fread(str,3,1,f);

		str[3]=0;

		if (!strcmp(str,"	//"))			{
			fgets(str,sizeof(str),f);
			str[strlen(str)-1]=0;
			strcpy(table_alloc[idx].nom_pc,str);
			continue;
		}

		else if (!strcmp(str,"};\n"))							//Lecture terminée correctement...
			break;

		else if (strcmp(str,"	{\""))		{
			Debug(str);
			Erreur("Le format de la table d'allocation est incorrect");
			return NULL;
		}

		//Lecture du nom
		LitChne(table_alloc[idx].nom,32,f);

		//Contrôle
		fread(str,2,1,f);
		str[2]=0;
		if (strcmp(str,", "))		{
			Erreur("Le format de la table d'allocation est incorrect");
			return NULL;
		}

		//Lit la taille
		LitArgument(str,32,f);

		table_alloc[idx].taille=atoi(str);

		if (table_alloc[idx].taille==0)
			Erreur("Un fichier ne peut avoir une taille nulle!\nLa table d'allocation est peut-être corrompue.");

		while(fgetc(f)!='\n' && !feof(f));
		idx++;
	}

	taf->nbFichiers=idx;
	return taf;
}*/


//Convertit une chaîne en hexa
int atox(char *chn)	{
	int i;
	int n;
	int v;
	char *deb;
	deb=chn;
	while((*chn>='0' && *chn<='9') || (*chn>='a' && *chn<='f'))
		chn++;
	chn--;
	i=1;
	n=0;
	while(chn>=deb)	{
		v=*(chn)-48;
		if (v>=17+32)	v-=39;
		if (v>=17)		v-=7;
		n+=i*v;
		i*=16;
		chn--;
	}
	return n;
}


//Idem mais en binaire
int atob(char *chn)	{
	int i;
	int n;
	int v;
	char *deb;
	deb=chn;
	while(*chn=='0' || *chn=='1')
		chn++;
	chn--;
	i=1;
	n=0;
	while(chn>=deb)	{
		v=*(chn)-48;
		n+=i*v;
		i*=2;
		chn--;
	}
	return n;
}

//Compare deux chaînes
char cmpchn(const char *c1, const char *c2)
{
	for (;*c1 && *c2;c1++,c2++) {
		if (*c1!=*c2)
			return 0;
	}
	return 1;
}


TAF *InitTAF()		{
	FICHIER *table_alloc = (FICHIER*)calloc(MAX_FICHIERS, sizeof(FICHIER));
	TAF *taf = (TAF*)calloc(1, sizeof(TAF));

	taf->f=table_alloc;
	memset(table_alloc,0,MAX_FICHIERS*sizeof(FICHIER));
	taf->nbFichiers=0;

	return taf;
}

int TAF_Ajoute(TAF *t, FICHIER *f)		{
	if (t->nbFichiers>=MAX_FICHIERS-1)			{
		Etat("Table d'allocation pleine!");
		return 0;
	}
	memcpy(&t->f[t->nbFichiers],f,sizeof(FICHIER));
	t->nbFichiers++;
	return 1;
}

void TAF_Remplace(TAF *t, int nFichier, FICHIER *f)		{
	memcpy(&t->f[nFichier],f,sizeof(FICHIER));
}


#define MAX_DONNEES (8 << 20)

typedef struct		{
	unsigned char *donnees;
	int nOctetsUtil;
	TAF *taf;
} BLOC;

BLOC *LitDonneesBin(TAF *t)		{
	FILE *f;
	unsigned char *data;
	BLOC *bloc;
	PETIT_FICHIER pf;
	int taille_donnees=0, nbFichiers=0;
	int i;
	char buffer_test[sizeof(test_format)];

	bloc = (BLOC*)calloc(1, sizeof(BLOC));

	data=(unsigned char *)calloc(1, MAX_DONNEES);
	
	f=fopen(dataFileName, "rb");
	if (f)		{
		fread(buffer_test,sizeof(test_format),1,f);
		if (memcmp(buffer_test,test_format,sizeof(test_format)))
			Erreur("Format de fichier binaire erroné!");
		else	{
			fread(&nbFichiers,sizeof(int),1,f);
			for (i=0;i<nbFichiers;i++)			{
				fread(&pf,sizeof(PETIT_FICHIER),1,f);
				strcpy(t->f[i].nom,pf.nom);
				t->f[i].taille=pf.taille;
				strcpy(t->f[i].nom_pc,"");
			}
			taille_donnees=fread(data,1,MAX_DONNEES,f);
		}
		fclose(f);
	}

	bloc->donnees=data;
	bloc->nOctetsUtil=taille_donnees;
	bloc->taf=t;
	bloc->taf->nbFichiers=nbFichiers;
	return bloc;
}

unsigned char *gblData;

void AjouteData(int donnee, int type)			{
//	signed char d7;
	unsigned char d8;
//	signed short d15;
	unsigned short d16;
//	signed long d31;
	unsigned long d32;

/*	if (type==7)			{
		d7=donnee;
		*(signed char *)gblData=d7;
		gblData++;
	}*/
	if (type<=8)			{
		d8=donnee;
		*(unsigned char *)gblData=d8;
		gblData++;
	}
/*	else if (type==15)			{
		d15=donnee;
		*(signed short *)gblData=d15;
		gblData+=2;
	}*/
	else if (type<=16)			{
		d16=donnee;
		*(unsigned short *)gblData=d16;
		gblData+=2;
	}
/*	else if (type==31)			{
		d31=donnee;
		*(signed long *)gblData=d31;
		gblData+=4;
	}*/
	else if (type<=32)			{
		d32=donnee;
		*(unsigned long *)gblData=d32;
		gblData+=4;
	}
}

int LitFichierC(unsigned char *data, const char *nom)			{
	int c, i, type, type_donnees;
	char nombre[1000], chne[1000], *ptr;
	FILE *f;

	gblData=data;

	f=fopen(nom,"r");

	if (!f)		{
		Etat("Fichier %s non-trouvé!",nom);
		return 0;
	}

	while(1)		{
		fgets(chne,sizeof(chne),f);								//Lecture d'une ligne
		ptr=chne;
		while(*ptr=='	' || *ptr==' ')							//Sauter les espaces et tabulations
			ptr++;
		if (*ptr=='/' && *(ptr+1)=='/')							//C'est un commentaire
			continue;
		if (cmpchn(ptr,"const "))			{					//Un tableau (const) est défini
			ptr+=6;
			//Maintenant, il faut détecter le type de données demandé!
			if (cmpchn(ptr,"char ") || cmpchn(ptr,"s8"))
				type_donnees=7;
			else if (cmpchn(ptr,"unsigned char ") || cmpchn(ptr,"u8"))
				type_donnees=8;
			else if (cmpchn(ptr,"short ") || cmpchn(ptr,"s16"))
				type_donnees=15;
			else if (cmpchn(ptr,"unsigned short ") || cmpchn(ptr,"u16"))
				type_donnees=16;
			else if (cmpchn(ptr,"long ") || cmpchn(ptr,"s32") || cmpchn(ptr,"int "))
				type_donnees=31;
			else if (cmpchn(ptr,"unsigned long ") || cmpchn(ptr,"u32") || cmpchn(ptr,"unsigned int "))
				type_donnees=32;
			break;
		}
	}

//	while(fgetc(f)!='{');

	while(!feof(f))			{

		do		{
			c=fgetc(f);
		} while ((c<'0' || c>'9') && !feof(f));

		if (feof(f))
			break;

		type=0;										//Type décimal

		if (c=='0')			{
			c=fgetc(f);								//0x...
			if (c=='x')			{
				type=1;								//Type hexa
				c=fgetc(f);							//Prochain caractère
			}
		}

		i=0;

		while(((c>='0' && c<='9') || (c>='a' && c<='f')) && i<sizeof(nombre)-1 && !feof(f))			{
			nombre[i++]=c;
			c=fgetc(f);
			if (c>='A' && c<='F')
				c+='a'-'A';
		}

		if (feof(f))
			break;

		nombre[i++]=0;

		if (type==0)
			i=atoi(nombre);
		else
			i=atox(nombre);

		AjouteData(i,type_donnees);
	}

	fclose(f);

	return gblData-data;
}


int LitFichier(unsigned char *data, const char *nom)			{
	FILE *f;
	int taille_donnees;

	//Analyse d'un fichier binaire ou C
	if (!strcmp(nom+strlen(nom)-2,".c"))
		taille_donnees=LitFichierC(data,nom);
	else	{
		f=fopen(nom,"rb");

		if (!f)		{
			Etat("Fichier %s non-trouvé!",nom);
			return 0;
		}

		taille_donnees=fread(data,1,MAX_DONNEES,f);
		fclose(f);
	}

	//Le fichier est vide (et plutôt inutile donc)
	if (taille_donnees<=0)		{
		Etat("Fichier %s vide.",nom);
		return 0;
	}

	//Pour aligner les données à 4 octets près.
	while(taille_donnees%4>0)			{
		*(char*)(data+taille_donnees)=0;
		taille_donnees++;
	}

	return taille_donnees;
}


FICHIER *AjouteFichier(BLOC *bloc, char *nom)		{
	unsigned char *data;
	int taille_donnees;
	FICHIER *fich;

	data=(unsigned char *)malloc(MAX_DONNEES);
	fich=(FICHIER *)malloc(sizeof(FICHIER));

	taille_donnees=LitFichier(data,nom);
	if (!taille_donnees)			{
		free(data);
		return NULL;
	}

	if (taille_donnees+bloc->nOctetsUtil>=MAX_DONNEES)		{
		Etat("Impossible d'ajouter: Le fichier binaire est plein!");
		free(data);
		return NULL;
	}

	memcpy(bloc->donnees+bloc->nOctetsUtil,data,taille_donnees);
	bloc->nOctetsUtil+=taille_donnees;

	fich->taille=taille_donnees;

	free(data);
	return fich;
}

void EcritDonneesBin(BLOC *b)		{
	FILE *f;
	int i, offset=0;
	PETIT_FICHIER pf;

	f=fopen(dataFileName, "wb");

	fwrite(test_format,sizeof(test_format),1,f);
	fwrite(&b->taf->nbFichiers,sizeof(int),1,f);

	for (i=0;i<b->taf->nbFichiers;i++)				{
		strcpy(pf.nom,b->taf->f[i].nom);
		pf.taille=b->taf->f[i].taille;
		pf.offset=offset;
		fwrite(&pf,sizeof(PETIT_FICHIER),1,f);
		offset+=pf.taille;
	}

	fwrite(b->donnees,b->nOctetsUtil,1,f);
	fclose(f);
}

void EcritProjet(BLOC *b)			{
	FILE *f;

	f=fopen(projectFileName, "wb");
	fwrite(version,sizeof(version),1,f);
	fwrite(b->taf->f,sizeof(FICHIER),b->taf->nbFichiers,f);
	fclose(f);
}

//En fait, cela va remplacer la table d'alloc lue dans le fichier binaire par celle-ci, plus complète. On pourrait imaginer une détection d'erreurs ainsi...
void LitProjet(BLOC *b)			{
	FILE *f;
	char buffer_test[sizeof(version)];
	int fichiersLus;

	f=fopen(projectFileName, "rb");

	if (f)		{
		fread(buffer_test,sizeof(buffer_test),1,f);
		if (strcmp(buffer_test,version))		{
			Erreur("Votre fichier est de version %s.\nLa version actuelle (%s) ne propose pas d'importation pour votre fichier et va le remplacer par un nouveau...",buffer_test,version);
			memset(b->taf->f,0,MAX_FICHIERS*sizeof(FICHIER));
			b->taf->nbFichiers=0;
			b->nOctetsUtil=0;
			return;
		}
		fichiersLus = fread(b->taf->f, sizeof(FICHIER), MAX_FICHIERS, f);
		if (b->taf->nbFichiers == 0) {
			// Pas de données binaires => importation du fichier pfs
			FICHIER *aImporter = (FICHIER*)malloc(fichiersLus * sizeof(FICHIER));
			memcpy(aImporter, b->taf->f, fichiersLus * sizeof(FICHIER));

			for (int i = 0; i < fichiersLus; i++) {
				FICHIER *f = AjouteFichier(b, aImporter[i].nom_pc);
				strcpy(f->nom, aImporter[i].nom);
				strcpy(f->nom_pc, aImporter[i].nom_pc);
				memcpy(f->reserve, aImporter[i].reserve, sizeof(f->reserve));
				f->taille = aImporter[i].taille;
				TAF_Ajoute(b->taf, f);
			}
		}
		fclose(f);
	}
}

int TrouveFichier(BLOC *b, int nFich)		{
	int i, offset=0;
	for (i=0;i<nFich;i++)
		offset+=b->taf->f[i].taille;
	return offset;
}

void EffaceFichier(BLOC *b, int nFich)		{
	int taille, offset;

	offset=TrouveFichier(b,nFich);
	taille=b->taf->f[nFich].taille;

	memmove(b->donnees+offset,b->donnees+offset+taille,b->nOctetsUtil-offset-taille);
	b->nOctetsUtil-=taille;

	memmove(&b->taf->f[nFich],&b->taf->f[nFich+1],(b->taf->nbFichiers-(nFich+1))*sizeof(FICHIER));
	b->taf->nbFichiers--;
}

int RedimensionneFichier(BLOC *b, int nFich, int nouvelleTaille)		{
	int taille, offset, difference;

	offset=TrouveFichier(b,nFich);
	taille=b->taf->f[nFich].taille;
	difference=nouvelleTaille-taille;

	if (b->nOctetsUtil+difference>=MAX_DONNEES)		{
		Etat("Impossible d'ajouter: Le fichier binaire est plein!");
		return 0;
	}

	memmove(b->donnees+offset+nouvelleTaille,b->donnees+offset+taille,b->nOctetsUtil-offset-taille);
	b->nOctetsUtil+=difference;

	b->taf->f[nFich].taille=nouvelleTaille;

	return 1;
}

FICHIER *RemplaceFichier(BLOC *bloc, int nFichier, char *nom)		{
	unsigned char *data;
	int taille_donnees, offset;
	FICHIER *fich;

	data=(unsigned char *)malloc(MAX_DONNEES);
	fich=&bloc->taf->f[nFichier];

	if (nom==NULL)
		nom=bloc->taf->f[nFichier].nom_pc;

	taille_donnees=LitFichier(data,nom);
	if (!taille_donnees)			{
		free(data);
		return NULL;
	}

	if (!RedimensionneFichier(bloc,nFichier,taille_donnees))
		return NULL;

	offset=TrouveFichier(bloc,nFichier);

	memcpy(bloc->donnees+offset,data,taille_donnees);

	fich->taille=taille_donnees;
	free(data);

	return fich;
}

FICHIER *InsereFichier(BLOC *bloc, int nFichier, char *nom)		{
	unsigned char *data;
	int taille_donnees, offset;
	FICHIER *fich;

	data=(unsigned char *)malloc(MAX_DONNEES);
	fich=(FICHIER *)malloc(sizeof(FICHIER));

	taille_donnees=LitFichier(data,nom);
	if (!taille_donnees)			{
		free(data);
		return NULL;
	}

	offset=TrouveFichier(bloc,nFichier);

	memmove(bloc->donnees+offset+taille_donnees,bloc->donnees+offset,bloc->nOctetsUtil-offset);
	bloc->nOctetsUtil+=taille_donnees;

	memmove(&bloc->taf->f[nFichier+1],&bloc->taf->f[nFichier],(bloc->taf->nbFichiers-nFichier)*sizeof(FICHIER));
	bloc->taf->nbFichiers++;

	memcpy(bloc->donnees+offset,data,taille_donnees);
	fich->taille=taille_donnees;

	free(data);

	return fich;
}


void Liste_AjouteElement(HWND hListe, FICHIER *f, int i)		{
	LVITEM lvi;
	char str[1000];

	// Initialize LVITEM members that are common to all items. 
	lvi.mask = LVIF_TEXT | LVIF_STATE;
	lvi.state = 0; 
	lvi.stateMask = 0; 
	lvi.pszText = f->nom;   // app. maintains text
	lvi.iImage = 0;                     // image list index
	// Initialize item-specific LVITEM members. 
	lvi.iItem = i;
	lvi.iSubItem = 0;
	lvi.lParam = (LPARAM) NULL;    // item data

	ListView_InsertItem(hListe,&lvi);

	ListView_SetItemText(hListe,
			i,
			1,
			f->nom_pc[0]?f->nom_pc:"(aucun)");

	sprintf(str,"%i",f->taille);
	ListView_SetItemText(hListe,
			i,
			2,
			str);

}

void Message_repos(BLOC *b)		{
	char str[1000];
	Etat("Travail effectué");
	if (b->nOctetsUtil>=1048576)
		sprintf(str,"%#.2f Mo (%02i%%)",b->nOctetsUtil/1048576.0,100*b->nOctetsUtil/MAX_DONNEES);
	else
		sprintf(str,"%i ko (%02i%%)",(b->nOctetsUtil+512)/1024,100*b->nOctetsUtil/MAX_DONNEES);
	SetDlgItemText(gblHDlg,IDC_MEMOIRE,str);
}


char *FaitNomSymbole(char *str)			{
	char *ptr;
	ptr=str+strlen(str)-1;
	while(ptr>str && *ptr!='\\')
		ptr--;
	if (*ptr=='\\')
		return ptr+1;
	else
		return ptr;
}

LRESULT CALLBACK DialogPrincipal(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)		{
	static TAF *taf;
	static BLOC *bloc;
	int i;
	static int nObjSelect=-1;
	char str[1000];
	LVCOLUMN lvc;

	switch (message)
	{
		case WM_INITDIALOG:
			gblHDlg=hDlg;

			ShowWindow(hDlg,SW_SHOW);
			Etat("Chargement en cours...");
			taf=InitTAF();

			if (!taf)			{
				DestroyWindow(hDlg);
				return TRUE;
			}

			bloc = LitDonneesBin(taf);
			LitProjet(bloc);

//			f=fopen("test.txt","r");
//			InitListViewItems(GetDlgItem(hDlg,IDC_LISTEFICHIERS),f);
			// Initialize the LVCOLUMN structure. 
			lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM; 
			lvc.fmt = LVCFMT_LEFT;
			lvc.cx = 50; 

			lvc.pszText = "Taille";
			lvc.iSubItem = 1; 
			if (ListView_InsertColumn(GetDlgItem(hDlg,IDC_LISTEFICHIERS), 0, &lvc) == -1) 
				return FALSE;


			lvc.cx = 100; 
			lvc.pszText = "Nom original";
			lvc.iSubItem = 2; 
			if (ListView_InsertColumn(GetDlgItem(hDlg,IDC_LISTEFICHIERS), 0, &lvc) == -1) 
				return FALSE;

			lvc.iSubItem = 3;
			lvc.pszText = "Symbole";
			if (ListView_InsertColumn(GetDlgItem(hDlg,IDC_LISTEFICHIERS), 0, &lvc) == -1) 
				return FALSE;


reecrit:
			SetDlgItemText(hDlg,IDC_NOM,"");
			SetDlgItemText(hDlg,IDC_FICHIER,"");
			SetDlgItemText(hDlg,IDOK,"Ajouter");
			nObjSelect=-1;

			ListView_DeleteAllItems(GetDlgItem(hDlg,IDC_LISTEFICHIERS));

			for (i=0;i<taf->nbFichiers;i++)		{
				Liste_AjouteElement(GetDlgItem(hDlg,IDC_LISTEFICHIERS),&taf->f[i],i);
			}

			SendDlgItemMessage(hDlg,IDC_NOM,EM_SETLIMITTEXT,23,0);

			Message_repos(bloc);
			return TRUE;

		case WM_NOTIFY:
/*			i=((LPNMHDR) lParam)->code;
			if (i!=-7 && i!=-8 && i!=-12 && i!=-102)
				Debug("%i",i);*/
			switch (((LPNMHDR) lParam)->code) {

				case LVN_KEYDOWN :
					NMLVKEYDOWN *pnkd;
					pnkd = (LPNMLVKEYDOWN) lParam;
					if (pnkd->wVKey==VK_DELETE)			{
						if (nObjSelect!=-1)		{
							EffaceFichier(bloc,nObjSelect);
							goto reecrit;
						}
					}
					break;

				case LVN_ITEMCHANGED :
					LPNMLISTVIEW pnmv;

					pnmv = (LPNMLISTVIEW) lParam;

/*					i=ListView_GetNextItem(GetDlgItem(hDlg,IDC_LISTEFICHIERS),-1,LVNI_SELECTED);
					SetDlgItemText(hDlg,IDC_NOM,taf->f[i].nom);
					SetDlgItemText(hDlg,IDC_FICHIER,taf->f[i].nom_pc);*/

					if (pnmv->uNewState&LVIS_SELECTED)				{
						i=pnmv->iItem;
						SetDlgItemText(hDlg,IDC_NOM,taf->f[i].nom);
						SetDlgItemText(hDlg,IDC_FICHIER,taf->f[i].nom_pc);
						SetDlgItemText(hDlg,IDOK,"Mettre à jour");
						nObjSelect=i;
					}
					else	{
						SetDlgItemText(hDlg,IDC_NOM,"");
						SetDlgItemText(hDlg,IDC_FICHIER,"");
						SetDlgItemText(hDlg,IDOK,"Ajouter");
						nObjSelect=-1;
					}

/*					GetCursorPos(&point);
					ScreenToClient(GetDlgItem(hDlg,IDC_LISTEFICHIERS),&point);
					lvhti.pt.x=point.x;
					lvhti.pt.y=point.y;
					i=ListView_HitTest(GetDlgItem(hDlg,IDC_LISTEFICHIERS),&lvhti);
					Debug("Sélectionné l'élément: %i",i);*/
					break;
			}

			break;


		case WM_DROPFILES:
			HDROP hDrop;

			hDrop = (HDROP) wParam;

			DragQueryFile(hDrop,0,str,sizeof(str));

			nObjSelect=-1;
			SetDlgItemText(hDlg,IDC_FICHIER,str);
			SetDlgItemText(hDlg,IDOK,"Ajouter");

			SetDlgItemText(hDlg,IDC_NOM,FaitNomSymbole(str));

			break;

		case WM_COMMAND:

			if (LOWORD(wParam) == IDM_TAB)
				SendMessage(hDlg,WM_NEXTDLGCTL,FALSE,FALSE);

			if (LOWORD(wParam) == IDM_SHIFT_TAB)
				SendMessage(hDlg,WM_NEXTDLGCTL,TRUE,FALSE);

			if (LOWORD(wParam) == IDM_MAJTOUT)			{
				Etat("Mise à jour des symboles...");

				for (i=0;i<bloc->taf->nbFichiers;i++)			{
					if (!RemplaceFichier(bloc,i,NULL))
						return FALSE;
				}

				Message_repos(bloc);
				goto reecrit;
			}

			//Fermer
			if (LOWORD(wParam) == IDCANCEL || LOWORD(wParam) == IDM_QUITTER)
			{
				EcritDonneesBin(bloc);
				EcritProjet(bloc);
				DestroyWindow(hDlg);
				PostQuitMessage(0);
				return TRUE;
			}

			if (LOWORD(wParam) == IDM_QUITTERSANSSAUVER)		{
				DestroyWindow(hDlg);
				PostQuitMessage(0);
				return TRUE;
			}

			if (LOWORD(wParam) == IDM_ECRIRE)		{
				EcritDonneesBin(bloc);
				EcritProjet(bloc);
			}

			if (LOWORD(wParam) == IDOK)			{
				char nom_interne[100];
				FICHIER *fich;

				GetDlgItemText(hDlg,IDC_NOM,nom_interne,sizeof(nom_interne));
				if (!nom_interne[0])			{
					Etat("Veuillez spécifier un nom de symbole!");
					break;
				}
				
				GetDlgItemText(hDlg,IDC_FICHIER,str,sizeof(str));
//				f=fopen(str,"rb");

				if (!str[0])			{
					Etat("Aucun fichier en entrée!");
					break;
				}

				Etat("Ajout du fichier...");

				if (nObjSelect==-1)
//					fich=InsereFichier(bloc,2,str);
					fich=AjouteFichier(bloc,str);
				else
					fich=RemplaceFichier(bloc,nObjSelect,str);

				if (!fich)
					break;

				strcpy(fich->nom_pc,str);

				strcpy(fich->nom,nom_interne);

				if (nObjSelect==-1)		{
					if (!TAF_Ajoute(taf,fich))
						break;
//					TAF_Remplace(taf,2,fich);
				}

				Message_repos(bloc);
				goto reecrit;
			}

			break;
	}

    return FALSE;
}


void DoCmd(int cmdNb)			{
	TAF *taf;
	BLOC *bloc;
	int i;

	//Lecture
	taf=InitTAF();

	if (!taf)
		return;

	bloc=LitDonneesBin(taf);
	LitProjet(bloc);

	//Gestion
	if (cmdNb==1)			{
		for (i=0;i<bloc->taf->nbFichiers;i++)			{
			if (!RemplaceFichier(bloc,i,NULL))
				return;
		}
	}


	//Ecriture
	EcritDonneesBin(bloc);
	EcritProjet(bloc);
}

int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
	HWND hWnd;
	MSG msg;
	HACCEL hAccelTable;

	strcpy(projectFileName, "projet.pfs");
	strcpy(dataFileName, "donnees.bin");
	if (*lpCmdLine != '/' && *lpCmdLine) {
		int i = 0;
		// Nom de fichier projet
		if (*lpCmdLine == '\"') {
			lpCmdLine++;
			while (*lpCmdLine != '\"' && *lpCmdLine && i < MAX_PROJECT_FILE_LENGTH - 1)
				projectFileName[i++] = *lpCmdLine++;
			projectFileName[i] = 0;
		}
		else {
			while (*lpCmdLine != ' ' && *lpCmdLine && i < MAX_PROJECT_FILE_LENGTH - 1)
				projectFileName[i++] = *lpCmdLine++;
			projectFileName[i] = 0;
		}
		
		// Met à jour le nom du fichier de données aussi
		while (projectFileName[i] != '\\' && projectFileName[i] != '/' && i > 0)
			i--;
		strncpy(dataFileName, projectFileName, i);
		if (i > 0)
			strcat(dataFileName, "\\donnees.bin");
	}

	if (*lpCmdLine == '/') {
		if (!strncmp(lpCmdLine, "/updateall", 10)) {
			DoCmd(1);
			return 0;
		}
	}

	LoadLibrary("comctl32.dll");

	hWnd=CreateDialog(hInstance,(LPCTSTR)IDD_MAIN,NULL,(DLGPROC)DialogPrincipal);
	hAccelTable=LoadAccelerators(hInstance,(LPCTSTR)IDR_ACCELMAIN);

	while (GetMessage(&msg, NULL, 0, 0)/* && !Quitter*/)
	{
		if (!TranslateAccelerator(hWnd, hAccelTable, &msg))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}
	return 0;
}

