import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

/**
 * In dieser Klasse wird ein astronomisches Pixelbild korrigiert
 * @author Dino Lindlau & Emin-Can Kösem
 * @version 0.1
 * @since 13.01.2019
 * @return Korrigiertes Pixelbild
 */
public final class Teil2_Aufgabe1_Pixel {

    public static void main(String[] args) {


        String[] eingabestrings = args;
        int dateimenge = eingabestrings.length;
        boolean dateiexists[] = new boolean[dateimenge];
        Arrays.fill(dateiexists, true);
        int richtigedateien = 0;
        for(int i = 0; i < dateimenge; i++) {
            File dateieingabe = new File(eingabestrings[i]+".bmp");
            boolean exists = dateieingabe.exists();
            if (exists != true) {
                dateiexists[i] = false;
            }
            else if(exists == true) {
                richtigedateien++;
            }
        }

        // C:\Users\dino114\eclipse-workspace\Teil2_Aufgabe1_Pixel
        //File userdir = new File(System.getProperty("user.dir").toString());
        //File-Array mit allen bmp files, die existieren aus args
        File[] files = new File[richtigedateien];
        for(int i = 0, n = 0; i < dateimenge; i++) {
            File dateieingabe = new File(eingabestrings[i]+".bmp");
            boolean exists = dateieingabe.exists();
            if (exists != true) {
                System.out.println("Die Datei " + dateieingabe.toString() + " existiert nicht");
                dateiexists[i] = false;
            }
            else if(exists == true) {
                files[n] = new File(eingabestrings[i]+".bmp");
                n++;
            }
        }


        //Files für weisse und schwarze Bilder
        try {
            File dark = new File("user.dir\\dark.bmp");
            }
        catch (FileNotFoundException e) {
            System.out.println("FEhler");
        }
        File white = new File("user.dir\\white.bmp");
        File[] korrigiert = new File[files.length];
        for (int i = 0; i < korrigiert.length; i++) {
            korrigiert[i] = new File(files[i].toString().replaceFirst("[.][^.]+$", "") + "korr.bmp");
        }


        for (int x = 0; x < files.length; x++) {
            //ByteArray mit den Daten des Bildes
            byte[] imageinput = readData(files[x].getName());
            //ByteArray für die korrigiertenBytes
            byte[] imagecorr = new byte[(int)files[x].length()];
            //ByteArray für die ersten 1078 Bytes
            byte[] firstbytes = new byte[1078];
            for (int i = 0; i <= 1077; i++) {
                firstbytes[i] = imageinput[i];
            }
            //ByteArray für die letzen zwei Bytes
            byte[] lastbytes = new byte[2];
            for (int i = 16078, c = 0; i <= 16079; i++) {
                lastbytes[c] = imageinput[i];
                c++;
            }
            //ByteArray fuer weisses und schwarzes Bild
            byte[] whiteimagesigned = readData(white.getName());
            byte[] darkimagesigned = readData(dark.getName());

            //int arrays für unsigned byte werde da java keine unsigned datentypen hat via bitmaske

            int[] whiteimageunsigned = new int[whiteimagesigned.length];
            int[] darkimageunsigned = new int[darkimagesigned.length];
            int[] imageinputunsigned = new int[imageinput.length];
            //umwandeln der werte
            for (int i = 0; i < whiteimageunsigned.length; i++) {

                if(whiteimagesigned[i] >= 0  && whiteimagesigned[i] <= 127) {
                    whiteimageunsigned[i] = whiteimagesigned[i];
                }
                else {
                    whiteimageunsigned[i] = whiteimagesigned[i] + 256;
                }

                if(darkimagesigned[i] >= 0  && darkimagesigned[i] <= 127) {
                    darkimageunsigned[i] = darkimagesigned[i];
                }
                else {
                    darkimageunsigned[i] = darkimagesigned[i] +256;
                }

            }
            //andere for schleife wegen späterer start
            for (int i = 1078, n = 0, h = 0; h < 150;) {
                for (int b = 0; b < 100; b++) {
                    imageinputunsigned[n] = imageinput[i] & 0xff;
                    i++;
                    n++;
                }
                h++;
            }

            //Pixelmatrix für alle imageinput, weisses bild und schwarzes Bild
            double[][] pixelmatriximageinput = new double[150][100];
            double[][] pixelmatrixdark = new double[150][100];
            double[][] pixelmatrixwhite = new double[150][100];
            //Speichern der Werte in pixelmatrixdark
            for (int i = 1078, h = 0; h < 150;) {
                for (int b = 0; b < 100; b++) {
                    pixelmatrixdark[h][b] = darkimageunsigned[i];
                    i++;
                }
                h++;
            }


            //Speichern der Werte in Pixelmatrixwhite
            for (int i = 1078, h = 0; h < 150;) {
                for (int b = 0; b < 100; b++) {
                    pixelmatrixwhite[h][b] = whiteimageunsigned[i];
                    i++;
                }
                h++;
            }

            //Speichern der Werte für Pixelmatriximageinput
            for (int i = 1078, h = 0; h < 150;) {
                for (int b = 0; b < 100; b++) {
                    pixelmatriximageinput[h][b] = imageinputunsigned[i];
                    i++;
                }
                h++;
            }



            //Summe der Werte aller Pixel des Weissbildes
            int summe = 0;
            for (int h = 0; h < 150; h++) {
                for (int b = 0; b < 100; b++) {
                    summe += pixelmatrixwhite[h][b];
                }
            }
            //Graustufenmittelwert fuer die Rechnung
            double graustufenmittelwert = summe/15000;
            //System.out.println(graustufenmittelwert);


            //Korrektur der Pixel
            //das Dunkelbild vom astronomischen Rohbild pixelweise abziehen,
            //das so korrigierte Bild pixelweise durch das Weißbild dividieren und
            //das so korrigierte Bild pixelweise mit dem Graustufenmittelwert des Weißbildes multiplizieren
              for (int h = 0; h < 150; h++) {
                   for (int b = 0; b < 100; b++) {
                    pixelmatriximageinput[h][b] -= pixelmatrixdark[h][b];
                    pixelmatriximageinput[h][b] /= pixelmatrixwhite[h][b];
                     pixelmatriximageinput[h][b] *= graustufenmittelwert;
                     pixelmatriximageinput[h][b] = Math.round(pixelmatriximageinput[h][b]);
                   }
              }


            //Speichern der first bytes in korrektur
            for (int i = 0; i < 1078; i++) {
            imagecorr[i] = firstbytes[i];
            }
            //Speichern der pixel in korrektur
            for (int i = 1078, h = 0; h < 150;) {
                for (int b = 0; b < 100; b++) {
                    if(pixelmatriximageinput[h][b] > 127)
                    imagecorr[i]=(byte) (pixelmatriximageinput[h][b] - 256);
                    else {
                        imagecorr[i] = (byte) pixelmatriximageinput[h][b];
                    }

                    i++;
                }
                h++;
            }
            //Speichern der letzen beiden bytes in korrektur
            for (int i = 16077; i < 10679; i++) {
                imagecorr[i] = lastbytes[i];
                }


         writeData(imagecorr, korrigiert[x].getName());
         System.out.println("Die Datei " + files[x].getName() + " wurde korrigiert und abgespeichert in " + korrigiert[x]);

        }




 } //End of main
/**
 *
 * @param filename: bekommt den Namen der zu lesenden Datei
 * @return gibt ein byte[] mit allen bytes zurück
 */
 static byte[] readData(String filename) {

  File file = new File(filename);
  FileInputStream fis = null;
  byte[] data = null;
  try {
   fis = new FileInputStream(file);
   data = new byte[(int) file.length()];
   fis.read(data);
  }
  catch (FileNotFoundException e) {
   e.printStackTrace();
  }
  catch (IOException e) {
   e.printStackTrace();
  }
  finally {
   try {
    if (fis != null) fis.close();
   } catch (IOException e) {}
  }
  return data;
 }
/**
 *
 * @param data: das Array der zu schreibenden bytes
 * @param fileName: braucht den Namen der zu schreibenden Datei
 * @return gibt als boolean zurück, ob es geklappt hat
 */
 static boolean writeData(byte[] data, String fileName) {
     File file = new File(fileName);

     FileOutputStream fos = null;
     try {
         fos = new FileOutputStream(file);
         fos.write(data);
         fos.flush();
         return true;
     } catch (FileNotFoundException e) {
         System.err.println(file + " doesn't exist!");
     } catch (IOException e) {
         System.err.println("Problems writing data to " + file);
     } finally {
         try {
             if(fos != null) fos.close();
         }catch(IOException e){}
     }
     return false;
 }


} //End of Class