package MLP;

import java.io.File;
import java.io.FileNotFoundException;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Stream;

import org.jfree.chart.*;
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 static MLP.NetworkTools.createRandomArray;

public class Network {

    private double[][] wyjscie;
    private double[][][] wagi;
    private double[][] bias;
    private double[][] vectorMomentum;
    private double[][] errorSignal;
    private double[][] pochodnaPoWyjsciu;

    ArrayList<double[]> list = new ArrayList<>();

    private final int[] rozmiarWarstwySieci;
    private final int rozmiarWejscia;
    private final int rozmiarWyjscia;
    private final int rozmiarSieci;

    public Network(int... tablica) {
        rozmiarWarstwySieci = tablica;
        rozmiarWejscia = rozmiarWarstwySieci[0];
        rozmiarSieci = rozmiarWarstwySieci.length;
        rozmiarWyjscia = rozmiarWarstwySieci[rozmiarSieci -1];

        this.wyjscie = new double[rozmiarSieci][];
        this.wagi = new double[rozmiarSieci][][];
        this.bias = new double[rozmiarSieci][];
        this.vectorMomentum = new double[rozmiarSieci][];
        this.errorSignal = new double[rozmiarSieci][];
        this.pochodnaPoWyjsciu = new double[rozmiarSieci][];

        for(int i = 0; i < rozmiarSieci; i++)
        {
            this.wyjscie[i] = new double[tablica[i]];
            this.errorSignal[i] = new double[tablica[i]];
            this.pochodnaPoWyjsciu[i] = new double[tablica[i]];
            this.bias[i] = createRandomArray(rozmiarWarstwySieci[i],0.2,0.7);
            this.vectorMomentum[i] = new double[tablica[i]];
            if(i>0)
            {
                wagi[i] = createRandomArray(rozmiarWarstwySieci[i],tablica[i-1],-0.3,0.5);
            }
        }
    }

    private void trening(double[] wejscie, double[] cel, double eta, double momentum, boolean ifBias)
    {
        if (wejscie.length != rozmiarWejscia || cel.length != rozmiarWyjscia) return;
        oblicz(ifBias, wejscie);
        bladWstecznejPropragacji(cel);
        zaktualizujWagi(eta, momentum);
    }
    public double[] oblicz(boolean ifBias, double... wejscie)
    {
        if (wejscie.length != this.rozmiarWejscia) return null;
        this.wyjscie[0] = wejscie;
        for (int warstwa = 1; warstwa < rozmiarSieci; warstwa++)
            for (int neuron = 0; neuron < rozmiarWarstwySieci[warstwa]; neuron++) {
                double sum;
                if (ifBias)
                    sum = bias[warstwa][neuron];
                else
                    sum = 0;
                for (int poprzedniNeuron = 0; poprzedniNeuron < rozmiarWarstwySieci[warstwa - 1]; poprzedniNeuron++) {
                    sum += wyjscie[warstwa - 1][poprzedniNeuron] * wagi[warstwa][neuron][poprzedniNeuron];
                }
                wyjscie[warstwa][neuron] = sigmoid(sum);
                pochodnaPoWyjsciu[warstwa][neuron] = wyjscie[warstwa][neuron] * (1 - wyjscie[warstwa][neuron]);
            }
        return wyjscie[rozmiarSieci - 1];
    }

    private void zaktualizujWagi(double eta, double momentum)
    {
        double delta = 0.0;
        for (int warstwa = 1; warstwa < rozmiarSieci; warstwa++)
        {
            //delta = -eta * errorSignal[layer][neuron];
            //bias[layer][neuron] += delta;
            for (int neuron = 0; neuron < rozmiarWarstwySieci[warstwa]; neuron++)
                for (int poprzedniNeuron = 0; poprzedniNeuron < rozmiarWarstwySieci[warstwa - 1]; poprzedniNeuron++) {
                    //delta = -eta * output[layer - 1][prevNeuron] * errorSignal[layer][neuron] + momentum * prevWeight;
                    delta = -eta * wyjscie[warstwa - 1][poprzedniNeuron] * errorSignal[warstwa][neuron] + momentum * vectorMomentum[warstwa][neuron];
                    //prevWeight = delta;
                    vectorMomentum[warstwa][neuron] = delta;
                    wagi[warstwa][neuron][poprzedniNeuron] += delta;
                    bias[warstwa][neuron] += -eta * errorSignal[warstwa][neuron];
                }
        }
    }

    private void bladWstecznejPropragacji(double[] cel)
    {
        for (int neuron = 0; neuron < rozmiarWarstwySieci[rozmiarSieci - 1]; neuron++)
            errorSignal[rozmiarSieci - 1][neuron] = (wyjscie[rozmiarSieci - 1][neuron] - cel[neuron])
                    * pochodnaPoWyjsciu[rozmiarSieci - 1][neuron];
        for (int warstwa = rozmiarSieci - 2; warstwa > 0; warstwa--)
            for (int neuron = 0; neuron < rozmiarWarstwySieci[warstwa]; neuron++) {
                double sum = 0;
                for (int nastepnyNeuron = 0; nastepnyNeuron < rozmiarWarstwySieci[warstwa + 1]; nastepnyNeuron++) {
                    sum += wagi[warstwa + 1][nastepnyNeuron][neuron] * errorSignal[warstwa + 1][nastepnyNeuron];
                }
                errorSignal[warstwa][neuron] = sum * pochodnaPoWyjsciu[warstwa][neuron];
            }
    }

    private double sigmoid(double x)
    {
        return 1d / (1 + Math.exp(-x));
    }

    private ArrayList<double[]> trenowac(ArrayList<double[]> wejscie, ArrayList<double[]> wyjscie, double eta, double momentum, boolean ifBias, int iteracje, int rozmiarTablicy)
    {
        double[] tablicaBledu = new double[iteracje];
        double obliczonyBlad;
        ArrayList<double[]> temp = new ArrayList<>();
        for (int i = 0; i < iteracje; i++)
        {
            int[] tablica = new int[rozmiarTablicy];
            for (int r = 0; r < rozmiarTablicy; r++)
                tablica[r] = r;
            szufladkujTablice(tablica);
            obliczonyBlad = 0;
            for (int k = 0; k < rozmiarTablicy; k++)
            {
                trening(wejscie.get(tablica[k]), wyjscie.get(tablica[k]), eta, momentum, ifBias);
                double sum = 0;
                for (int t = 0; t < rozmiarTablicy; t++)
                {
                    sum += (wyjscie.get(tablica[k])[t] - this.wyjscie[rozmiarSieci - 1][t]) * ((wyjscie.get(tablica[k])[t]) - this.wyjscie[rozmiarSieci - 1][t]);
                }
                obliczonyBlad += sum;

            }
            tablicaBledu[i] = 1d / 4d * obliczonyBlad;
            if (i == iteracje - 1)
            {
                for (int k = 0; k < rozmiarTablicy; k++)
                {
                    list.add(oblicz(ifBias, wejscie.get(k)));
                    temp.add(list.get(k).clone());
                }
            }
        }
        rysujBlad(tablicaBledu);
        return temp;
    }

    private static void szufladkujTablice(int[] tablica)
    {
        Random rnd = ThreadLocalRandom.current();
        for (int i = tablica.length - 1; i > 0; i--)
        {
            int index = rnd.nextInt(i + 1);
            int a = tablica[index];
            tablica[index] = tablica[i];
            tablica[i] = a;
        }
    }
    private int czytajZPliku(ArrayList<double[]> UI, ArrayList<double[]> IO)
    {
        int rozmiarTablicy = 0;
        try{
            Scanner scanner = new Scanner(new File("dane.txt"));
            while (scanner.hasNext())
            {
                rozmiarTablicy++;
                double[] arr = Stream.of(scanner.nextLine().split(","))
                        .mapToDouble (Double::parseDouble)
                        .toArray();

                UI.add(arr);
                IO.add(arr);
            }
        }catch(FileNotFoundException e ) {
            System.out.println(e);
        }
        return rozmiarTablicy;
    }

    private void rysujBlad(double[] error)
    {
        XYPlot plot = new XYPlot();
        XYSeriesCollection dataset = new XYSeriesCollection();

        XYSeries series = new XYSeries("Funkcja błędu") ;
        for(int i = 0 ; i < error.length ; i++)
        {
            series.add(i,error[i]);
        }
        dataset.addSeries(series);
        plot.setDataset(dataset);

        XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer(true, false);
        plot.setRenderer(renderer);
        plot.setDomainAxis(new org.jfree.chart.axis.NumberAxis("Iteracje"));
        plot.setRangeAxis(new org.jfree.chart.axis.NumberAxis("Błąd"));

        JFreeChart chart = new JFreeChart("Perceptron wielowarstwowy", JFreeChart.DEFAULT_TITLE_FONT, plot, true);

        ChartFrame frame1 = new ChartFrame("Perceptron wielowarstwowy",chart);
        frame1.setVisible(true);


        frame1.setSize(1150,650);

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

        Scanner scan = new Scanner(System.in);
        double eta = 0.0;
        double momentum = 0.0;
        int iteracje = 0;
        boolean czyBiasWlaczony = false;
        int liczbaNeuronowUkrytych = 0;

        DecimalFormat df = new DecimalFormat("####.###########");
        ArrayList<double[]> wejscia = new ArrayList<double[]>();
        ArrayList<double[]> wyjscia= new ArrayList<double[]>();
        ArrayList<double[]> wyniki;
/*

        System.out.println("Podaj ilość neuronów w warstwie ukrytej:");
        liczbaNeuronowUkrytych=scan.nextInt();
        System.out.println("Podaj etę:");
        eta=scan.nextDouble();
        System.out.println("Podaj momentum:");
        momentum=scan.nextDouble();
        System.out.println("Podaj liczbę iteracji:");
        iteracje=scan.nextInt();
        System.out.println("Użyć biasu? T by uzyc, cokolwiek by nie uzyc:");
        char ans=scan.next().charAt(0);
        if(ans=='T') {czyBiasWlaczony = true; System.out.println("Bias aktywny.");}
        else {System.out.println("Bias nieaktywny.");}
        scan.close();
*/
        //Network net = new Network(4, numOfHiddenNeurons, 4);
        Network net = new Network(4, 2, 4);

 //       wyniki = net.Training(wejscia,wyjscia,eta ,momentum,biasEnabled,iteracje,net.readFile(wejscia,wyjscia));
        wyniki = net.trenowac(wejscia,wyjscia,0.1 ,0,false,10000,net.czytajZPliku(wejscia,wyjscia));

        System.out.println();

        for(int i = 0; i < 4; i++)
        {
            for(int j = 0; j < 4; j++)
            {
                System.out.print(df.format(wyniki.get(i)[j]) + " ");
            }
            System.out.println();
        }
        System.out.println();

    }}