using Esiur.Analysis.Algebra;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Esiur.Analysis.Neural
{
    public class NeuralNetwork
    {
        NeuralLayer[] neuralLayers;

        public NeuralNetwork(int[] layers, MathFunction<RealFunction>[] activations)
        {
            neuralLayers = new NeuralLayer[layers.Length];

            for (var i = 0; i < layers.Length; i++)
                neuralLayers[i] = new NeuralLayer(layers[i], activations[i], i == 0 ? null : neuralLayers[i-1]);
        }

        public double[] FeedForward(double[] input)
        {
            for (int i = 0; i < input.Length; i++)
            {
                neuralLayers[0].Neurons[i].Value = input[i];
            }

            for (int i = 1; i < neuralLayers.Length; i++)
            {
                for (int j = 0; j < neuralLayers[i].Neurons.Length; j++)
                {
                    neuralLayers[i].Neurons[j].Forward();
                }
            }

            return neuralLayers.Last().Neurons.Select(x => x.Value).ToArray();
        }



        public void BackPropagate(double[] input, double[] target)
        {
            var output = FeedForward(input);

            // total error (square error function)
            double totalError = 0.5 * output.Zip(target, (x, y) => Math.Pow(x - y, 2)).Sum() ;


            // calculate partial derivitave of E-Total with respect to weights dE/dW = dE/dOF * dOF/dO *  dO/dW

           for(var i = 0; i < target.Length; i++)
            {
                //var z = -(target[i] - output[i]) * 
            }
            //for (int i = 0; i < output.Length; i++) 
            //    totalError += (float)Math.Pow(output[i] - expected[i], 2);//calculated cost of network

            //totalError /= 2; //this value is not used in calculions, rather used to identify the performance of the network



            //var gamma = neuralLayers.Select(x => x.Neurons.Select(n => n.Value).ToArray()).ToArray();

 
            //int layer = layers.Length - 2;

            //for (int i = 0; i < output.Length; i++) gamma[layers.Length - 1][i] = (output[i] - expected[i]) * activateDer(output[i], layer);//Gamma calculation
            //for (int i = 0; i < layers[layers.Length - 1]; i++)//calculates the w' and b' for the last layer in the network
            //{
            //    biases[layers.Length - 2][i] -= gamma[layers.Length - 1][i] * learningRate;
            //    for (int j = 0; j < layers[layers.Length - 2]; j++)
            //    {

            //        weights[layers.Length - 2][i][j] -= gamma[layers.Length - 1][i] * neurons[layers.Length - 2][j] * learningRate;//*learning 
            //    }
            //}

            //for (int i = layers.Length - 2; i > 0; i--)//runs on all hidden layers
            //{
            //    layer = i - 1;
            //    for (int j = 0; j < layers[i]; j++)//outputs
            //    {
            //        gamma[i][j] = 0;
            //        for (int k = 0; k < gamma[i + 1].Length; k++)
            //        {
            //            gamma[i][j] += gamma[i + 1][k] * weights[i][k][j];
            //        }
            //        gamma[i][j] *= activateDer(neurons[i][j], layer);//calculate gamma
            //    }
            //    for (int j = 0; j < layers[i]; j++)//itterate over outputs of layer
            //    {
            //        biases[i - 1][j] -= gamma[i][j] * learningRate;//modify biases of network
            //        for (int k = 0; k < layers[i - 1]; k++)//itterate over inputs to layer
            //        {
            //            weights[i - 1][j][k] -= gamma[i][j] * neurons[i - 1][k] * learningRate;//modify weights of network
            //        }
            //    }
            //}
        }
    }
}