ResultController.java

package ui.controllers;

import exceptions.NegativeDurationException;
import javafx.application.Platform;
import javafx.concurrent.Task;
import javafx.fxml.FXML;
import javafx.scene.chart.LineChart;
import javafx.scene.chart.XYChart;
import javafx.scene.text.Text;
import kernel.Kernel;
import kernel.views.variables.*;
import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import ui.Controller;

import java.text.SimpleDateFormat;
import java.time.DateTimeException;
import java.time.Duration;
import java.util.concurrent.Executor;

@Controller
public class ResultController implements Executor {

    private static final Logger log = LoggerFactory.getLogger
            (ResultController.class);

    private static final Duration pressurePollingInterval =
            Duration.ofMillis(1000);

    private static final Duration voltagePollingInterval =
            Duration.ofMillis(1000);

    private static final Integer maximumNumberOfDataPointsInCharts = 30;

    @Autowired private Kernel kernel;

    @FXML private volatile Text reportedPressure;

    @FXML private volatile Text reportedVoltage;

    @FXML private LineChart<String, Float> pressureChart;

    @FXML private LineChart<String, Float> voltageChart;

    private XYChart.Series<String, Float> pressureSeries;

    private XYChart.Series<String, Float> voltageSeries;

    @FXML public void initialize(){
        configurePressureSeries();
        if (kernel.getVariableProvidersView().hasPressureProvider()){
            log.info("Found pressure provider. Reporting");
            configurePressureProvider();
        }

        configureVoltageSeries();
        if (kernel.getVariableProvidersView().hasVoltageProvider()){
            log.info("Found voltage provider. Reporting");
            configureVoltageProvider();
        }
    }

    @FXML
    public void handleRefreshButtonClicked(){
        if (kernel.getVariableProvidersView().hasPressureProvider()){
            log.info("Found pressure provider. Using this for reports");
            configurePressureProvider();
        }
        if (kernel.getVariableProvidersView().hasVoltageProvider()){
            log.info("Found voltage provider. Using this for reports");
            configureVoltageProvider();
        }
    }

    @Override
    public void execute(@NotNull Runnable command){
        Platform.runLater(command);
    }

    private void configureVoltageProvider(){
        VariableProvider<Voltage> provider = kernel.getVariableProvidersView()
                .getVoltageProvider();

        try {
            provider.setPollingInterval(voltagePollingInterval);
        } catch (NegativeDurationException error){
            error.printStackTrace();
        }

        provider.addOnChangeListener(new VoltageChangeHandler(this));
    }

    private void configurePressureProvider(){
        VariableProvider<Pressure> provider = kernel
                .getVariableProvidersView().getPressureProvider();

        try {
            provider.setPollingInterval(pressurePollingInterval);
        } catch (NegativeDurationException error){
            error.printStackTrace();
        }

        provider.addOnChangeListener(new PressureChangeHandler(this));
    }

    private void configureVoltageSeries(){
        voltageSeries = new XYChart.Series<>();
        voltageSeries.setName("Voltage / V");

        voltageChart.getData().add(voltageSeries);
    }

    private void configurePressureSeries(){
        pressureSeries = new XYChart.Series<>();
        pressureSeries.setName("Pressure / mBar");

        pressureChart.getData().add(pressureSeries);
    }

    private class VoltageChangeHandler implements
            VariableChangeEventListener<Voltage> {

        private Executor taskExecutor;

        public VoltageChangeHandler(Executor taskExecutor){
            this.taskExecutor = taskExecutor;
        }

        @Override
        public void onChange(Voltage newVoltage){
            if (voltageChart.isVisible() && reportedVoltage.isVisible()) {
                Task<Void> task = new UpdateVoltageTask(newVoltage);
                this.taskExecutor.execute(task);
            }
        }
    }

    private class PressureChangeHandler implements
            VariableChangeEventListener<Pressure> {

        private Executor taskExecutor;

        public PressureChangeHandler(Executor taskExecutor){
            this.taskExecutor = taskExecutor;
        }

        @Override
        public void onChange(Pressure newPressure){
            if (pressureChart.isVisible() && reportedPressure.isVisible()) {
                Task<Void> task = new UpdatePressureTask(newPressure);
                this.taskExecutor.execute(task);
            }
        }
    }

    private class UpdatePressureTask extends Task<Void> {
        private Pressure newPressure;

        public UpdatePressureTask(Pressure newPressure){
            this.newPressure = newPressure;
        }

        @Override
        public Void call(){
            updatePressureText();
            updatePressureChart();
            return null;
        }

        private void updatePressureText(){
            reportedPressure.setText(newPressure.getValue().toString());
        }

        private void updatePressureChart() throws DateTimeException {
            String xValue = getDateFromPressure();
            Float yValue = newPressure.getValue();
            XYChart.Data<String, Float> dataPoint = new XYChart.Data<>(
                    xValue, yValue);

            pressureSeries.getData().add(dataPoint);
            ResultController.checkSeriesSizeCorrect(pressureSeries);
        }

        @NotNull
        private String getDateFromPressure() throws DateTimeException {
            SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");
            return formatter.format(newPressure.getDate());
        }
    }

    private class UpdateVoltageTask extends Task<Void> {
        private Voltage newVoltage;

        public UpdateVoltageTask(Voltage newVoltage){
            this.newVoltage = newVoltage;
        }

        @Override
        public Void call(){
            updateVoltageText();
            updateVoltageChart();
            return null;
        }

        private void updateVoltageText(){
            reportedVoltage.setText(newVoltage.getValue().toString());
        }

        private void updateVoltageChart(){
            String xValue = getDateFromVoltage();
            Float yValue = newVoltage.getValue().floatValue();

            XYChart.Data<String, Float> dataPoint = new XYChart.Data<>(
                    xValue, yValue
            );

            voltageSeries.getData().add(dataPoint);
            ResultController.checkSeriesSizeCorrect(voltageSeries);
        }

        @NotNull
        private String getDateFromVoltage(){
            SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");
            return formatter.format(newVoltage.getDate());
        }
    }

    private static void checkSeriesSizeCorrect(XYChart.Series series){
        Integer dataPointNumber = series.getData().size();

        if (dataPointNumber > maximumNumberOfDataPointsInCharts){
            series.getData().remove(0);
        }
    }
}