/*
 *
 *  MERGE and CUT
 *
 *  Idée originale  : Thibaut Maquet
 *
 *  Avril 1993 .
 *
 */


#include <stdio.h>
#include <string.h>

#include <intuition/intuition.h>
#include <exec/memory.h>

#include <proto/exec.h>
#include <proto/dos.h>
#include <proto/reqtools.h>

#include <libraries/reqtools.h>

struct Library *DosBase;
struct FileLock *lock_fichier = NULL;
struct FileInfoBlock *fib_ptr = NULL;
struct FileHandle *fichhandle = NULL,*fichdiv_handle = NULL;

int taille,octets_lus;
ULONG nbr_div;
char fichier_div[80],tmp[80];    
char *adr_ptr;

struct ReqToolsBase *ReqToolsBase = NULL;

char filename0[80],filename1[80],
     pathname0[80],pathname1[80];


char *rt_getpathname(char *intitule)
{

  struct rtFileRequester *filereq;
  char nom_du_fichier[80],chemin_acces[80];

  if (filereq = rtAllocRequestA (RT_FILEREQ, NULL)) 
  {
    if (rtFileRequest (filereq,nom_du_fichier,intitule,TAG_END))
    {
      strcpy(chemin_acces,filereq->Dir);      
      if (chemin_acces[strlen(chemin_acces) - 1] != ':')
        strcat(chemin_acces,"/");
      strcat(chemin_acces,nom_du_fichier);
      return chemin_acces;
    }
    else
      return 0;  
    rtFreeRequest (filereq);
  }
  else
    return 0;
}


void quitte(void)
{  
  DeleteFile(tmp);
  if (DosBase)
    CloseLibrary(DosBase);  
  if (ReqToolsBase)
    CloseLibrary((struct Library *)ReqToolsBase);
  Exit(0);
}


void merge(void)
{ 

  adr_ptr = AllocMem(100*1024,MEMF_FAST | MEMF_CLEAR );
  if (!adr_ptr)   
    AllocMem(100*1024,MEMF_CHIP | MEMF_CLEAR );
  if (!adr_ptr)
  {
    rtEZRequest ("Mémoire insuffisante !","D'accord", NULL, NULL);
    quitte();
  }
 
  strcpy(pathname0,rt_getpathname("fichier n°1"));
  if (!pathname0[0])
  {
    FreeMem(adr_ptr,100*1024); 
    quitte(); 
  }

  strcpy(tmp,pathname0);
  strcat(tmp,".mrg");

  fichhandle = (struct FileHandle *)Open(tmp,MODE_NEWFILE);
  if (fichhandle == NULL)
  {
    rtEZRequest ("Fichier introuvable !","D'accord", NULL, NULL);
    FreeMem(adr_ptr,100*1024); 
    quitte();
  } 

  fichdiv_handle = (struct FileHandle *)Open(pathname0,MODE_OLDFILE);
  if (fichdiv_handle == NULL)
  {
    Close((BPTR)fichhandle);
    rtEZRequest ("Fichier introuvable !","D'accord", NULL, NULL);
    FreeMem(adr_ptr,100*1024); 
    quitte();
  } 

  octets_lus = Read((BPTR)fichdiv_handle,adr_ptr,100*1024);

  while (octets_lus)
  {
  
    Write((BPTR)fichhandle,adr_ptr,octets_lus);
    octets_lus = Read((BPTR)fichdiv_handle,adr_ptr,100*1024);
  }

  Close((BPTR)fichdiv_handle);

  strcpy(pathname1,rt_getpathname("fichier n°2"));
  if (!pathname1[0])
  {
    Close((BPTR)fichhandle);
    FreeMem(adr_ptr,100*1024); 
    quitte();
  }

  fichdiv_handle = (struct FileHandle *)Open(pathname1,MODE_OLDFILE);
  if (!fichdiv_handle)
  {
    Close((BPTR)fichhandle);
    rtEZRequest ("Fichier introuvable !","D'accord", NULL, NULL);
    FreeMem(adr_ptr,100*1024); 
    quitte();
  } 
  
  octets_lus = Read((BPTR)fichdiv_handle,adr_ptr,100*1024);

  while (octets_lus)
  {
  
    Write((BPTR)fichhandle,adr_ptr,octets_lus);
    octets_lus = Read((BPTR)fichdiv_handle,adr_ptr,100*1024);
  }  
  
  Close((BPTR)fichhandle); 
  Close((BPTR)fichdiv_handle);  
  
  fichhandle = (struct FileHandle *)Open(tmp,MODE_OLDFILE);
  if (!fichhandle)
  {
    rtEZRequest ("Fichier introuvable !","D'accord", NULL, NULL);
    FreeMem(adr_ptr,100*1024); 
    quitte();   
  }
 
  strcpy(pathname1,rt_getpathname("Sauvegarde du fichier"));

  fichdiv_handle = (struct FileHandle *)Open(pathname1,MODE_NEWFILE);
  if (fichdiv_handle == NULL)
  {
    Close((BPTR)fichhandle);
    rtEZRequest ("Fichier introuvable !","D'accord", NULL, NULL);
    FreeMem(adr_ptr,100*1024); 
    quitte();
  } 
 
  octets_lus = Read((BPTR)fichhandle,adr_ptr,100*1024);

  while (octets_lus)
  {
    Write((BPTR)fichdiv_handle,adr_ptr,octets_lus);
    octets_lus = Read((BPTR)fichhandle,adr_ptr,100*1024);
  }  

  Close((BPTR)fichhandle);
  Close((BPTR)fichdiv_handle);  
  FreeMem(adr_ptr,100*1024); 
 
}


void cut(void)
{ 

  short i = 0;

  strcpy(pathname0,rt_getpathname("Choisissez un fichier"));
  if (!pathname0[0])
    quitte(); 

  while (!nbr_div)
    while (!rtGetLong (&nbr_div, "Nombre :", NULL,RTGL_ShowDefault, FALSE, TAG_END))
      rtEZRequest ("Vous devez entrer un nombre !","D'accord", NULL, NULL);

  fib_ptr = (struct FileInfoBlock *)
            AllocMem( sizeof( struct FileInfoBlock ),
            MEMF_FAST | MEMF_CLEAR );
  if (fib_ptr == NULL)
          (struct FileInfoBlock *)
          AllocMem( sizeof( struct FileInfoBlock ),
          MEMF_CHIP | MEMF_CLEAR );
  if (fib_ptr == NULL)
  {
    rtEZRequest ("Mémoire insuffisante !","D'accord", NULL, NULL);
    quitte();
  }  

  lock_fichier = (struct FileLock *)Lock(pathname0,SHARED_LOCK);
  if (lock_fichier == NULL)
  {  
    rtEZRequest ("Fichier introuvable !","Bizarre", NULL, NULL);
    FreeMem(fib_ptr,sizeof(struct FileInfoBlock)); 
    quitte();    
  }

  Examine((BPTR)lock_fichier,fib_ptr);
  taille = fib_ptr->fib_Size / nbr_div;
  if (taille * nbr_div != fib_ptr->fib_Size)
    taille++;
  UnLock((BPTR)lock_fichier);
  FreeMem(fib_ptr,sizeof( struct FileInfoBlock));
  fib_ptr = AllocMem(taille,MEMF_FAST | MEMF_CLEAR );
  if (fib_ptr == NULL)   
    AllocMem(taille,MEMF_CHIP | MEMF_CLEAR );
  if (fib_ptr == NULL)
  {
    rtEZRequest ("Mémoire insuffisante !","D'accord", NULL, NULL);
    quitte();
  } 

  fichhandle = (struct FileHandle *)Open(pathname0,MODE_OLDFILE);
  if (!fichhandle)
  { 
    rtEZRequest ("Fichier introuvable !","Bizarre", NULL, NULL);
    FreeMem(fib_ptr,taille); 
    quitte();
  }

  octets_lus = Read((BPTR)fichhandle,fib_ptr,taille);

  for (i=0;i<nbr_div;i++)
  {
    stci_d(tmp,i); 
    strcpy(fichier_div,pathname0);
    strcat(fichier_div,tmp);
    fichdiv_handle = (struct FileHandle *)Open(fichier_div,MODE_NEWFILE);
    if (!fichdiv_handle)
      break;
    Write((BPTR)fichdiv_handle,fib_ptr,octets_lus);
    Close((BPTR)fichdiv_handle);
    octets_lus = Read((BPTR)fichhandle,fib_ptr,taille);  
  }

  Close((BPTR)fichhandle);
  FreeMem(fib_ptr,taille); 

}

main(int argc,char **argv)
{

  DosBase = OpenLibrary("dos.library",0L);
  if (!DosBase)
    Exit(5);

  if (!(ReqToolsBase = (struct ReqToolsBase *)
        OpenLibrary (REQTOOLSNAME, REQTOOLSVERSION)))
  {
    printf("reqtools.library V37 introuvable!\n");
    Exit (5);
  }

  switch (rtEZRequest ("Choisissez :\n"	"'Couper' pour couper un fichier.\n"
               "'Coller' pour coller deux fichiers.",
               "Couper|Coller",NULL,NULL))
  {
    case TRUE:
      cut();
      break;
    case FALSE:
      merge();
      break;  
  }

  quitte();
}