/* Labbuppgift Extremdokumenterat sorteringsprogram av Per Wigren.
 * Använder dynamisk minnesallokering med hjälp av en länkad lista.
 * Endast minnet begränsar hur stor filen som kan sorteras kan vara.
 */



#include <stdio.h>

#define TRUE  1
#define FALSE 0

/* Skapa en struktur med namnet FAJL som innehåller _en_ rad i filen som ska sorteras */

struct FAJL {
   /* Pekare till nästa FAJL (nästa rad) */
   struct FAJL *next;
   /* Pekare till föregående FAJL (föregående rad) */
   struct FAJL *prev;
   /* Strängvariabel med raden */
   char line[255];
};

/* Huvudprogrammet. argc innehåller antal argument och argv innehåller argumenten */

int main(int *argc, char *argv[]) {
   int i,j;
   char arg[255],filename[255],line[255];
   int desc=FALSE,version=FALSE,verbose=TRUE;
   /* Skapa en FILE-variabel (pekare) med namnet file */
   FILE *file;
   /* Skapa variablerna fajl, first och tmp av typen FAJL som vi skapade ovan */
   struct FAJL *fajl, *first, *tmp;
   /* Allokera minne till variabeln fajl och lägg pekaren till den i variabeln.
    * sizeof(struct FAJL) returnerar storleken i bytes av en FAJL-struktur */
   fajl=(struct FAJL*)malloc(sizeof(struct FAJL));
   /* Gör variabeln first en pekare till den första fajl-en */
   first=fajl;
   /* Om argc är 1 (inga argument), skriv ut hjälptext och avsluta */
   if((int)argc==1) print_usage(0);
   /* Börja på 1 (första argumentet) och fortsätt till argc */
   for(i=1 ; i<(int)argc ; i++) {
      /* Om första tecknet i argumentet är ett "-" ....... */
      if (argv[i][0]=='-') {
	 /* Börja på 1 (första tecknet efter "-") och kör hela längden på argumentet */
	 for(j=1 ; j<strlen(argv[i]) ; j++) {
	    switch(argv[i][j]) {
	     /* Om det finns ett "d" däri, sätt desc (descending) till TRUE */
	     case 'd' : desc=TRUE;
	       break;
	     /* Om det finns ett "q", sätt verbose till FALSE */
	     case 'q' : verbose=FALSE;
	       break;
	     /* Om det finns ett "h", skriv ut hjälptext och avsluta */
	     case 'h' : print_usage(1);
	     /* Om det finns ett "v", skriv ut versionsnummer och avluta */
	     case 'v' : print_usage(0);
	    }
	 }
      }
      /* Om argumentet inte börjar på "-" är det filnamnet */
      else strcpy(filename,argv[i]);
   }
   /* Om desc är FALSE och verbose är TRUE .... */
   if(!desc && verbose) printf("sorting file: %s\n",filename);
   /* Om både desc och verbose är TRUE .... */
   if(desc && verbose) printf("sorting file: %s descending\n",filename);
   
   /* Öppna filen filename i "r" (read only) mode. Fortsätt om det gick. */
   if(file=fopen(filename,"r")) {
      /* Läs en rad, max storleken på linevariabeln (255) från filen och lägg i variabeln line
       * tills filen är slut */
      while(fgets(line,sizeof(line),file)) {
	 /* Kopiera line till linevariabeln i fajl-strukturen */
	 strcpy(fajl->line,line);
	 /* Allokera minne till en ny FAJL (rad) och lägg pekaren i "next" i den nuvarande */
	 fajl->next=(struct FAJL*)malloc(sizeof(struct FAJL));
	 /* Lägg pekaren till den nuvarande fajlen i nexts prev... */
	 fajl->next->prev=fajl;
	 /* Gör fajl till den nyligen allokerade fajl->next (nästa rad) */ 
	 fajl=fajl->next;
      }
      /* Stäng filen */
      fclose(file);

      /* Sätt fajl till den första raden (pekaren till den första fajl som allokerades */
      fajl=first;
      /* Oändlig loop */
      while(1) {
	 /* Sätt tmp till fajl */
	 tmp=fajl;
	 /* Oändlig loop igen ;) */
	 while(1) {
	    /* Om tmp->line är större än fajl->line (strcmp returnerar ett värde större än 0)... */
	    if(strcmp(tmp->line,fajl->line) > 0) {
	       /* Kopiera tmp->line till line (temporär variabel) */
	       strcpy(line,tmp->line);
	       /* Kopiera fajl->line till tmp->line */
	       strcpy(tmp->line,fajl->line);
	       /* Kopiera den temporära line till fajl->line */
	       strcpy(fajl->line,line);
	    }
	    /* Om fajl->next inte är NULL, gå till nästa i kedjan */
	    if(fajl->next != NULL) fajl=fajl->next;
	    /* Om fajl->next ÄR NULL innebär det att vi är på sista raden redan,
	     * isåfall avbryt loopen */
	    else break;
	    
	 }
	 /* Om tmp->next inte är NULL, sätt fajl till tmp->next */ 
	 if(tmp->next != NULL) fajl=tmp->next;
	 /* annars avbryt den här loopen också */
	 else break;
      }
      /* Om desc är FALSE, skriv ut sorterat från låg till hög */
      if(!desc) {
	 /* fajl sätts till första posten */
	 fajl=first;
	 while(1) {
	    /* Skriv ut fajl->line. Raderna innehåller redan ett "\n" */
	    printf("%s",fajl->line);
	    /* Hoppa till nästa om vi inte är på sista */
	    if(fajl->next != NULL) fajl=fajl->next;
	    /* är vi det, avbryt */
	    else break;
	 }
      }
      /* Om desc är TRUE, skriv ut sorterat från hög till låg */
      if(desc) {
	 /* Hoppa framåt i listan tills vi kommer till den sista raden */
	 while(fajl->next != NULL) fajl=fajl->next;
	 while(1) {
	    /* Skriv ut en rad */
	    printf("%s",fajl->line);
	    /* Om vi inte är på första, hoppa till föregående */
	    if(fajl->prev != NULL) fajl=fajl->prev;
	    /* är vi det, avbryt */
	    else break;
	 }
      }

      /* Hoppa fram till den sista */
      while(fajl->next != NULL) fajl=fajl->next;
      
      while(1) {
	 /* Är vi på den första, avbryt */
	 if(fajl->prev==NULL) break;
	 else {
	    /* annars hoppa till den föregående... */
	    fajl=fajl->prev;
	    /* ...och lämna tillbaka minnet från nästa (den vi var på nyss) */
	    free(fajl->next);
	 }
      }
   }
   /* Om inte filen hittades... */
   else {
      printf("File %s not found!\n",filename);
      /* Avsluta med 10 (warning) som returkod */
      exit(10);
   }
}

int print_usage(int h) {
         puts("fsort v2.0 by Per Wigren");
   /* om print_usage fick anropades med 1 som argument ('h' flaggan var satt) */
         if(h) {
	    puts("Usage: fsort [-vhqd] filename");
	    puts("  -v     print versionnumber and quit");
	    puts("  -h     print this help and quit");
	    puts("  -q     don\'t print header");
	    puts("  -d     sort descending");
	 }
   /* avsluta med 5 som returkod */
         exit(5);
}