SPA2, k1, v2, Biblioteka

/*
* Insertion sort vrsi manji broj poredjenja u odnosu na selection;
* Ukoliko su swapovi/razmene dva elementa "skupe" potrebno koristiti selection;
*/

import org.svetovid.io.SvetovidReader;
import org.svetovid.io.SvetovidWriter;

import java.util.Arrays;

import java.util.Comparator;


public class Biblioteka{

  public static void main(String[] args){

    Svetovid.out.println("Start programa.");

    //ucitaj ime ulaznog/izlaznog fajla
    String fileIn = Svetovid.in.readLine("Unesite ime ulaznog fajla: ");
    String fileOut = Svetovid.in.readLine("Unesite ime izlaznog fajla: ");

    //ucitavanje knjige iz fajla
    Knjiga[] biblioteka = ucitajKnjige(fileIn);

    if (biblioteka == null) {
      Svetovid.err.println("Nepostojeci fajl.");
      return;
    } else {
      Svetovid.out.println("Uspesno citanje podataka iz fajla.\n");
    }

    //stampanje svih knjiga pre sortiranja
    stampajKnjige(biblioteka);
    Svetovid.out.println("----------------");

    // Pitamo korisnika za vrstu sorta
    Svetovid.out.println("Opcija 1: ugradjeni sort");
    Svetovid.out.println("Opcija 2: insertion sort");
    Svetovid.out.println("Opcija 3: selection sort");
    Svetovid.out.print("Unesite opciju 1-3:");
    int opcija1 = Svetovid.in.readInt();
    if(!(opcija1 >= 1 && opcija1 <= 3)){
      Svetovid.err.println("Odabrana je nepostojeca opcija");
      return;
    }

    // Pitamo korisnika za kriterijum sortiranja
    Svetovid.out.println("Opcija 1: sort sa rastucim id knjige");
    Svetovid.out.println("Opcija 2: sort sa opadajucim id knjige");
    Svetovid.out.println("Opcija 3: sort po naslovu");
    Svetovid.out.println("Opcija 4: sort po autoru, a zatim po naslovu");
    int opcija2 = Svetovid.in.readInt();

    //zavrsiti kostur
    /*
    switch(opcija2){
      case 1:
        if(opcija1 == 1){

        } else if(opcija1 == 2){

        } else {

        }
        break;
      case 2:
      case 3:
      case 4:
    }
    */

    //stampaj knjige nakon sortiranja
    stampajKnjige(biblioteka);

    //snimi u fajl
    if(snimiKnjige(biblioteka, fileOut)){
      Svetovid.out.println("Uspesno snimljeni podaci u zadati fajl");
    } else {
      Svetovid.err.println("Greska pri snimanju podataka u zadati fajl");
    }
  }

  private static Knjiga[] ucitajKnjige(String f){

    if(!Svetovid.testIn(f)){
      return null;
    }

    SvetovidReader reader = Svetovid.in(f);

    int num = reader.readInt();
    Knjiga[] knjige = new Knjiga[num];

    for(int i = 0; i < num; i++){

      int id = reader.readInt();
      String naslov = reader.readLine();
      String autor = reader.readLine();

      knjige[i] = new Knjiga(id, naslov, autor);

    }

    reader.close();
    return knjige;

  }

  public static void stampajKnjige(Knjiga[] niz){
    for(Knjiga k: niz){
      Svetovid.out.println(k.toString());
    }
  }

  private static boolean snimiKnjige(Knjiga[] nizKnjiga, String f){

    if(!Svetovid.testOut(f)){
      return false;
    }

    SvetovidWriter writer = Svetovid.out(f);

    writer.println(nizKnjiga.length);

    for(Knjiga k: nizKnjiga){
      writer.println(k.id);
      writer.println(k.naslov);
      writer.println(k.autor); //k.getAutor(); u slucaju private
    }

    writer.close();
    return true;
  }

  //ugradjeno sortiranje
  public static void sortiraj(Knjiga[] niz){
    Arrays.sort(niz);
  }

  public static void sortirajKnjige(Knjiga[] niz, Comparator<Knjiga> c){
   Arrays.sort(niz, c);
  }

  //insertion sort
  public static void insertionSort(Comparable[] niz, Comparator comparator){
    for(int i = 0; i < niz.length; i++){

      Comparable temp = niz[i];

      int j = i - 1;

      while(j >= 0 && comparator.compare(niz[j], temp) > 0){
        niz[j + 1] = niz[j];
        j--;
      }

      niz[j + 1] = temp;

    }
  }

  //selection sort
  public static void selectionSort(Comparable[] niz, Comparator comparator) {

    for (int i = niz.length - 1; i >= 1; i--) {

      int maxIndex = 0;
      for (int j = 1; j <= i; j++) {
        if(comparator.compare(niz[maxIndex], niz[j]) <= 0){
          maxIndex = j;
        }
    }

      if(maxIndex != i){
        Comparable temp = niz[i];
        niz[i] = niz[maxIndex];
        niz[maxIndex] = temp;
      }

    }
  }

}

class Knjiga implements Comparable<Knjiga>{

  public final int id;
  public final String naslov;
  public final String autor;

  public Knjiga(int id, String naslov, String autor){
    this.id = id;
    this.naslov = naslov;
    this.autor = autor;
  }

  @Override
  public String toString(){
    return id + " " + naslov + " " + autor;
  }

  @Override
  public int compareTo(Knjiga that){
    return this.id - that.id;
  }
}

// Komparator koji koristi prirodni poredak, tj. samo poziva compareTo()
class KomparatorPoPrirodnomUredjenju implements Comparator<Knjiga>{

  @Override
  public int compare(Knjiga k1, Knjiga k2){
    return k1.compareTo(k2);
  }

}

class InverzniKomparator implements Comparator<Knjiga>{

  private Comparator<Knjiga> originalni;

  public InverzniKomparator(Comparator<Knjiga> originalni){
    this.originalni = originalni;
  }

  @Override
  public int compare(Knjiga k1, Knjiga k2){
    return -originalni.compare(k1, k2);
  }

}

// Komparator koji prvo poredi pomocu primarnog komparatora a potom po sekundarnom
class KompozitniKomparator implements Comparator<Knjiga>{

  private Comparator<Knjiga> primarni;
  private Comparator<Knjiga> sekundarni;

  public KompozitniKomparator(Comparator<Knjiga> primarni, Comparator<Knjiga> sekundarni){
    this.primarni = primarni;
    this.sekundarni = sekundarni;
  }

  @Override
  public int compare(Knjiga k1, Knjiga k2){
    int res = primarni.compare(k1, k2);
    if(res == 0){
      res = sekundarni.compare(k1, k2);
    }

    return res;
  }
}

class KomparatorPoAutoru implements Comparator<Knjiga> {

    @Override
    public int compare(Knjiga k1, Knjiga k2) {
      return k1.autor.compareTo(k2.autor);
    }

}

class KomparatorPoNaslovu implements Comparator<Knjiga> {

    @Override
    public int compare(Knjiga k1, Knjiga k2) {
      return k1.naslov.compareTo(k2.naslov);
    }
}

// Komparator koji poredi po autoru, a za iste autore, po naslovu
class KomparatorPoAutoruIPotomNaslovu extends KompozitniKomparator {

  public KomparatorPoAutoruIPotomNaslovu(){
    super(new KomparatorPoAutoru(), new KomparatorPoNaslovu());
  }

}