/*****************************************************************************\
* IMPORT.C - Importation des fichiers d'un dossier                            *
* Auteur : Daniel Coulom - danielcoulom@gmail.com                             *
* Creation : Avril 2010                                                       *
\*****************************************************************************/

#include <stdio.h>
#include <string.h>
#include <dirent.h>
#include "dcfdutil.h"

//variables globales
FILE *fp;
char filename[256];
int filesize;
int newblock;

//variables externes
extern FILE *fdisk;
extern char *diskname;
extern char diskfilename[];
extern char folder[];
extern char fat[];
extern char cat[];
extern char string[];
extern int unite;
extern int type;
extern int unitsize;
extern int sectorsize;
extern int filesectorsize;
extern int blocksize;
extern int fatoffset;
extern int fatlength;
extern int catlength;
extern char cat_filename[];
extern char cat_comments[];
extern int cat_filetype;
extern int cat_datatype;
extern int cat_firstblock;
extern int cat_lastsectorsize;
extern int cat_flag;

//Allocation du premier bloc d'un fichier//////////////////////////////////////
void Firstalloc()
{
 int i, blockcount;
 blockcount = unitsize / blocksize;
 i = blockcount / 2;
 while(i < blockcount)
 {
  if((fat[i + 1] & 0xff) == 0xff) break;
  i = blockcount - i;
  if((fat[i + 1] & 0xff) == 0xff) break;
  i = blockcount + 1 - i;
 }
 newblock = i;
}

//Allocation des blocs suivants///////////////////////////////////////////////
void Nextalloc()
{
 int i, blockcount;
 i = newblock;
 blockcount = unitsize / blocksize;
 while(1)
 {
  if(i == 0) {Firstalloc(); return;}
  if((fat[i + 1] & 0xff) == 0xff) break;
  i--;
  if(i < blockcount / 2) continue;
  i += 2;
  if(i >= blockcount) {Firstalloc(); return;}
 }
 newblock = i;
}

//Mise a jour du catalogue////////////////////////////////////////////////////
int Updatecat(int n, int lastsectorsize)
//retour: 0=OK, negatif=fichier existant
{
 int i, n1, n2;
 //initialisation a blanc du filename thomson
 for(i = 0; i < 11; i++) cat_filename[i] = ' ';
 //determination de l'extension thomson
 for(n1 = strlen(filename); n1 >= 0; n1--) if(filename[n1] == '.') break;
 if(n1 < 0) n1 = strlen(filename);  //pas d'extension
 if(n1 > 8) n1 = 8;                 //le nom du fichier est <= 8
 for(i = 0; i < n1; i++) cat_filename[i] = filename[i]; //nom du fichier
 n2 = strlen(filename) - n1 - 1;    //longueur de l'extension
 if(n2 > 3) n2 = 3;
 for(i = 0; i < n2; i++) cat_filename[8 + i] = filename[n1 + i + 1];
 for(i = 0; i < 3; i++) string[i] = cat_filename[8 + i];
 string[3] = 0;
 //recherche d'existence du fichier dans le catalogue
 for(i = 0; i < 112; i++)
 if(memcmp(cat_filename, cat + 32 * i, 11) == 0) return -1;
 //determination du type de fichier
 cat_filetype = 2;
 if(strcasecmp(string, "BAS") == 0) cat_filetype = 0;
 if(strcasecmp(string, "BAT") == 0) cat_filetype = 0;
 if(strcasecmp(string, "DAT") == 0) cat_filetype = 1;
 if(strcasecmp(string, "ASC") == 0) cat_filetype = 1;
 if(strcasecmp(string, "TXT") == 0) cat_filetype = 1;
 //determination du type de donnees
 cat_datatype = 0;
 //attention: la determination du type de donnees n'est pas correcte
 //if(strcasecmp(string, "BAS") == 0) cat_datatype = 255;
 //if(strcasecmp(string, "BAT") == 0) cat_datatype = 255;
 if(strcasecmp(string, "DAT") == 0) cat_datatype = 255;
 if(strcasecmp(string, "ASC") == 0) cat_datatype = 255;
 if(strcasecmp(string, "TXT") == 0) cat_datatype = 255;
 //initialisation des autres champs
 for(i = 0; i < 15; i++) cat_comments[i] = 0;
 cat_flag = 0;
 cat_firstblock = newblock;
 cat_lastsectorsize = lastsectorsize;
 if(cat_lastsectorsize == 0) cat_lastsectorsize = filesectorsize;
 //ecriture dans le catalogue
 Putcat(n);
 //affichage du compte-rendu
 for(i = 0; i < 8; i++) string[i] = cat_filename[i];
 string[8] = ' ';
 for(i = 0; i < 3; i++) string[9 + i] = cat_filename[i + 8];
 string[12] = ' ';
 sprintf(string + 13, "%02x %02x  %02x %03x",
         cat_filetype, cat_datatype, cat_firstblock, cat_lastsectorsize);
 Display(string);
 return 0;
}

//Importation d'un bloc////////////////////////////////////////////////////////
void Importblock(int blocklength, int blocknumber)
{
 int i;
 int lastsectorlength;
 char buffer[blocklength];
 lastsectorlength = blocklength;
 for(i = 0; i < blocklength; i++) buffer[i] = 0;
 //secteurs complets
 for(i = 0; i < blocklength / sectorsize; i++)
 {
  fread(buffer + i * sectorsize, filesectorsize, 1, fp);
  lastsectorlength -= sectorsize;
 }
 //secteur incomplet
 if(lastsectorlength > 0) fread(buffer + i * sectorsize, lastsectorlength, 1, fp);
 //ecriture du bloc dans le fichier .fd
 fseek(fdisk, unite * unitsize + blocknumber * blocksize, SEEK_SET);
 fwrite(buffer, blocklength, 1, fdisk);
}

//Importation d'un fichier/////////////////////////////////////////////////////
void Importfile()
{
 int i, n;
 //int bloc;
 int nsectors;
 int nfullsectors;
 int incompletesectorsize;
 int nfullblocks;
 int blocksectors;
 int incompleteblocksectors;
 int currentblock;
 //ouverture du fichier
 strcpy(string, folder);
 strcat(string, filename);
 fp = fopen(string, "rb");
 if(fp == NULL) {Display(string); Erreur(2); return;}
 //taille du fichier
 fseek(fp, 0, SEEK_END);
 filesize = ftell(fp);
 fseek(fp, 0, SEEK_SET);
 //nombre de secteurs complets
 nfullsectors = filesize / filesectorsize;
 //taille du secteur incomplet
 incompletesectorsize = filesize - nfullsectors * filesectorsize;
 //nombre total de secteurs
 nsectors = nfullsectors;
 if(incompletesectorsize > 0) nsectors++;
 //nombre de blocs complets
 blocksectors = blocksize / sectorsize;
 nfullblocks = nsectors / blocksectors;
 //nombre de secteurs du bloc incomplet
 incompleteblocksectors = nsectors - nfullblocks * blocksectors;
 //allocation du premier bloc
 Firstalloc();
 if(newblock > 159) {Erreur(14); return;} //disquette pleine
 currentblock = newblock;
 //recherche place libre dans le catalogue
 for(n = 0; n < 112; n++)
 {
  if(cat[32 * n] == 0) break;
  if((cat[32 * n] & 0xff) == 0xff) break;
 }
 if(n > 111) {Erreur(14); return;} //disquette pleine
 //mise a jour du catalogue
 if(Updatecat(n, incompletesectorsize) < 0) {Display(filename); Erreur(15); return;}
 //ecriture des blocs complets (8 secteurs)
 for(i = 0; i < nfullblocks; i++)
 {
  //ecriture du bloc
  currentblock = newblock;
  Importblock(blocksize, currentblock);
  //allocation du prochain bloc
  fat[currentblock + 1] = 0; //pour ne pas reallouer le meme bloc
  Nextalloc();
  fat[currentblock + 1] = newblock;
 }
 //indicateur de fin en l'absence de bloc incomplet
 if(incompleteblocksectors == 0)
 {
  fat[currentblock + 1] = 0xc0 + blocksectors;
 }
 //ecriture eventuelle d'un bloc de fin incomplet
 if(incompleteblocksectors > 0)
 {
  currentblock = newblock;
  Importblock(incompleteblocksectors * sectorsize, currentblock);
  fat[currentblock + 1] = 0xc0 + incompleteblocksectors;
 }
 fclose(fp);
}

//Importation des fichiers d'un repertoire/////////////////////////////////////
void Import()
{
 DIR *dp;
 DIR *dummy;
 struct dirent *ep;
 int i;
 //controle
 sprintf(string, "Importation unite %i disquette ", unite);
 if(diskname != NULL) strcat(string, diskname + 1);
 Display(string);
 if(diskname == NULL) {Erreur(1); return;}
 //ouverture du fichier image de disquette
 fdisk = fopen(diskfilename, "rb+");
 if(fdisk == NULL) {Erreur(2); return;}
 //lecture FAT et DIR
 i = unite * unitsize + fatoffset;
 fseek(fdisk, 0, SEEK_END);
 if(i > ftell(fdisk)) {Erreur(10 + unite); return;}
 fseek(fdisk, i, SEEK_SET);
 fread(fat, fatlength, 1, fdisk);
 fread(cat, catlength, 1, fdisk);
 //choix du dossier
 if(ChoixDossier(0) < 0) {Erreur(9); return;}
 //boucle sur chaque fichier du dossier
 dp = opendir(folder);
 if(dp == NULL) {Erreur(3); return;}
 while((ep = readdir(dp)))
 {
  strcpy(filename, ep->d_name);
  if(filename[0] == '.') continue; //c'est un fichier supprime
  strcpy(string, folder);
  strcat(string, filename);
  dummy = opendir(string);
  if(dummy) {closedir(dummy); continue;} //c'est un repertoire
  Importfile();
 }
 closedir(dp);
 //ecriture fat et cat
 fseek(fdisk, unite * unitsize + fatoffset, SEEK_SET);
 fwrite(fat, fatlength, 1, fdisk);
 fwrite(cat, catlength, 1, fdisk);
 fclose(fdisk);
 Display("Fin de l'importation des fichiers du dossier");
}