package de.wwwu.awolf.presenter.io;

import com.opencsv.CSVReader;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.communication.Data;
import de.wwwu.awolf.model.communication.ImportData;
import de.wwwu.awolf.model.communication.SubscriberType;
import de.wwwu.awolf.presenter.util.Logging;

import javax.swing.*;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.Flow;


/**
 * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
 *
 * @Author: Armin Wolf
 * @Email: a_wolf28@uni-muenster.de
 * @Date: 21.06.2017.
 */
public class DataImporter implements Flow.Publisher<Data> {

    private CSVReader reader;
    private Flow.Subscriber<? super Data> subscriber;

    /**
     * Konstruktor
     *
     * @param file Datei aus der die Informationen imortiert werden sollen.
     */
    public DataImporter(File file, Flow.Subscriber<? super Data> subscriber) {
        subscribe(subscriber);

        try {
            this.reader = new CSVReader(new FileReader(file));
        } catch (FileNotFoundException e) {
            Logging.logError(e.getMessage(), e);
        }
    }

    /**
     * Diese Methode importiert liest zeile für zeile die Daten aus der Datei und baut eine Liste von Geraden auf.
     * Dabei wird auf die richtige Form geachtet. Falls die Datei nicht, mindestens zwei Spalten enthält wird ein Fehler
     * signalisiert und der Import wird abgebrochen.
     *
     * @return Liste der Geraden
     */
    public List<Line> run() {
        List<Line> list = new LinkedList<>();
        try {
            List<String[]> lines = reader.readAll();
            int counter = 0;
            String[] result = {"import", lines.size() + "", ""};
            for (String[] nextLine : lines) {
                if (nextLine.length == 3) {
                    double x = Double.parseDouble(nextLine[1]);
                    double y = Double.parseDouble(nextLine[2]) * (-1);
                    Line line = new Line(x, y);
                    line.setId(nextLine[0] + "");
                    if (!list.contains(line)) {
                        list.add(line);
                    }
                    counter++;
                    result[2] = counter + "";
                    Thread.sleep(10);


                    communicate(counter, lines.size());
                } else if (nextLine.length == 2) {
                    double x = Double.parseDouble(nextLine[1]);
                    double y = Double.parseDouble(nextLine[2]) * (-1);
                    Line line = new Line(x, y);
                    line.setId(counter + "");
                    if (!list.contains(line)) {
                        list.add(line);
                    }

                    counter++;
                    result[2] = counter + "";
                    Thread.sleep(10);

                    communicate(counter, lines.size());
                } else {
                    JOptionPane.showMessageDialog(null, "Diese Datei kann nicht importiert werden." +
                            "Es müssen mindestens zwei Spalten enthalten sein (x,y).", "Fehler bei der Eingabe", JOptionPane.ERROR_MESSAGE);
                    Logging.logWarning("Diese Datei kann nicht importiert werden. Es müssen mindestens zwei Spalten enthalten sein (x,y). Fehler bei der Eingabe");
                    return null;
                }
            }
        } catch (IOException e) {
            Logging.logError(e.getMessage(), e);
        } catch (InterruptedException e) {
            Logging.logError(e.getMessage(), e);
            Thread.currentThread().interrupt();
        }
        return list;
    }

    private void communicate(int counter, int size) {
        // communication
        ImportData data = new ImportData();
        data.setType(SubscriberType.IMPORT);
        data.setCurrent(counter);
        data.setNumberOfLines(size);
        this.subscriber.onNext(data);
    }

    @Override
    public void subscribe(Flow.Subscriber<? super Data> subscriber) {
        this.subscriber = subscriber;
    }
}