// BEARBEITET VON: MARTIN HEINRICH
// MATNR: 0125222
// BSPNR: 2011 (2.Runde)
// MEINE KOMMENTARE SIND IN BLOCKSCHRIFT GESCHRIEBEN, DER ORIGINALKOMMENTARTEXT IST VOLLSTÄNDIG ERHALTEN.
// ERSETZUNGEN DES ORIGINAL QUELLTEXTES SIND AM ANFANG MIT /**/ GEKENNZEICHNET
// UND AN DEREN ENDE STEHT DER URSPRÜNGLICHE CODE.
// DIE AUFGABE LAUTET:
// ERSTELLEN EINER KLASSE testen MIT EINER METHODE public static String perform(),
// DIE EINEN STRING ENTSPRECHEND DER ORIGINAL SPEZIFIKATIONEN ZURÜCKGIBT (SIEHE BSP 1200).
//
// Autor: stefan jud
// matnr: 0125042
// email: e0125042@student.tuwien.ac.at
// BspNr: 1200
//
// Beschreibung:
// Konvertieren eines True-Color-Farbwertes aus dem RGB-Raum in
// einen kleineren Farbraum (Detailierte Beschreibung in farb1.txt)
// die Indizes (zB "--> 0.1") am Beginn von markanten Blöcken verweisen 
// auf eine detailiertere Beschreibung zu dem Block im Dokumentationsfile.
//
 

  
  
import eprog.*;

/**/ public class testen extends EprogIO {
/*public class farb1 extends EprogIO {*/

   // --> 0.1
   // liefert die "links" vom wert liegenden quadergrenze
   private static short grenzelinks(short [] grenzen, short wert) {
      short re = 0;
      
      for (int i =1; i < grenzen.length; i++)
         if (wert <= grenzen[i]) {
            re = grenzen[i-1];
            break;
         }
      return re;
   }

   // --> 0.2
   // liefert die "rechts" vom wert liegende quadergrenze
   private static short grenzerechts(short [] grenzen, short wert) {
      short re = 0;
      
      for (int i = 1; i < grenzen.length; i++)
         if (wert <= grenzen[i]) {
            re = grenzen[i];
            break;
         }
      return re;
   }

   // --> 0.3
   // liefert die zu "wert" nähere variable ("unten" oder "oben") zurück
   private static short near(short unten, short oben, short wert) {
      int uw, wo;
      short re = 0;
      
      uw = wert - unten;
      wo = oben - wert;
      if (uw < wo)  re = unten;
      if (uw > wo)  re = oben;
      if (uw == wo) re = unten;
      return re;
   }

   // --> 0.4
   // liefert die zu "wert" entferntere variable ("unten" oder "oben") zurück
   private static short far(short unten, short oben, short wert) {
      int uw, wo;
      short re = 0;
      
      uw = wert - unten;
      wo = oben - wert;
      if (uw < wo)  re = oben;
      if (uw > wo)  re = unten;
      if (uw == wo) re = oben;
      return re;
   }

   // --> 1.0
   // methode main
/**/ public static String perform() {
/*public static void main (String [] args) throws EprogException {*/
      final short [] GrenzenR = {0,  36,  73, 109, 146, 182, 219, 255};
      final short [] GrenzenG = {0,  36,  73, 109, 146, 182, 219, 255};
      final short [] GrenzenB = {0,  85, 170, 255};
      final short [][] AlleGrenzen = {GrenzenR, GrenzenG, GrenzenB};
      
      boolean ErrorNoShort = false,
              ErrorInhalt  = false,
              PunktIstEck  = false;
              
      short [] RGB    = new short[3];   // diese variable enthält die eingabe
            
      String ausgabe;  // in diesen string wird die ausgabe geschrieben


      // --> 1.1
      // dateneingabe mit fehlerbehandlung
      for (int i = 0; i < 3; i++)
         try {
            RGB[i] = readShort();
            if ( RGB[i] < 0 || RGB[i] > 255 ) ErrorInhalt = true;
         }
         catch (EprogException e) {
            ErrorNoShort = true;
         }

      // bei fehlerloser eingabe
      if ((!ErrorNoShort) & (!ErrorInhalt)) {      
            
         // --> 1.2
         //prüfen ob punkt eckpunkt eines quaders ist
         for (int i = 0; i < GrenzenB.length; i++)
            if (GrenzenB[i] == RGB[2]) {
               for (int j = 0; j < GrenzenG.length; j++)
                  if (GrenzenG[j] == RGB[1]) {
                     for (int k = 0; k < GrenzenR.length; k++)
                        if (GrenzenR[k] == RGB[0]) {
                           PunktIstEck = true;
                           break;
                        }
                     break;
                  }
               break;
            }

         // --> 1.3
         // wenn punkt kein eckpunkt ist quaderpunkte suchen
         if (!PunktIstEck) {
            short [] NextPt = new short[3];
            short [] FarPt  = new short[3];
            
            for (int i=0; i<AlleGrenzen.length; i++) {
               short untereG, obereG;
               
               untereG = grenzelinks (AlleGrenzen[i],RGB[i]);
               obereG  = grenzerechts(AlleGrenzen[i],RGB[i]);
               NextPt[i]= near(untereG,obereG,RGB[i]);
               FarPt[i] = far (untereG,obereG,RGB[i]);
            }
            ausgabe = NextPt[0]+" "+NextPt[1]+" "+NextPt[2]+" "+FarPt[0]+" "+FarPt[1]+" "+FarPt[2];
         }
         else  // wenn punkt eckpunkt ist 2x punkt ausgeben
            ausgabe = RGB[0]+" "+RGB[1]+" "+RGB[2]+" "+RGB[0]+" "+RGB[1]+" "+RGB[2];
      }      
      else  // wenn eingabefehler aufgetreten fehlermeldung erzeugen
         if (ErrorNoShort) ausgabe = "?";
         else ausgabe = "FALSCHE EINGABE";               
      
      // ausgabestring auf den bildschirm schreiben
/**/ return (ausgabe);      
/*println(ausgabe);*/
      
   }  // ende main // = ENDE perform
}  // ende class