package currency_markets;

import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.fxml.FXML;
import javafx.geometry.Point2D;
import javafx.scene.chart.*;
import javafx.scene.control.Label;
import javafx.scene.control.Spinner;
import javafx.scene.control.SpinnerValueFactory;
import javafx.scene.input.MouseEvent;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class MainWindowController{
    /*
    * Dependency injection
    * makes sure that all injections are done
    */
    @FXML
    private Label labelSummary;

    @FXML
    private LineChart<String, Double> lineChart, lineChartFractalPreview;

    @FXML
    private BarChart<String, Double> barChart;

    @FXML
    private Spinner<Integer> spinnerCoeffCount, spinnerNoOfIterations;

    @FXML
    private Spinner<Double> spinnerX1, spinnerX2, spinnerX3, spinnerX4, spinnerX5,
            spinnerY1, spinnerY2, spinnerY3, spinnerY4, spinnerY5;

    @FXML
    private Spinner<Double> spinnerBegYear, spinnerEndYear, spinnerBegValue, spinnerEndValue;

    private List<Spinner<Double>> spinnerXList;
    private List<Spinner<Double>> spinnerYList;
    private List<Double> selectedCoeffsXList;
    private List<Double> selectedCoeffsYList;
    private long renderTimeStart;
    private Utilities utils;

    public MainWindowController(){ System.out.println("MainWindowController ready for duty!"); }

    @FXML
    void initialize(){
        utils = new Utilities();
        labelSummary.setText("Summary: None");

        SpinnerValueFactory<Integer> spinnerIntValueFactory = new SpinnerValueFactory.IntegerSpinnerValueFactory(1,5,1);
        spinnerCoeffCount.setValueFactory(spinnerIntValueFactory);

        spinnerIntValueFactory = new SpinnerValueFactory.IntegerSpinnerValueFactory(1,20,1);
        spinnerNoOfIterations.setValueFactory(spinnerIntValueFactory);

        SpinnerValueFactory<Double> spinnerDoubleValueFactory = new SpinnerValueFactory.DoubleSpinnerValueFactory(1900,2100, 2000, 1);
        spinnerBegYear.setValueFactory(spinnerDoubleValueFactory);

        spinnerDoubleValueFactory = new SpinnerValueFactory.DoubleSpinnerValueFactory(1900,2100, 2010, 1);
        spinnerEndYear.setValueFactory(spinnerDoubleValueFactory);

        spinnerDoubleValueFactory = new SpinnerValueFactory.DoubleSpinnerValueFactory(0.0,10.0, 2.0, 0.1);
        spinnerBegValue.setValueFactory(spinnerDoubleValueFactory);

        spinnerDoubleValueFactory = new SpinnerValueFactory.DoubleSpinnerValueFactory(0.0,10.0, 5.0, 0.1);
        spinnerEndValue.setValueFactory(spinnerDoubleValueFactory);

        spinnerXList = Arrays.asList(spinnerX1, spinnerX2, spinnerX3, spinnerX4, spinnerX5);
        spinnerYList = Arrays.asList(spinnerY1, spinnerY2, spinnerY3, spinnerY4, spinnerY5);
        configureXYSpinners(spinnerXList);
        configureXYSpinners(spinnerYList);

        lineChart.setTitle("PLN / USD");
        lineChart.setCreateSymbols(false);
        lineChart.setLegendVisible(false);
        lineChart.setAnimated(false);

        barChart.setTitle("PLN / USD delta");
        barChart.setLegendVisible(false);
        barChart.setAnimated(false);

        lineChartFractalPreview.setCreateSymbols(false);
        lineChartFractalPreview.setLegendVisible(false);


        spinnerCoeffCountClick();
    }

    private void setLineChartData(){
        renderTimeStart = System.currentTimeMillis();
        List<Point2D> market = utils.getMarket();
        ObservableList<XYChart.Data<String, Number>> data = FXCollections.observableArrayList();
        for (int i = 0; i < market.size(); i++) {
            String xAxisName = utils.getXaxisName(i);
            data.add(new XYChart.Data<>(xAxisName, market.get(i).getY()));
        }

        XYChart.Series series = new XYChart.Series(data);
        lineChart.getData().clear();
        lineChart.layout();
        lineChart.getData().add(series);
    }

    private void setBarChartData(){
        List<Point2D> market = utils.getMarket();
        ObservableList<XYChart.Data<String, Number>> data = FXCollections.observableArrayList();
        for (int i = 0; i < market.size() - 1; i++) {
            String xAxisName = utils.getXaxisName(i);
            double delta = market.get(i + 1).getY() - market.get(i).getY();
            data.add(new XYChart.Data<>(xAxisName, delta));
        }

        XYChart.Series series = new XYChart.Series(data);
        barChart.getData().clear();
        barChart.getData().add(series);


        long renderTimeStop = System.currentTimeMillis();
        long renderExecTime = renderTimeStop - renderTimeStart;
        labelSummary.setText("No of points: " + market.size() +
                " | Generator exec time: " + utils.getExecTime() + " ms" +
                " | Render time: " + renderExecTime + " ms");
    }

    public void spinnerCoeffCountClick() {
        for (int i = 0; i < spinnerXList.size(); i++){
            if (i + 1 <= spinnerCoeffCount.getValue()){
                spinnerXList.get(i).setDisable(false);
                spinnerYList.get(i).setDisable(false);
            }
            else {
                spinnerXList.get(i).setDisable(true);
                spinnerYList.get(i).setDisable(true);
            }
        }
        spinnerClick();
    }

    public void spinnerClick() {
        selectedCoeffsXList = new ArrayList<>();
        selectedCoeffsYList = new ArrayList<>();

        for (Spinner<Double> spinner: spinnerXList) { if (!spinner.isDisable()){ selectedCoeffsXList.add(spinner.getValue()); } }
        for (Spinner<Double> spinner: spinnerYList) { if (!spinner.isDisable()){ selectedCoeffsYList.add(spinner.getValue()); } }

        setLineChartFractalPreview(selectedCoeffsXList, selectedCoeffsYList);
    }

    private void setLineChartFractalPreview(List<Double> xCoeffsList, List<Double> yCoeffsList){
        Point2D firstPt = new Point2D(spinnerBegYear.getValue(), spinnerBegValue.getValue());
        Point2D secondPt = new Point2D(spinnerEndYear.getValue(), spinnerEndValue.getValue());
        XYChart.Series series = new XYChart.Series();

        series.getData().add(new XYChart.Data<>(Double.toString(firstPt.getX()), firstPt.getY()));
        for (int i = 0; i < xCoeffsList.size(); i++){
            Point2D computedPoint = FractalGenerator.computeNewPoint(firstPt, secondPt, xCoeffsList.get(i), yCoeffsList.get(i));
            String xAxisName = utils.chartXAxisParser(computedPoint.getX());
            series.getData().add(new XYChart.Data<>(xAxisName, computedPoint.getY()));
        }
        series.getData().add(new XYChart.Data<>(Double.toString(secondPt.getX()), secondPt.getY()));
        lineChartFractalPreview.getData().clear();
        lineChartFractalPreview.getData().addAll(series);
    }

    public void buttonSimulationStep(MouseEvent mouseEvent) {
        utils.stepSimulation(selectedCoeffsXList, selectedCoeffsYList);
        setLineChartData();
        setBarChartData();
    }

    public void buttonSimulationStart(MouseEvent mouseEvent) {
        utils.startNewSimulation(spinnerNoOfIterations.getValue(), selectedCoeffsXList, selectedCoeffsYList,
                spinnerBegYear.getValue(), spinnerEndYear.getValue(), spinnerBegValue.getValue(), spinnerEndValue.getValue());
        setLineChartData();
        setBarChartData();
    }

    private void configureXYSpinners(List<Spinner<Double>> list){
        BigDecimal initialValue = new BigDecimal("0.1");
        for (Spinner<Double> spinner: list) {
            SpinnerValueFactory<Double> spinnerDoubleValueFactory = new SpinnerValueFactory.DoubleSpinnerValueFactory(-0.9,0.9,initialValue.doubleValue(), 0.1);
            spinner.setValueFactory(spinnerDoubleValueFactory);
            initialValue = initialValue.add(new BigDecimal("0.1"));
        }
    }
}