package de.wwwu.awolf.view.panels;

import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.presenter.util.Logging;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
import org.jfree.util.ShapeUtilities;

import javax.swing.*;
import java.awt.*;
import java.util.List;

/**
 * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
 *
 * @Author: Armin Wolf
 * @Email: a_wolf28@uni-muenster.de
 * @Date: 29.05.2017.
 */
public class PlotPanel extends JPanel {

    private JFreeChart chart;
    private ChartPanel panel;
    private XYSeriesCollection datapoints;
    private XYSeries series;
    private Double min;
    private Double max;
    private XYPlot xyPlot;
    private int seriesCount;

    private XYLineAndShapeRenderer renderer;
    private Shape diamond;

    /**
     * Konstruktor
     */
    public PlotPanel() {
        super();
        this.setLayout(new BorderLayout());
        seriesCount = 1;
    }

    /**
     * Erzeugen des Plots
     *
     * @param points Liste der Geraden
     */
    public void createPlot(List<Line> points) {
        if (!points.isEmpty()) {
            try {
                Thread thread = new Thread(() -> convertData(points));
                thread.start();
                thread.join();
            } catch (InterruptedException e) {
                Logging.logError(e.getMessage(), e);
                Thread.currentThread().interrupt();
            }
        }
        //createScatterPlot
        chart = ChartFactory.createXYLineChart("",
                "X", "Y", datapoints, PlotOrientation.VERTICAL, true, true, false);
        diamond = ShapeUtilities.createDiamond(2f);
        chart.setBorderVisible(false);
        chart.setAntiAlias(true);
        chart.getPlot().setBackgroundPaint(Color.WHITE);
        chart.setBorderVisible(false);


        xyPlot = (XYPlot) chart.getPlot();
        xyPlot.setDomainCrosshairVisible(true);
        xyPlot.setRangeCrosshairVisible(true);


        renderer = (XYLineAndShapeRenderer) xyPlot.getRenderer();
        renderer.setSeriesLinesVisible(0, false);
        renderer.setSeriesShapesVisible(0, true);
        renderer.setSeriesLinesVisible(1, true);
        renderer.setSeriesLinesVisible(1, true);
        renderer.setSeriesPaint(0, Color.blue);
        renderer.setSeriesShape(0, diamond);
        renderer.setBaseSeriesVisible(true);


        xyPlot.setDomainCrosshairVisible(true);
        xyPlot.setRangeCrosshairVisible(true);

        panel = new ChartPanel(chart);
        panel.setMouseZoomable(false);
        this.add(panel, BorderLayout.CENTER);
    }

    /**
     * Leeren des Datensatzes
     */
    public void clear() {
        if (datapoints != null)
            datapoints.removeAllSeries();
    }

    /**
     * Fügt eine Gerade zum Plot hinzu
     *
     * @param m     Steigung
     * @param b     y-Achsenabschnitt
     * @param color Farbe
     * @param name  Bezeichner
     */
    public void addLineToPlot(double m, double b, Paint color, String name) {

        XYSeries linesA = new XYSeries(name);
        linesA.add(min.doubleValue(), min * m + b);
        linesA.add(max.doubleValue(), max * m + b);

        datapoints.addSeries(linesA);

        renderer.setSeriesPaint(seriesCount, color);
        renderer.setSeriesStroke(seriesCount, new BasicStroke(2.0f));
        renderer.setBaseSeriesVisible(true);
        renderer.setSeriesLinesVisible(seriesCount, true);
        seriesCount++;
    }

    /**
     * Fügt eine Gerade zum Plot hinzu
     *
     * @param m    Steigung
     * @param b    y-Achsenabschnitt
     * @param name Bezeichner
     */
    public void addLineToPlot(double m, double b, String name) {
        XYSeries linesA = new XYSeries(name);
        linesA.add(min.doubleValue(), min * m + b);
        linesA.add(max.doubleValue(), max * m + b);

        datapoints.addSeries(linesA);
        seriesCount = xyPlot.getSeriesCount();
        renderer.setSeriesPaint(seriesCount, Color.red);
        renderer.setSeriesStroke(seriesCount, new BasicStroke(2.0f));
        renderer.setBaseSeriesVisible(true);
        renderer.setSeriesLinesVisible(seriesCount, true);
    }

    /**
     * Wandelt die Daten in ein passendes Format um
     *
     * @param points Liste der Geraden
     */
    private void convertData(List<Line> points) {
        datapoints = new XYSeriesCollection();
        series = new XYSeries("points");
        for (Line p : points) {
            series.add(p.getM().doubleValue(), p.getB() * (-1));

        }
        this.max = series.getMaxX();
        this.min = series.getMinX();
        datapoints.addSeries(series);
    }


}