using System;

namespace NudnyProjektZCiekawegoPrzedmiotu
{
    class Program
    {
        static void Main(string[] args)
        {
            int d = 10;
            int N = 20;

            int[] pomocna = new int[N];

            double fi1 = 0.01;
            double fi2 = 2;
            double S = 0;

            double ograniczenie = 15;

            double[,,] X = new double[10000, N, d];
            double[,] poprzednieX = new double[N, d];
            double[,] V = new double[N, d];
            double[] fx = new double[N];
            double[] fxw = new double[N];
            double[,] p = new double[N, d];
            double[] g = new double[d];
            double[] pbest = new double[N];
            int[] epoki = new int[3];
            double gbest = 0;
            double gwaga = 0;
            int e = 1;

            int warunek = 0;

            double[] wartosc = new double[d];
            double[] waga = new double[d];

            Random liczba = new Random();

            wyzerujTabliceJednowym(pbest, N);

            wartosc[0] = 5;
            wartosc[1] = 10;
            wartosc[2] = 7;
            wartosc[3] = 3;
            wartosc[4] = 12;
            wartosc[5] = 15;
            wartosc[6] = 8;
            wartosc[7] = 4;
            wartosc[8] = 18;
            wartosc[9] = 13;

            waga[0] = 12;
            waga[1] = 5;
            waga[2] = 9;
            waga[3] = 1;
            waga[4] = 5;
            waga[5] = 13;
            waga[6] = 2;
            waga[7] = 18;
            waga[8] = 23;
            waga[9] = 10;

            wszystkieOpcje(wartosc, waga, ograniczenie, N, d, liczba);

//Inicjalizacja

            inicjalizacjaX(X, d, N, liczba);
            inicjalizacjaV(V, d, N, liczba);

//Epoki

            do
            {
                wyzerujTabliceJednowym(fx, N);
                wyzerujTabliceJednowym(fxw, N);

//Liczenie dla kazdej czastki wartosc fx

                for (int i = 0; i < N; i++)
                {
                    liczenieWartosciFunkcji(wartosc, fx, X, d, i, e);
                    liczenieWartosciFunkcji(waga, fxw, X, d, i, e);

                    if (fxw[i] <= ograniczenie)
                    {
                        if (fx[i] > pbest[i])
                        {
                            pbest[i] = fx[i];
                            for (int j = 0; j < d; j++)
                            {
                                p[i, j] = X[e, i, j];
                            }
                        }

                        if (fx[i] > gbest)
                        {
                            gbest = fx[i];
                            for (int j = 0; j < d; j++)
                            {
                                g[j] = X[e, i, j];
                                gwaga = fxw[i];
                            }
                        }
                    }
                }

//Aktualizacja predkosci i pozycji czastki

                wyzerujTabliceJednowym(fxw, N);

                for (int i = 0; i < N; i++)
                {
                    aktualizacjaCzastki(V, X, p, g, S, i, e, fi1, fi2, d, liczba);
                    liczenieWartosciFunkcji(waga, fxw, X, d, i, e);

                    if (fxw[i] > ograniczenie)
                    {
                        for (int j = 0; j < d; j++)
                        {
                            X[e, i, j] = X[e - 1, i, j];
                        }
                    }
                }

                //Console.WriteLine("Epoka " + (e));
                //wypiszWektoryTrzy(X, d, e, N);
                e++;

//Warunek stopu - sprawdzanie, czy wszystkie czastki osiagnely taka sama pozycje

                if (e > N)
                {
                    int pomocnaTabeli = 0;
                    for (int i = 0; i < N; i++)
                    {
                        int pomocnaJ = 0;
                        for (int j = 0; j < N; j++)
                        {
                            if (i != j)
                            {
                                int pomocnaD = 0;
                                for (int k = 0; k < d; k++)
                                {
                                    if (X[e, i, k] == X[e, j, k])
                                    {
                                        pomocnaD++;
                                    }
                                }
                                if (pomocnaD == d)
                                {
                                    pomocnaJ++;
                                }
                            }
                        }
                        if (pomocnaJ == (N - 1))
                        {
                            pomocnaTabeli++;
                        }
                    }

                    if (pomocnaTabeli == N)
                    {
                        warunek = 1;
                    }
                }

                if (e == 10000)
                {
                    warunek = 1;
                }

//DODAC TEN DRUGI WARUNEK, GDZIE PRZEZ TE 3 EPOKI <<POD RZAD>> NIE MA ZMIAN

                if(e > 3)
                {
                    int pomN = 0;
                    for(int i = 0; i < N; i++)
                    {
                        int pomD = 0;
                        for(int j = 0; j < d; j++)
                        {
                            if(X[e - 2, i, j] == X[e - 1, i, j] && X[e - 2, i, j] == X[e, i, j] && X[e - 1, i, j] == X[e, i, j])
                            {
                                pomD++;
                            }
                        }

                        if(pomD == d)
                        {
                            pomN++;
                        }
                    }

                    if(pomN == N)
                    {
                        warunek = 1;
                    }
                }

            } while (warunek == 0);


            Console.WriteLine();
            Console.WriteLine("Epok: " + e);
            Console.WriteLine("Gbest: " + gbest);
            Console.WriteLine("Waga: " + gwaga);
            Console.WriteLine("Itemki: ");
            for (int i = 0; i < d; i++)
            {
                Console.Write(g[i] + " ");
            }

            Console.ReadKey();
        }

        static void inicjalizacjaX(double[,,] X, int d, int N, Random liczba)
        {
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < d; j++)
                {
                    X[0, i, j] = 0;
                }
            }
        }

        static void inicjalizacjaV(double[,] V, int d, int N, Random liczba)
        {
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < d; j++)
                {
                    double losowaPredkosc = liczba.NextDouble() * 1;
                    V[i, j] = losowaPredkosc;
                }
            }
        }

        static void wyzerujTabliceJednowym(double[] tablica, int N)
        {
            for (int i = 0; i < N; i++)
            {
                tablica[i] = 0;
            }
        }

        static void liczenieWartosciFunkcji(double[] parametr, double[] fx, double[,,] X, int d, int i, int e)
        {
            for (int j = 0; j < d; j++)
            {
                fx[i] += parametr[j] * X[e, i, j];
            }
        }

        static void aktualizacjaCzastki(double[,] V, double[,,] X, double[,] p, double[] g, double S, int i, int e, double fi1, double fi2, int d, Random liczba)
        {
            for (int j = 0; j < d; j++)
            {
                double U1 = liczba.NextDouble() * 1;
                U1 = U1 * fi1;
                double U2 = liczba.NextDouble() * 1;
                U2 = U2 * fi2;
                V[i, j] =  V[i, j] + U1 * (p[i, j] - X[e, i, j]) + U2 * (g[j] - X[e, i, j]);

                S = 1 / (1 + Math.Exp((-1) * V[i, j]));
                //Console.WriteLine("V = " + V[i, j]);
                //Console.WriteLine("S = " + S);
                //Console.WriteLine();
                double randomowaLiczba = liczba.NextDouble() * 1;
                if (randomowaLiczba <= S)
                {
                    X[e + 1, i, j] = 1;
                }
                else
                    X[e + 1, i, j] = 0;

                S = 0;
            }
            //Console.WriteLine();
        }

        static void wszystkieOpcje(double[] wartosc, double[] waga, double ograniczenie, int N, int d, Random liczba)
        {
            int d2 = Convert.ToInt32(Math.Pow(2, d));
            int [] wszystkieKombinacjeDec = new int[d2];
            string[] wszystkieKombinacjeBin = new string[d2];
            char[] pomocniczaChar = new char[d];
            int[,] wszystkieKombinacjeInt = new int[d2, d];
            double[] fx = new double[d2];
            double[] fwx = new double[d2];
            double maxWartosc = 0;
            int maxIndex = 0;

            for (int i = 0; i < d2; i++)
            {
                wszystkieKombinacjeDec[i] = i;
                wszystkieKombinacjeBin[i] = Convert.ToString(wszystkieKombinacjeDec[i], 2);
                pomocniczaChar = wszystkieKombinacjeBin[i].ToCharArray();

                if(pomocniczaChar.Length < d)
                {
                    int roznica = d - pomocniczaChar.Length;

                    for(int k = 0; k < roznica; k++)
                    {
                        wszystkieKombinacjeInt[i, k] = 0;
                    }

                    int pom = 0;
                    for(int k = roznica; k < d; k++)
                    {
                        wszystkieKombinacjeInt[i, k] = pomocniczaChar[pom];
                        pom++;
                    }
                }

                else
                {
                    for (int j = 0; j < d; j++)
                    {
                        wszystkieKombinacjeInt[i, j] = pomocniczaChar[j];
                    }
                }
        }

            for (int i = 0; i < d2; i++)
            {
                for (int j = 0; j < d; j++)
                {
                    if (wszystkieKombinacjeInt[i, j] == 49)
                    {
                        wszystkieKombinacjeInt[i, j] = 1;
                    }

                    if (wszystkieKombinacjeInt[i, j] == 48)
                    {
                        wszystkieKombinacjeInt[i, j] = 0;
                    }
                }
            }

            for(int i = 0; i < d2; i++)
            {
                for (int j = 0; j < d; j++)
                {
                    fx[i] += wartosc[j] * wszystkieKombinacjeInt[i, j];
                    fwx[i] += waga[j] * wszystkieKombinacjeInt[i, j];
                }

                if(fx[i] > maxWartosc && fwx[i] <= ograniczenie)
                {
                    maxWartosc = fx[i];
                    maxIndex = i;
                }
            }

            for (int i = 0; i < d2; i++)
            {
                if(fwx[i] <= ograniczenie)
                {
                    for (int j = 0; j < d; j++)
                    {
                        Console.Write(wszystkieKombinacjeInt[i, j] + " ");
                    }
                    Console.Write(" Wartosc = " + fx[i] + "; Waga = " + fwx[i] + "; ");

                    if (i == maxIndex)
                    {
                        Console.Write("<-- NAJLEPSZE ROZWIAZANIE");
                    }
                    Console.WriteLine();
                }
            }
        }

//Wypisywanie

        static void wypiszWektoryDwu(double[,] wektor, int d, int N)
        {
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < d; j++)
                {
                    Console.Write(wektor[i, j] + " ");
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }

        static void wypiszWektoryTrzy(double[,,] wektor, int d, int e, int N)
        {
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < d; j++)
                {
                    Console.Write(wektor[e, i, j] + " ");
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }

        static void wypiszWartoscFunkcji(double[] fx, int N)
        {
            Console.WriteLine();
            for (int i = 0; i < N; i++)
            {
                Console.WriteLine(i + ". = " + fx[i]);
            }
        }

    }
}