import static Utils.formatDoubleValue
import static java.lang.Math.pow
import static java.lang.Math.sqrt
import static java.lang.String.format
import static org.apache.ivy.util.StringUtils.repeat

class WstecznaPropagacjaBledu {

    private static final int DOUBLE_PRECISION = 3
    private static final double e = 2.718
    private static final String DIVIDER = repeat('#', 100)

    static void main(String[] args) {
        println(
            "ALGORYTM WSTECZNEJ PROPAGACJI BLEDU\n\n" +
                "Siec dwuwarstwowa zlozona z dwoch neuronow unipolarnych ciaglych" +
                "\nw warstwie ukrytej i jednego liniowego w warstwie wyjsciowej\n${DIVIDER}\n"
        )
        double wspUczenia = 1
        println("Wspolczynnik uczenia: ${wspUczenia}")

        List<List<Double>> stopniePewnosci = [
            [1, 0, 0.3, 0.7]
        ]

        List<List<Double>> wzorce = [
            [0, 0, 0, 0, 0],
            [1, 1, 1, 1, 1],
            [1, 1, 0, 0, 0],
            [1, 0, 1, 0, 1]
        ]
        println("\nPrzykladowe wzorce: " + format("%40s", "Stopnie pewnosci:"))
        drukujWzorce(wzorce, stopniePewnosci)

        //      println("\nStopien pewnosci odpowiednio dla kazdego wiersza:")
        //      drukujStopniePewnosci(stopniePewnosci as List<Double>)

        println("\nUnormowane wzorce:")
        normalizujWzorce(wzorce)
        drukujWzorce(wzorce)

        Random r = new Random()
        List<List<Double>> wagiWarstwyUkrytej = [
            [4, -3, 0.5, 1, 0.7],
            [3, 0.5, -2, 0.7, 1]
        ]
        List<Double> wagiWarstwyWyjsciowej = [-0.4, -2]

        println("\nPoczatkowe wartosci wag dla warstwy ukrytej: ")
        drukujWagi(wagiWarstwyUkrytej[0])
        println()
        drukujWagi(wagiWarstwyUkrytej[1])
        println("\n\nPoczatkowe wartosci wag dla warstwy wyjsciowej: ")
        drukujWagi(wagiWarstwyWyjsciowej)
        println()

        //      List<List<Double>> wagi = new ArrayList<>()
        //      for (int i = 0; i < stopniePewnosci.size(); i++) {
        //          wagi.add(
        //              [
        //                  (-1.0 + (1.0 - (-1.0)) * r.nextDouble()).round(1),
        //                  (-1.0 + (1.0 - (-1.0)) * r.nextDouble()).round(1),
        //                  (-1.0 + (1.0 - (-1.0)) * r.nextDouble()).round(1),
        //                  (-1.0 + (1.0 - (-1.0)) * r.nextDouble()).round(1),
        //                  (-1.0 + (1.0 - (-1.0)) * r.nextDouble()).round(1)
        //              ]
        //          )
        //      }
        println(DIVIDER + "\n")

        List<Boolean> bledyRowneZero = [false, false, false, false]

        //      petla po wzorcach
        int licznikEpok = 1
        while (true) {
            println(format("%26s", "--==|Epoka ${licznikEpok}|==--"))

            for (int i = 0; i < wzorce.size(); i++) {
                double y1 = 0
                double y2 = 0
                for (int j = 0; j < wzorce[i].size(); j++) {
                    y1 += wzorce[i][j] * wagiWarstwyUkrytej[0][j]
                    y2 += wzorce[i][j] * wagiWarstwyUkrytej[1][j]
                }

                y1 = f(y1)
                y2 = f(y2)

                double z = wagiWarstwyWyjsciowej[0] * y1 + wagiWarstwyWyjsciowej[1] * y2

                double delta_blad = (double) (stopniePewnosci[0][i] - z)

                double delta_y1 = delta_blad * wagiWarstwyWyjsciowej[0]
                double delta_y2 = delta_blad * wagiWarstwyWyjsciowej[1]

                for (int j = 0; j < wagiWarstwyUkrytej[0].size(); j++) {
                    wagiWarstwyUkrytej[0][j] += wspUczenia * delta_y1 * wzorce[i][j]
                    wagiWarstwyUkrytej[1][j] += wspUczenia * delta_y2 * wzorce[i][j]
                }

                wagiWarstwyWyjsciowej[0] += wspUczenia * delta_blad * y1
                wagiWarstwyWyjsciowej[1] += wspUczenia * delta_blad * y2




                //              double delta_blad1 = (double) (stopniePewnosci[0][i] - y1)
                //              double delta_blad2 = (double) (stopniePewnosci[0][i] - y2)


                //              println("Wynik 1 neuronu dla ${i + 1} wzorca wynosi: ${formatDoubleValue(y1, DOUBLE_PRECISION, 8)}")
                //              println("Blad: ${formatDoubleValue(delta_blad1, DOUBLE_PRECISION, 8)}")
                //              print("Wagi po nauczeniu: ")
                //              drukujWagi(wagiWarstwyUkrytej[0])
                //
                //              println("\n\nWynik 2 neuronu dla ${i + 1} wzorca wynosi: ${formatDoubleValue(y2, DOUBLE_PRECISION, 8)}")
                //              println("Blad: ${formatDoubleValue(delta_blad2, DOUBLE_PRECISION, 8)}")
                //              print("Wagi po nauczeniu: ")
                //              drukujWagi(wagiWarstwyUkrytej[1])

                println("\nWynik dla ${i + 1} wzorca wynosi: ${formatDoubleValue(z, DOUBLE_PRECISION, 8)}")
                println("Blad: ${formatDoubleValue(delta_blad, DOUBLE_PRECISION, 8)}")

                delta_blad = delta_blad.round(4)
                bledyRowneZero[i] = delta_blad < 0.001
                //
                //              delta_blad1 = delta_blad1.round(4)
                //              delta_blad2 = delta_blad2.round(4)
                //
                //              double temp = delta_blad1 * delta_blad1 + delta_blad2 * delta_blad2
                //              bledyRowneZero[i] = sqrt(temp) < 0.001
            }
            print("\nWagi po nauczeniu: ")
            drukujWagi(wagiWarstwyWyjsciowej)
            println("\n${DIVIDER}\n")

            //          print("\n\n\tAby przerwać naukę wciśnij 'k', aby kontynuować inny klawisz...")
            //          if (System.in.newReader().readLine() == 'k') {
            //              break
            //          }

            licznikEpok++
            if (!(false in bledyRowneZero)) {
                break
            }
        }
    }

    private static double f(double y) {
        //      println("y=${y}")
        //      println("pow(e, -y)=${pow(e, -y)}")
        double wynik = 1 / (1 + pow(e, -y))
        //      println("wynik=${wynik}")
        return wynik
    }

    private static void drukujWagi(List<Double> wagi) {
        wagi.each { value ->
            print(formatDoubleValue(value, DOUBLE_PRECISION, 8))
        }
        //      println("\n")
    }

    private static void normalizujWzorce(List<List<Double>> wzorce) {
        wzorce.each { line ->
            def dlugoscWektora = 0
            line.each { value ->
                dlugoscWektora += value * value
            }
            dlugoscWektora = sqrt(dlugoscWektora)

            if (dlugoscWektora != 0) {
                for (int i = 0; i < line.size(); i++) {
                    line[i] = line[i] / dlugoscWektora
                }
            }
        }
    }

    private static void drukujWzorce(List<List<Double>> wzorce, List<List<Double>> listaStopniPewnosciDlaNeuronow = null) {
        for (int i = 0; i < wzorce.size(); i++) {
            wzorce[i].each { value ->
                print(formatDoubleValue(value, DOUBLE_PRECISION, 8))
            }
            if (listaStopniPewnosciDlaNeuronow) {
                print("\t")
                for (int j = 0; j < listaStopniPewnosciDlaNeuronow.size(); j++) {
                    print(format("%-20s", "| dla ${j + 1} jest ${listaStopniPewnosciDlaNeuronow[j][i]}"))
                }
            }
            println()
        }
    }

    private static void drukujStopniePewnosci(List<Double> stopniePewnosci) {
        stopniePewnosci.each { value ->
            print(formatDoubleValue(value, DOUBLE_PRECISION, 8) + '\n')
        }
    }
}