import java.util.*;

class Neural {

    /**
     *  Число входов
     */
    private final int SIZE_INPUTS = 6;

    /**
     *  Число узлов в скрытом слое
     */
    private final int SIZE_HIDDEN = 7;

    /**
     *  Количество эпох
     */
    private final int EPOCHS = 25000;

    /**
     *  Коэффициент для обучения
     */
    private final double LEARNING_RATE = .005;

    /**
     *  Выходное значение
     */
    private double output;

    /**
     *  Массивы значений на входном и скрытом слоях и массив весов скрытого слоя
     */
    private double[] valueInput, valueHidden, weightsHidden;

    /**
     *  Двумерный массив весов входного слоя
     */
    private double[][] weightsInput;

    /**
     *  Коллекция для обучения сети
     */
    private List<Map<Double, double[]>> trainingList;


    /**
     *  Конструктор. Инициализируем веса и заполняем лист для обучения
     */
    Neural() {
        weightsInput = generateWeights(SIZE_INPUTS, SIZE_HIDDEN);
        weightsHidden = generateWeights(SIZE_HIDDEN);

        trainingList = generateTraningList();
    }

    /**
     *  Передаем в переменную массив входных значений
     * @param valueInput
     */
    private void setValueInput(double[] valueInput) {
        if(valueInput.length != SIZE_INPUTS) {
            System.out.println(String.format("Input values count error! Right count is %d.", SIZE_INPUTS));
            return;
        }
        this.valueInput = valueInput;
    }

    /**
     *  Функция активации - сигмоид
     * @param value
     * @return
     */
    private double getSigmoid(double value) {
        return  1 / (1 + Math.exp(-value));
    }

    /**
     *  Приводим результат либо к нулю, если он меньше 0.5, либо к еденице в обратном случае
     * @param value
     * @return
     */
    private int getResult(double value) {
        return value >= .5 ? 1 : 0;
    }

    /**
     *  Суммируем произведения входных значений и весов и получаем активационную функцию
     * @param input
     * @param weight
     * @return
     */
    private double getActivationFunction(double[] input, double[] weight) {
        double summ = 0;
        for (int x = 0; x < input.length; x++) {
            summ += input[x] * weight[x];
        }
        return getSigmoid(summ);
    }

    /**
     *  Вычисляем значения нейронов на скрытом и на выходном слоях
     */
    private void calculateValues() {
        valueHidden = calculateHiddenValues(valueInput, SIZE_HIDDEN);
        output = calculateOutputValue(valueHidden);
    }

    /**
     *  В начале работы задаем рандомные веса для каждого узла.
     *  В этой функции делаем это для скрытого слоя
     * @param sizeInputs
     * @param sizeHidden
     * @return
     */
    private double[][] generateWeights(int sizeInputs, int sizeHidden) {
        double[][] result = new double[sizeHidden][sizeInputs];
        for(int x = 0; x < sizeHidden; x++) {
            for (int y = 0; y < sizeInputs; y++) {
                result[x][y] = Math.random() * .3;
            }
        }
        return result;
    }

    /**
     *  В начале работы задаем рандомные веса для каждого входа.
     *  В этой функции задаем их для входного слоя
     * @param sizeHidden
     * @return
     */
    private double[] generateWeights(int sizeHidden) {
        double[] result = new double[sizeHidden];
        for(int x = 0; x < sizeHidden; x++) {
            result[x] = Math.random() * .3;
        }
        return result;
    }

    /**
     *  Вычисляем значения на скрытом слое
     * @param valueInput
     * @param size
     * @return
     */
    private double[] calculateHiddenValues(double[] valueInput, int size) {
        double[] result = new double[size];
        for(int x = 0; x < size; x++) {
            result[x] = getActivationFunction(valueInput, weightsInput[x]);
        }
        return result;
    }

    /**
     *  Вычисляем выходное значение
     * @param valueHidden
     * @return
     */
    private double calculateOutputValue(double[] valueHidden) {
        return getActivationFunction(valueHidden, weightsHidden);
    }

    /**
     *  Создаем список для обучения. В комментариях указано ожидаемое значение на выходе
     * @return
     */
    private ArrayList<Map<Double, double[]>> generateTraningList() {
        ArrayList<Map<Double, double[]>> result = new ArrayList<>();
        Map<Double, double[]> map1, map2, map3, map4, map5, map6, map7, map8, map9, map10;
        double[] valuesInput1, valuesInput2, valuesInput3, valuesInput4, valuesInput5, valuesInput6, valuesInput7,
                     valuesInput8, valuesInput9, valuesInput10;

        valuesInput1 =      new double[]{ 0, 1, 1, 0, 0, 0 }; // 0
        map1 = new HashMap<>();
        map1.put(0.0, valuesInput1);

        valuesInput2 =      new double[]{ 0, 0, 0, 1, 1, 0 }; // 1
        map2 = new HashMap<>();
        map2.put(1.0, valuesInput2);

        valuesInput3 =      new double[]{ 0, 0, 1, 1, 1, 0 }; // 1
        map3 = new HashMap<>();
        map3.put(1.0, valuesInput3);

        valuesInput4 =      new double[]{ 1, 1, 0, 0, 1, 0 }; // 1
        map4 = new HashMap<>();
        map4.put(1.0, valuesInput4);

        valuesInput5 =      new double[]{ 0, 1, 1, 1, 0, 0 }; // 0
        map5 = new HashMap<>();
        map5.put(0.0, valuesInput5);

        valuesInput6 =      new double[]{ 0, 0, 0, 0, 0, 1 }; // 1
        map6 = new HashMap<>();
        map6.put(1.0, valuesInput6);

        valuesInput7 =      new double[]{ 0, 1, 1, 0, 0, 1 }; // 0
        map7 = new HashMap<>();
        map7.put(0.0, valuesInput7);

        valuesInput8 =      new double[]{ 0, 1, 1, 1, 1, 1 }; // 1
        map8 = new HashMap<>();
        map8.put(1.0, valuesInput8);

        valuesInput9 =      new double[]{ 0, 0, 0, 0, 0, 0 }; // 0
        map9 = new HashMap<>();
        map9.put(0.0, valuesInput9);

        valuesInput10 =     new double[]{ 1, 0, 0, 0, 0, 0 }; // 1
        map10 = new HashMap<>();
        map10.put(1.0, valuesInput10);

        result.add(map1);
        result.add(map2);
        result.add(map3);
        result.add(map4);
        result.add(map5);
        result.add(map6);
        result.add(map7);
        result.add(map8);
        result.add(map9);
        result.add(map10);

        return result;
    }


    /**
     *  Функция для обучения сети
     */
    void train() {

        for (int x = 0; x <= EPOCHS; x++) {

            double error, weightDelta;
            Collections.shuffle(trainingList);

            for (Map<Double, double[]> aTrainingList : trainingList) {

                for (Map.Entry<Double, double[]> item : aTrainingList.entrySet()) {

                    setValueInput(item.getValue());
                    calculateValues();

                    error = output - item.getKey();
                    weightDelta = error * (getSigmoid(output) * (1 - getSigmoid(output)));

                    for(int y = 0; y < weightsHidden.length; y++) {
                        weightsHidden[y] -= valueHidden[y] * weightDelta * LEARNING_RATE;

                        error = weightsHidden[y] * weightDelta;
                        weightDelta = error * (getSigmoid(valueHidden[y]) * (1 - getSigmoid(valueHidden[y])));

                        for(int z = 0; z < weightsInput[y].length; z++) {
                            weightsInput[y][z] -= valueInput[z] * weightDelta * LEARNING_RATE;
                        }

                    }

                }

            }

        }

    }

}