votex-2.1-JavaFX

package voteextractor.gui;


import java.awt.EventQueue;
import java.awt.Toolkit;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.StringSelection;

import javafx.application.Application;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.CheckBox;
import javafx.scene.control.Label;
import javafx.scene.control.MenuBar;
import javafx.scene.control.TextArea;
import javafx.scene.control.TextField;
import javafx.scene.image.Image;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;
import javafx.scene.text.Font;
import javafx.scene.text.Text;
import javafx.stage.Stage;

import javax.swing.JFrame;

import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.net.MalformedURLException;

public class votexJavaFX extends Application{

    //private JFrame frmElsahefsIrcstreamvoteextratorV;


    private ArrayList<String> irclines = new ArrayList<String>();
    private ArrayList<String> irclines_unprocessed = new ArrayList<String>();
    private HashMap<String, Integer> processed_nicknames = new HashMap<String, Integer>();
    private HashMap<String, String> processed_irclines = new HashMap<String, String>();
    private ArrayList<String> blacklisted_nicknames = new ArrayList<String>();
    private ArrayList<String> doublevotes = new ArrayList<String>();
    private ArrayList<String> pattern_only = new ArrayList<String>();

    private int votecount = 0;
    private int votesum = 0;
    private String votestring = "";

    // Konfigurationsoptionen mit Standardeinstellung//////////
    //
    // zur Laufzeit:  //////////////////////////////////////////
    //
    // Moderatoren highlighten
    private boolean blacky = false;
    private boolean muetsch = false;
    private boolean gebbi = false;

    // bei Programmstart über config.ini:  //////////////////////
    //
    // Nicknames der Moderatoren
    private String muetsch_nick = "Muetsch";
    private String blacky_nick = "Blacky107";
    private String gebbi_nick = "Gebbi";

    // Zeichenketten im IRC-Client vor und nach den Nicknames
    private String nickstart = "<";
    private String nickstop = ">";

    final TextArea textArea = new TextArea();

    final TextArea textArea_1 = new TextArea();

    Label lb_toplabel = new Label("den IRC-Abschnitt mit den Bewertungen hier reinkopieren:");

    final TextField lb_vote = new TextField("X bei Y Bewertern");

    final Label lb_votecount = new Label("extrahierte Bewertungen: 0");

    final Label lb_sum = new Label("Summe der extrahierten Bewertungen: 0");

    Label lb_bottomheader = new Label("Zeilen, aus denen keine Bewertung automatisch extrahiert werden konnte:");


    final Label lb_vote_exact = new Label("Bewertung: XX");

    final TextField voteaddfield = new TextField();
    Button extractbutton = new Button("Extrahieren");
    Button resetbutton = new Button("Zurücksetzen");

    CheckBox highlight_muetsch = new CheckBox("Muetsch");

    CheckBox highlight_blacky = new CheckBox("Blacky107");

    CheckBox highlight_gebbi = new CheckBox("Gebbi");

    Button clipboard = new Button("in die Zwischenablage");

    Label lbl_manualvotes = new Label("Bewertungen manuell hinzufügen:");

    Button manualvote_update = new Button("Aktualisieren");


    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(Stage stage) {

        //Stage stage  = stage;
        BorderPane pane = new BorderPane();
        stage.setTitle("el-sahef's IRC-Streamvote-Extractor V2.1 with JavaFX(added from Kullorki)");

        double scale = Math.rint(new Text("").getLayoutBounds().getHeight());
        scale = scale / 16;

        textArea.setFont(new Font("Arial",11*scale));
        textArea_1.setFont(new Font("Arial",11*scale));

        VBox v = new VBox(5*scale);

        HBox h1 = new HBox(5*scale);
        h1.getChildren().add(lb_toplabel);

        HBox h2 = new HBox(5*scale);
        h2.getChildren().add(textArea);

        HBox h3 = new HBox(5*scale);
        h3.getChildren().add(extractbutton);
        h3.getChildren().add(resetbutton);
        h3.getChildren().add(lb_vote);
        h3.getChildren().add(lb_vote_exact);

        HBox h4 = new HBox(5*scale);
        h4.getChildren().add(highlight_muetsch);
        h4.getChildren().add(highlight_blacky);
        h4.getChildren().add(highlight_gebbi);
        h4.getChildren().add(clipboard);

        HBox h41 = new HBox(5*scale);
        h41.getChildren().add(lb_votecount);
        h41.getChildren().add(lb_sum);

        HBox h5 = new HBox(5*scale);
        h5.getChildren().add(lbl_manualvotes);
        h5.getChildren().add(voteaddfield);
        h5.getChildren().add(manualvote_update);

        HBox h6 = new HBox(5*scale);
        h6.getChildren().add(lb_bottomheader);

        HBox h7 = new HBox(5*scale);
        h7.getChildren().add(textArea_1);

        v.getChildren().add(h1);
        v.getChildren().add(h2);
        v.getChildren().add(h3);
        v.getChildren().add(h4);
        v.getChildren().add(h41);
        v.getChildren().add(h5);
        v.getChildren().add(h6);
        v.getChildren().add(h7);

        pane.setCenter(v);
        pane.setBottom(new Label(" "));
        pane.setLeft(new Label(" "));
        pane.setRight(new Label(" "));
        pane.setTop(new Label(" "));

        stage.setScene(new Scene(pane));

        stage.show();
        initialize();
    }


    /**
     * Create the application.
     */
    public votexJavaFX() {
        initialize();
    }

    /**
     * Initialize the contents of the frame.
     */
    private void initialize() {

       try {
            BufferedReader input = new BufferedReader(new FileReader("config.ini"));
            String zeile = null;
            while ((zeile = input.readLine()) != null) {

                // die config-Datei parsen
                //
                // Kommentare ignorieren
                if(zeile.charAt(0) == '#'){
                    continue;
                }

                // Konfiguration lesen
                String option = zeile.substring(0, zeile.indexOf("="));
                String value = zeile.substring(zeile.indexOf("\"") + 1, zeile.lastIndexOf("\""));

                switch (option){
                    case "blacky_nick": blacky_nick = value;
                    break;

                    case "muetsch_nick": muetsch_nick = value;
                    break;

                    case "gebbi_nick": gebbi_nick = value;
                    break;

                    case "nickstart": nickstart = value;
                    break;

                    case "nickstop": nickstop = value;
                    break;
                }

            }
            input.close();
        } catch (IOException e) {
            e.printStackTrace();
        }




        extractbutton.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                // alles nochmal zurücksetzen

                textArea_1.setText("");
                voteaddfield.setText(" ");

                votecount = 0;
                votesum = 0;

                irclines_unprocessed.clear();
                irclines.clear();
                processed_irclines.clear();
                processed_nicknames.clear();
                doublevotes.clear();
                blacklisted_nicknames.clear();
                pattern_only.clear();


                // speichere die einzelnen Zeilen ab

                StringBuilder rawdata = new StringBuilder(textArea.getText());
                fillStringArrayList(rawdata);

                // extrahiere die Votes und berechne Bewertung

                extract();

                double result = ((double) votesum) / ((double) votecount);

                // zeige Bewertung

                lb_vote_exact.setText("genaue Bewertung: " + result);

                // ggf. Mods highlighten

                StringBuilder highlight = new StringBuilder();

                if(muetsch){
                    highlight.append(" " + muetsch_nick);
                }
                if(blacky){
                    highlight.append(" " + blacky_nick);
                }
                if(gebbi){
                    highlight.append(" " + gebbi_nick);
                }

                result = Math.round(result * 100.0)/100.0;

                NumberFormat formatter = new DecimalFormat("#0.00");

                votestring = formatter.format(result) + " bei " + votecount + " Bewertungen  " + highlight.toString();

                lb_vote.setText(votestring);

                lb_votecount.setText("extrahierte Bewertungen: " + votecount);
                lb_sum.setText("Summe der extrahierten Bewertungen: " + votesum);

                // zeige nicht behandelte IRC-Zeilen

                textArea_1.setText(getStringFromArrayList());


            }
        });



        resetbutton.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                // setze alles zurück
                textArea.setText("");
                textArea_1.setText("");
                voteaddfield.setText(" ");

                lb_vote.setText("X bei Y Bewertern");
                lb_votecount.setText("extrahierte Bewertungen: 0");
                lb_sum.setText("Summe der extrahierten Bewertungen: 0");
                lb_vote_exact.setText("genaue Bewertung: XX");

                votecount = 0;
                votesum = 0;

                votestring = "";

                irclines_unprocessed.clear();
                irclines.clear();
                processed_irclines.clear();
                processed_nicknames.clear();
                doublevotes.clear();
                blacklisted_nicknames.clear();
                pattern_only.clear();

            }
        });

        highlight_muetsch.selectedProperty().addListener(new ChangeListener<Boolean>() {
                public void changed(ObservableValue ov,
                    Boolean old_val, Boolean new_val) {
                    muetsch = !muetsch;
                }
            });

        highlight_blacky.selectedProperty().addListener(new ChangeListener<Boolean>() {
                public void changed(ObservableValue ov,
                    Boolean old_val, Boolean new_val) {
                    blacky = !blacky;
                }
            });

        highlight_gebbi.selectedProperty().addListener(new ChangeListener<Boolean>() {
                public void changed(ObservableValue ov,
                    Boolean old_val, Boolean new_val) {
                    gebbi = !gebbi;
                }
            });

        clipboard.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                StringSelection stringselect = new StringSelection(votestring);
                Clipboard clpboard = Toolkit.getDefaultToolkit().getSystemClipboard();
                clpboard.setContents(stringselect, null);

            }
        });


        manualvote_update.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {

                int added_votesum = 0;
                int added_votecount = 0;

                StringBuilder rawaddedvotes = new StringBuilder(voteaddfield.getText());
                rawaddedvotes.append(" ");

                // Votes aus rawaddedvotes extrahieren, solange Leerzeichen drin sind
                int newvoteborder;

                if(rawaddedvotes.indexOf(" ") == -1){
                    newvoteborder = rawaddedvotes.length();
                }
                else{
                    newvoteborder = rawaddedvotes.indexOf(" ");
                }

                do{
                    try{
                        int current = Integer.parseInt(rawaddedvotes.substring(0, newvoteborder));

                        // nur wenn Bewertung zwischen 0 und 10, diese werten
                        if ((current >= 0) && current <= 10){
                            added_votesum = added_votesum + Integer.parseInt(rawaddedvotes.substring(0, newvoteborder));
                            added_votecount = added_votecount + 1;
                        }
                    } catch (NumberFormatException e){

                    }

                    // gerade bearebeiteten Bereich löschen
                    rawaddedvotes.delete(0, newvoteborder + 1);
                    newvoteborder = rawaddedvotes.indexOf(" ");
                }
                while(rawaddedvotes.indexOf(" ") != -1);

                // neue Gesamtbewertung berechnen

                double result = ((double) votesum + (double) added_votesum) / ((double) votecount + (double) added_votecount);

                // zeige Bewertung

                lb_vote_exact.setText("genaue Bewertung: " + result);

                // ggf. Mods highlighten

                StringBuilder highlight = new StringBuilder();

                if(muetsch){
                    highlight.append(" " + muetsch_nick);
                }
                if(blacky){
                    highlight.append(" " + blacky_nick);
                }
                if(gebbi){
                    highlight.append(" " + gebbi_nick);
                }

                result = Math.round(result * 100.0)/100.0;

                NumberFormat formatter = new DecimalFormat("#0.00");

                votestring = formatter.format(result) + " bei " + (votecount + added_votecount) + " Bewertungen  " + highlight.toString();

                lb_vote.setText(votestring);

                lb_votecount.setText("extrahierte Bewertungen: " + (votecount + added_votecount));
                lb_sum.setText("Summe der extrahierten Bewertungen: " + (votesum + added_votesum));

            }
        });

    }
    // splittet den großen String aus dem Eingabetextfeld auf die Zeilen auf und trägt diese zur Weiterverarbeiung in eine ArrayList ein
    private void fillStringArrayList(StringBuilder input){


        int newline;

        if(input.indexOf("\n") == -1){
            newline = input.length();
        }
        else{
            newline = input.indexOf("\n");
        }

        do{
            irclines.add(input.substring(0, newline));
            input.delete(0, newline + 1);
            newline = input.indexOf("\n");
        }
        while(input.indexOf("\n") != -1);

        irclines.add(input.toString());




    }

    // holt Strings aus der ArrayList und macht daraus einen großen String für das Ausgabetextfeld
    private String getStringFromArrayList(){


        StringBuilder output = new StringBuilder();

        output.append("potentielle Doppelvotes (nicht verarbeitet): \n");

        java.util.Iterator<String> it2 = doublevotes.iterator();
        while(it2.hasNext()){
            output.append(it2.next() + "\n");
        }

        output.append("\nBewertungsschema, aber keine verarbeitbare Bewertung: \n");

        java.util.Iterator<String> it3 = pattern_only.iterator();
        while(it3.hasNext()){
            output.append(it3.next() + "\n");
        }

        output.append("\nZeilen ohne Bewertungsschema: \n");

        java.util.Iterator<String> it = irclines_unprocessed.iterator();
        while(it.hasNext()){
            output.append(it.next() + "\n");
        }

        output.append("\nverarbeitete Zeilen mit Bewertungsschema: \n");

        Set<String> keys = processed_irclines.keySet();
        java.util.Iterator<String> it4 = keys.iterator();
        while(it4.hasNext()){
            output.append(processed_irclines.get(it4.next()) + "\n");
        }

        return output.toString();

    }

    // prüft, ob das Bewertungsschema votepattern in String irczeile zwei mal vorkommt (setzt voraus, dass es mind 1x vorkommt)
    private int checkSameDoubleVote(String votepattern, String irczeile){
        // erstes votepattern ersetzen
        String temp = irczeile;
        temp = temp.replaceFirst(votepattern, "");

        // wenn jetzt noch eins im String ist, dann doppelvote
        if (temp.contains(votepattern)){
            return 1;
        }
        // sonst nicht
        else{
            return 0;
        }

    }

    // prüft, ob der Eingabe-Char eine Ziffer, ein Punkt oder ein Minus ist
    private  boolean isNumberOrDotOrMinus(char input){
        String temp = String.valueOf(input);
        if( ( (temp.codePointAt(0) <= 57) & (temp.codePointAt(0) >= 48) ) || (temp.codePointAt(0) == 46) || (temp.codePointAt(0) == 45)){
            return true;
        }
        else{
            return false;
        }
    }

    // prüft, ob der Eingabe-Char eine Ziffer oder ein Minus ist
    private  boolean isNumberOrMinus(char input){
        String temp = String.valueOf(input);
        if( ( (temp.codePointAt(0) <= 57) & (temp.codePointAt(0) >= 48) ) || (temp.codePointAt(0) == 45)){
            return true;
        }
        else{
            return false;
        }
    }

    // prüft, ob der Eingabe-Char ein Punkt ist
    private  boolean isDot(char input){
        String temp = String.valueOf(input);
        if( temp.codePointAt(0) == 46 ){
            return true;
        }
        else{
            return false;
        }
    }

    // beschneidet einen String (beginnend nach dem Nickname, endend vor dem Bewertungsschema) auf die letze Zahl vor dem Bewertungsschema
    // ließt die Zahl aus (oder setzt current_vote = -1 bei Fehlschlag)
    // rundet diese
    // führt Bereichüberprüfung aus und korrigiert ggf. auf Ober-/Untergrenze
    private int parseRow(String row){

        // Kommas durch Punkte ersetzen, da ParseFloat nichts mit kommas anfangen kann
        row = row.replace(',' , '.');


        float bewertung = Float.NaN;

        /*
         * Block 1 wertet so aus, dass die erste Zahl vor dem Bewertungsschema genommen wird, wobei zwischen
         * Bewertungsschema und Zahl noch was stehen darf.
         *
         * Beispiel: [Dienstag, 30. September 2014] [23:26:24] <Metalfire>  6,5 kekse /10 --> 7/10
         *
         * Beispiel für Zeilen, die damit falsche Bewertungen produzieren:
         * [Dienstag, 23. September 2014] [22:16:50] <tublat>   2 deep 4 u /10 --> 4/10
         *
         */
//      // try-catch-Block, da es sein kann, dass zwar ein Bewertungsschema gefunden wurde, aber keine Bewertung enthalten ist
//      // dann wird der String auf der Suche nach einer Zahl so lange beschnitten, bis eine StringIndexOutOfBoundsException kommt
//      //
//      // Beispiel: [Dienstag, 14. Oktober 2014] [23:46:52] <TouhouFan>    inaba/10
//      try{
//
//          // TODO:
//          // Es könnten mehrere Zahlen zwischen Nickstop und Bewertung stehen, dann ist unklar, was Bewertung ist.
//          // Solche Zeilen könnte man auch filtern.
//
//
//          // prüfen, wo die letzte Zahl vor dem Bewertungsschema ist
//          // dazu von rechts nach links den String durchgehen
//
//          int i = row.length() - 1;
//          int progress = 0;
//
//          // zunächst muss mindestens eine Ziffer kommen, das ist das Ende der Zahl
//
//          while((progress < 1)){
//              if(!isNumberOrMinus(row.charAt(i))){
//                  i = i - 1;
//              }
//              else{
//                  progress = 1;
//              }
//          }
//
//
//          // das Ende der Zahl wurde gefunden, nun den String beschneiden
//          row = row.substring(0, i+1);
//
//          boolean dotOccured = false;
//
//          // jetzt dürfen Ziffern, ein Punkt oder ein Minus kommen
//          //
//          // falls ein Punkt kommt, dürfen davor nur noch Ziffern oder ein Minus kommen
//          while((progress < 2)){
//              // bevor Punkt gekommen ist, Ziffern, Punkte und Minus zulassen
//              if(isNumberOrDotOrMinus(row.charAt(i)) & !dotOccured){
//                  if(isDot(row.charAt(i))){
//                      dotOccured = true;
//                  }
//                  i = i - 1;
//              }
//              // nachdem Punkt gekommen ist (d. h., die Zahl ist eine Kommazahl oder vor der Ganzzahl steht ein Punkt), nur noch Ziffern und Minus zulassen
//              else{
//                  if(isNumberOrMinus(row.charAt(i))){ // nachdem Punkt gekommen ist, nur noch Ziffern zulassen
//                      i = i - 1;
//                  }
//                  else{
//                      // Anfang der Zahl gefunden
//                      progress = 2;
//                  }
//              }
//          }
//
//          // String auf den Bereich mit der Zahl beschneiden
//
//          row = row.substring(i + 1, row.length() );
//
//          // die erste Stelle könnte Punkt sein, wenn Berwerung eine Ganzzahl mit Punkt davor ist
//          // dann diesen entfernen
//          if(isDot(row.charAt(0))){
//              row = row.substring(1, row.length());
//          }
//
//      }
//      // Exception, wenn String out of range --> Bewertungsschema, aber keine Bewertung
//      catch (StringIndexOutOfBoundsException e){
//          row = "nonumber";
//      }

        /*
         * Block 2 wertet so aus, dass zwischen Zahl und Bewertungsschema keine weiteren Zeichen (abgesehen von Leerzeichen) stehen dürfen.
         * Beispiel: [Dienstag, 30. September 2014] [23:26:24] <Metalfire>  6,5 /10 --> 7/10
         *
         * Dafür können solche Zeilen:
         * [Dienstag, 30. September 2014] [23:26:24] <Metalfire>    6,5 kekse /10 --> 7/10
         * nicht automatisiert werden.
         *
         * Beide Blöcke werten bei - mit Leerzeichen die Zahl fälschlicherweise positiv
         *
         * Beispiel: [Dienstag, 30. September 2014] [23:26:24] <Metalfire>  - 100/10 --> 10/10
         * [Dienstag, 30. September 2014] [23:26:24] <Metalfire>    -100/10 --> 0/10
         *
         */

        boolean done = false;

        while(!done){
            try{
                bewertung = Float.parseFloat(row);
                done = true;
            }
            catch (NumberFormatException e){
                if(row.length() > 1){
                    row = row.substring(1);
                }
                else{
                    done = true;
                }
            }
        }

        // jetzt sollte der String auf den Bereich mit der Zahl beschnitten sein, so dass
        // diese ausgelesen werden kann


        /*
         * gehört zu m Code von Block 1
         */
//      try{
//          bewertung = Float.parseFloat(row);
//      }
//      // bei "nonumber" oder unlesbarer Bewertung, diese auf NaN setzen
//      catch (NumberFormatException e){
//          bewertung = Float.NaN;
//      }

        // -1 als Bewertung ist Signalwert dafür, dass zwar Bewertungsschema, aber keine gültige Bewertung gefunden wurde
        if(Float.isNaN(bewertung)){
            return -1;
        }
        // falls gültige Bewertung extrahiert werden konnte...
        else{
            // ...diese auf Ganzzahl runden und Bereichsüberprüfung mit Korrektur durchführen
            int current_vote = Math.round(bewertung);
            if(current_vote > 10){
                current_vote = 10;
            }
            if(current_vote < 0){
                current_vote = 0;
            }
            return current_vote;
        }

    }



    // extrahiert aus einer IRC-Zeile die Bewertung (falls vorhanden) und rechnet diese zum Geamtergebnis hinzu
    // filtert dabei Doppelvotes raus
    private void extract(){


        int votecount_zeile = 0;
        int current_vote = 0;
        String zeile = null;
        String nickname = null;


        java.util.Iterator<String> it = irclines.iterator();
        while(it.hasNext()){

            votecount_zeile = 0;
            current_vote = 0;
            nickname = null;
            zeile = it.next();

            // wenn Zeile nickname enthält, dann diesen extrahieren
            //
            // wenn der IRC-Client die Nicknames nicht mit nickstart und nickstop umrandet, dann funktionert das so nicht
            // wenn jemand den Nickname während des Abschnitts mit den Bewertungen ändert, dann klappt das Aussortieren der Doppelbewertung nicht
            if((zeile.indexOf(nickstart) != -1 ) && (zeile.indexOf(nickstop) != -1 )){
                nickname = zeile.substring(zeile.indexOf(nickstart) + 1, zeile.indexOf(nickstop));

            // Bewertung suchen, falls Zeile Nickname enthält


                if (zeile.contains("/10")){

                    // Zeile auf Bereich zwischen dem Bewertungsschema und dem Nickname beschneiden, da nur hier die Zahl von Interesse drin ist (wenn vorhanden)
                    String temp = zeile.substring(zeile.indexOf(nickstop), zeile.indexOf("/10"));

                    votecount_zeile++;
                    votecount_zeile = votecount_zeile + checkSameDoubleVote("/10", zeile);

                    current_vote = parseRow(temp);
                }

                if (zeile.contains("/ 10")){

                    String temp = zeile.substring(zeile.indexOf(nickstop), zeile.indexOf("/ 10"));

                    votecount_zeile++;
                    votecount_zeile = votecount_zeile + checkSameDoubleVote("/ 10", zeile);

                    current_vote = parseRow(temp);
                }

                if (zeile.contains("\\10")){

                    String temp = zeile.substring(zeile.indexOf(nickstop), zeile.indexOf("\\10"));

                    votecount_zeile++;
                    votecount_zeile = votecount_zeile + checkSameDoubleVote("\\10", zeile);

                    current_vote = parseRow(temp);
                }

                if (zeile.contains("\\ 10")){

                    String temp = zeile.substring(zeile.indexOf(nickstop), zeile.indexOf("\\ 10"));

                    votecount_zeile++;
                    votecount_zeile = votecount_zeile + checkSameDoubleVote("\\ 10", zeile);

                    current_vote = parseRow(temp);
                }

                if (zeile.contains("von10")){

                    String temp = zeile.substring(zeile.indexOf(nickstop), zeile.indexOf("von10"));

                    votecount_zeile++;
                    votecount_zeile = votecount_zeile + checkSameDoubleVote("von10", zeile);

                    current_vote = parseRow(temp);
                }

                if (zeile.contains("von 10")){

                    String temp = zeile.substring(zeile.indexOf(nickstop), zeile.indexOf("von 10"));

                    votecount_zeile++;
                    votecount_zeile = votecount_zeile + checkSameDoubleVote("von 10", zeile);

                    current_vote = parseRow(temp);
                }

                // auf + prüfen, um zeilen wie
                // [Dienstag, 30. September 2014] [22:47:47] <Links>    6/10 + 2 für den sub
                // rauszuschmeißen
                //
                // kann man auch für - machen, verhindert aber,
                // dass negative Zahlen automatisch als 0  gewertet werden können
                // und alle Zeilen mit Bindestrichen fallen auch durchs Raster
                String temp = zeile.substring(zeile.indexOf(nickstop));
                if(temp.contains("+")){
                //if(temp.contains("+") || temp.contains("-")){
                    current_vote = -1;
                }


                // Eintragen der Zeile ///////////////////////////////////////////////////////////////////////////

                // Wahrheitstabelle
                // votecount = 0 und current_vote = do not care :       keine Bewertung in Zeile
                // votecount = 1 und current_vote -1 :                  Bewertungsschema vorhanden, aber keine Bewertung
                // votecount = 1 und current_vote = 0 bis 10:           eine gültige Bewertung vorhanden, Check auf Doppelvote, sonst Eintragung
                // votecount > 1 und current_vote = do not care:        Doppelvote innerhalb einer Zeile

                // prüfen, ob user schon geblacklistet wurde
                if(blacklisted_nicknames.contains(nickname) && (votecount_zeile >=1 )){

                    // dann zeile zu den doublevotes und weiter mit der nächsten Zeile
                    doublevotes.add(zeile);
                    continue;
                }


                // wenn nur ein Vote-Schema in der Zeile gefunden wurde und die Zeile einen Nickname hatte
                //
                // Beispiel: [Dienstag, 9. September 2014] [23:19:33] <alex_roston> 10/10 so geniaaaaal!
                // aber auch: [Dienstag, 14. Oktober 2014] [23:46:52] <TouhouFan>   inaba/10
                if (votecount_zeile == 1) {

                    // prüfen, ob user schon nen vote abgegeben hat, aber noch nicht geblacklistet wurde
                    if(processed_nicknames.containsKey(nickname)){

                        // dann votecount dekrementieren und den ersten Vote dieses users wieder abziehen
                        votecount--;
                        votesum = votesum - processed_nicknames.get(nickname);

                        // außerdem user blacklisten und jetzige sowie vorherige Zeile dieses users bei den doublevotes eintragen
                        blacklisted_nicknames.add(nickname);

                        temp = processed_irclines.get(nickname);
                        temp = temp.substring(0, temp.lastIndexOf("-->"));
                        doublevotes.add(temp);

                        doublevotes.add(zeile);

                        processed_irclines.remove(nickname);



                    }
                    // Normallfall: user hat noch keinen vote abgegeben und ist nicht wegen doublevote geblacklistet
                    else{

                        // prüfen, ob Bewertungsschema vorhanden war, aber keine Bewertung gefunden werden konnte
                        // dann Zeile unter pattern_only eintragen
                        if (current_vote == -1){

                            pattern_only.add(zeile);
                        }

                        // wenn Bewertung gefunden werden konnte
                        else{
                            zeile = zeile + "  -->  " + current_vote;
                            votecount++;
                            votesum = votesum +  current_vote;
                            processed_nicknames.put(nickname, current_vote);
                            processed_irclines.put(nickname, zeile);
                        }
                    }
                }

                // wenn mehr als ein Vote in der Zeile
                //
                // Beispiel: [Mittwoch, 10. September 2014] [00:13:40] <DerDingens> 3/10 für die Folge, 7/10 für blackys geballten HASS = Gesamtwertung 10/10
                // --> kann man nicht automatisch bearbeiten lassen
                else if (votecount_zeile > 1){

                    // prüfen, ob user schon nen vote abgegeben hat, aber noch nicht geblacklistet wurde
                    if(processed_nicknames.containsKey(nickname)){

                        // dann votecount dekrementieren und den ersten Vote dieses users wieder abziehen
                        votecount--;
                        votesum = votesum - processed_nicknames.get(nickname);

                        // außerdem user blacklisten und jetzige sowie vorherige Zeile dieses users bei den doublevotes eintragen
                        blacklisted_nicknames.add(nickname);
                        doublevotes.add(processed_irclines.get(nickname));
                        doublevotes.add(zeile);

                    }
                    // sonst user wegen doublevote blacklisten
                    else{
                        // dann zeile zu den doublevotes und weiter mit der nächsten zeile
                        blacklisted_nicknames.add(nickname);
                        doublevotes.add(zeile);
                    }

                }

                // wenn kein Vote in der Zeile, diese bei unprocessed hinzufügen
                //
                // Beispiel: [Dienstag, 14. Oktober 2014] [23:52:43] <Hans_Yolo>    ok animestream vorbei für heute
                else{
                    irclines_unprocessed.add(zeile);
                }
            }

            // wenn kein Nickname nach Schema <nickname>
            // mit < gleich nickstart und > gleich nickstop in der Zeile, diese bei unprocessed hinzufügen
            //
            // Beispiel: [Mittwoch, 15. Oktober 2014] [00:37:03] Beenden    brainless (~chatzilla@euirc-e21b6c8b.dynamic.kabel-deutschland.de) hat diesen Server verlassen (Client exited).
            else{
                irclines_unprocessed.add(zeile);
            }


        } //while-Klammer

    } // extract-Klammer

}