using OxyPlot;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace inzynierka_kowalczyk
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    ///
    public static class MyStaticValues
    {
        public static int liczbaInstancji { get; set; }
    }

    public partial class MainWindow : Window
    {

        static Random r = new Random();
        Random mutacjeRandom;
        Random krzyzowanieRandom;
        Random krzyzowka;

        public static string krzyzowanie = "";
        public static string mutacje = "";
        public static string selekcje = "";

        public static int liczbaOsobnikow = 0;
        public static int liczbaPrac = 0;
        public static int liczbaMaszyn = 0;
        public static int liczbaGeneracji = 0;
        public static float mutacjeProcent = 0;
        public static float krzyzowanieProcent = 0;
        public static int liczniktablicyMutacji = 0;
        public static int liczniktablicyKrzyzowania = 0;
        public static int sumaFunkcjiCeluMinimalizacja = 0;

        public int[,] tablicaFunkcjiCelu;

        Osobnik pierwszyOsobnik;

        Chromosom[] osobnikGlowny = new Chromosom[liczbaOsobnikow];
        Chromosom[] mutacjePotomkowie;
        Chromosom[] krzyzowaniePotomkowie;
        Chromosom[] nowaGeneracjaBezFCelu;

        Osobnik[] tabRodzicow;
        Osobnik[] nowaGeneracja;
        Osobnik[] tabPoSelekcji;

        public MainWindow()
        {
            InitializeComponent();
        }

        private void adjacentTwoJobExchange_Click(object sender, RoutedEventArgs e)
        {
            mutacje = "adjacentTwoJobExchange";
            wybranaMutacja.Text = "Adjacent Two-Job Exchange";
        }

        public static Chromosom adjacentTwoJobExchangeMethod(Chromosom ck)
        {
            int index = r.Next(0, liczbaPrac);
            Chromosom kromosom = new Chromosom();
            kromosom.liczbaPrac = ck.liczbaPrac;
            kromosom.zadanie = ck.zadanie;
            for (int i = 0; i < liczbaPrac; i++)
            {
                if (i == index)
                {
                    if (index == 0)
                    {
                        Praca temp = new Praca();
                        temp.liczbaMaszyn = kromosom.zadanie[index].liczbaMaszyn;
                        temp.rnd = kromosom.zadanie[index].rnd;
                        temp.zadania = kromosom.zadanie[index].zadania;

                        kromosom.zadanie[index].liczbaMaszyn = kromosom.zadanie[index + 1].liczbaMaszyn;
                        kromosom.zadanie[index].rnd = kromosom.zadanie[index + 1].rnd;
                        kromosom.zadanie[index].zadania = kromosom.zadanie[index + 1].zadania;

                        kromosom.zadanie[index + 1].liczbaMaszyn = temp.liczbaMaszyn;
                        kromosom.zadanie[index + 1].rnd = temp.rnd;
                        kromosom.zadanie[index + 1].zadania = temp.zadania;
                    }
                    else
                    {
                        Praca temp = new Praca();
                        temp.liczbaMaszyn = kromosom.zadanie[index].liczbaMaszyn;
                        temp.rnd = kromosom.zadanie[index].rnd;
                        temp.zadania = kromosom.zadanie[index].zadania;

                        kromosom.zadanie[index].liczbaMaszyn = kromosom.zadanie[index - 1].liczbaMaszyn;
                        kromosom.zadanie[index].rnd = kromosom.zadanie[index - 1].rnd;
                        kromosom.zadanie[index].zadania = kromosom.zadanie[index - 1].zadania;

                        kromosom.zadanie[index - 1].liczbaMaszyn = temp.liczbaMaszyn;
                        kromosom.zadanie[index - 1].rnd = temp.rnd;
                        kromosom.zadanie[index - 1].zadania = temp.zadania;
                    }
                }
            }
            return kromosom;
        }

        private void positionBasedMutation_Click(object sender, RoutedEventArgs e)
        {
            mutacje = "positionBasedMutation";
            wybranaMutacja.Text = "Position Based Mutation";
        }

        public static Chromosom positionBasedMutationMethod(Chromosom ck)
        {
            int indexPierwszy;
            indexPierwszy = r.Next(0, liczbaPrac - 1);
            int indexDrugi;
            do
            {
                indexDrugi = r.Next(0, liczbaPrac);
            } while ((indexDrugi < indexPierwszy) || (indexDrugi == indexPierwszy));

            Praca[] praca = new Praca[liczbaPrac];
            for (int i = 0; i < praca.Length; i++)
            {
                praca[i] = new Praca();
                praca[i].rnd = r;
                praca[i].liczbaMaszyn = liczbaMaszyn;
                praca[i].pracaTworzenie(0);
            }
            Chromosom kromosom = new Chromosom();
            kromosom.liczbaPrac = liczbaPrac;
            kromosom.zadanie = praca;

            for (int i = 0; i < liczbaPrac; i++)
            {
                if (i == indexPierwszy)
                {
                    kromosom.zadanie[i].liczbaMaszyn = ck.zadanie[indexDrugi].liczbaMaszyn;
                    kromosom.zadanie[i].rnd = ck.zadanie[indexDrugi].rnd;
                    kromosom.zadanie[i].zadania = ck.zadanie[indexDrugi].zadania;
                }
                else if (i > indexPierwszy && i > indexDrugi)
                {
                    kromosom.zadanie[i].liczbaMaszyn = ck.zadanie[i].liczbaMaszyn;
                    kromosom.zadanie[i].rnd = ck.zadanie[i].rnd;
                    kromosom.zadanie[i].zadania = ck.zadanie[i].zadania;
                }
                else if (i > indexPierwszy)
                {
                    kromosom.zadanie[i].liczbaMaszyn = ck.zadanie[i - 1].liczbaMaszyn;
                    kromosom.zadanie[i].rnd = ck.zadanie[i - 1].rnd;
                    kromosom.zadanie[i].zadania = ck.zadanie[i - 1].zadania;
                }
                else
                {
                    kromosom.zadanie[i].liczbaMaszyn = ck.zadanie[i].liczbaMaszyn;
                    kromosom.zadanie[i].rnd = ck.zadanie[i].rnd;
                    kromosom.zadanie[i].zadania = ck.zadanie[i].zadania;
                }
            }
            return kromosom;
        }

        private void orderBasedMutation_Click(object sender, RoutedEventArgs e)
        {
            mutacje = "orderBasedMutation";
            wybranaMutacja.Text = "Order Based Mutation";
        }

        public static Chromosom orderBasedMutationMethod(Chromosom ck)
        {
            int indexPierwszy = r.Next(0, liczbaPrac);
            int indexDrugi;
            do
            {
                indexDrugi = r.Next(0, liczbaPrac);
            } while (indexDrugi == indexPierwszy);

            Chromosom kromosom = new Chromosom();
            kromosom.liczbaPrac = ck.liczbaPrac;
            kromosom.zadanie = ck.zadanie;

            Praca temp = new Praca();
            temp.liczbaMaszyn = kromosom.zadanie[indexPierwszy].liczbaMaszyn;
            temp.rnd = kromosom.zadanie[indexPierwszy].rnd;
            temp.zadania = kromosom.zadanie[indexPierwszy].zadania;

            kromosom.zadanie[indexPierwszy].liczbaMaszyn = kromosom.zadanie[indexDrugi].liczbaMaszyn;
            kromosom.zadanie[indexPierwszy].rnd = kromosom.zadanie[indexDrugi].rnd;
            kromosom.zadanie[indexPierwszy].zadania = kromosom.zadanie[indexDrugi].zadania;

            kromosom.zadanie[indexDrugi].liczbaMaszyn = temp.liczbaMaszyn;
            kromosom.zadanie[indexDrugi].rnd = temp.rnd;
            kromosom.zadanie[indexDrugi].zadania = temp.zadania;

            return kromosom;
        }

        private void onePointCrossover_Click(object sender, RoutedEventArgs e)
        {
            krzyzowanie = "onePointCrossover";
            wybraneKrzyzowanie.Text = "One Point Crossover";
        }

        public static Chromosom onePointCrossoverMethod(Chromosom osobnik1, Chromosom osobnik2)
        {
            int gdzieKrzyzowanie = r.Next(1, liczbaPrac);

            Praca[] praca = new Praca[liczbaPrac];
            for (int i = 0; i < praca.Length; i++)
            {
                praca[i] = new Praca();
                praca[i].rnd = osobnik1.zadanie[i].rnd;
                praca[i].liczbaMaszyn = osobnik1.zadanie[i].liczbaMaszyn;
                Zadanie[] zad = new Zadanie[liczbaMaszyn];
                for (int j = 0; j < zad.Length; j++)
                {
                    Zadanie temp = new Zadanie();
                    temp.nr_maszyny = osobnik1.zadanie[i].zadania[j].nr_maszyny;
                    temp.czas = osobnik1.zadanie[i].zadania[j].czas;
                    zad[j] = temp;
                }
                praca[i].zadania = zad;
            }
            Chromosom potomek = new Chromosom();
            potomek.liczbaPrac = liczbaPrac;
            potomek.zadanie = praca;

            for (int i = 0; i < liczbaPrac; i++)
            {
                if (i < gdzieKrzyzowanie)
                {
                    for (int z = 0; z < liczbaPrac; z++)
                    {
                        if (czyTaSamaPraca(potomek.zadanie[z], osobnik2.zadanie[i]))
                        {
                            Praca temp = new Praca();
                            temp.liczbaMaszyn = potomek.zadanie[z].liczbaMaszyn;
                            temp.rnd = potomek.zadanie[z].rnd;
                            temp.zadania = potomek.zadanie[z].zadania;

                            potomek.zadanie[z].liczbaMaszyn = potomek.zadanie[i].liczbaMaszyn;
                            potomek.zadanie[z].rnd = potomek.zadanie[i].rnd;
                            potomek.zadanie[z].zadania = potomek.zadanie[i].zadania;

                            potomek.zadanie[i].liczbaMaszyn = temp.liczbaMaszyn;
                            potomek.zadanie[i].rnd = temp.rnd;
                            potomek.zadanie[i].zadania = temp.zadania;
                        }
                    }
                }
            }

            return potomek;
        }

        private void twoPointCrossover_Click(object sender, RoutedEventArgs e)
        {
            krzyzowanie = "twoPointCrossover";
            wybraneKrzyzowanie.Text = "Two Point Crossover";
        }

        public static Chromosom twoPointCrossoverMethod(Chromosom osobnik1, Chromosom osobnik2)
        {
            Random random = new Random();
            int gdzieKrzyzowanieDol = 1/*random.Next(1, liczbaPrac-1)*/;
            int gdzieKrzyzowanieGora;
            do
            {
                gdzieKrzyzowanieGora = 4/*random.Next(1, liczbaPrac)*/;
            } while (gdzieKrzyzowanieGora < gdzieKrzyzowanieDol);


            Praca[] praca = new Praca[liczbaPrac];
            for (int i = 0; i < praca.Length; i++)
            {
                praca[i] = new Praca();
                praca[i].rnd = osobnik1.zadanie[i].rnd;
                praca[i].liczbaMaszyn = osobnik1.zadanie[i].liczbaMaszyn;
                Zadanie[] zad = new Zadanie[liczbaMaszyn];
                for (int j = 0; j < zad.Length; j++)
                {
                    Zadanie temp = new Zadanie();
                    temp.nr_maszyny = osobnik1.zadanie[i].zadania[j].nr_maszyny;
                    temp.czas = osobnik1.zadanie[i].zadania[j].czas;
                    zad[j] = temp;
                }
                praca[i].zadania = zad;
            }
            Chromosom potomek = new Chromosom();
            potomek.liczbaPrac = liczbaPrac;
            potomek.zadanie = praca;

            for (int i = 0; i < liczbaPrac; i++)
            {
                if (i < gdzieKrzyzowanieDol || i >= gdzieKrzyzowanieGora)
                {
                    for (int z = 0; z < liczbaPrac; z++)
                    {
                        if (czyTaSamaPraca(potomek.zadanie[z], osobnik2.zadanie[i]))
                        {
                            Praca temp = new Praca();
                            temp.liczbaMaszyn = potomek.zadanie[z].liczbaMaszyn;
                            temp.rnd = potomek.zadanie[z].rnd;
                            temp.zadania = potomek.zadanie[z].zadania;

                            potomek.zadanie[z].liczbaMaszyn = potomek.zadanie[i].liczbaMaszyn;
                            potomek.zadanie[z].rnd = potomek.zadanie[i].rnd;
                            potomek.zadanie[z].zadania = potomek.zadanie[i].zadania;

                            potomek.zadanie[i].liczbaMaszyn = temp.liczbaMaszyn;
                            potomek.zadanie[i].rnd = temp.rnd;
                            potomek.zadanie[i].zadania = temp.zadania;
                        }
                    }
                }
            }

            return potomek;
        }

        private void selekcjaTurniejowa_Click(object sender, RoutedEventArgs e)
        {
            selekcje = "selekcjaTurniejowa";
            wybraneSelekcja.Text = "Selekcja turniejowa";
        }

        private void selekcjaRankingowa_Click(object sender, RoutedEventArgs e)
        {
            selekcje = "selekcjaRankingowa";
            wybraneSelekcja.Text = "Selekcja rankingowa";
        }

        private void selekcjaElitarna_Click(object sender, RoutedEventArgs e)
        {
            selekcje = "selekcjaElitarna";
            wybraneSelekcja.Text = "Selekcja elitarna";
        }

        private void quit_Click(object sender, RoutedEventArgs e)
        {
            this.Close();
        }

        private void buttonWczytajDane_Click(object sender, RoutedEventArgs e)
        {
            liczbaOsobnikow = Int32.Parse(liczbaOsobnikowWczytaj.Text);
            liczbaPrac = Int32.Parse(liczbaPracWczytaj.Text);
            liczbaMaszyn = Int32.Parse(liczbaMaszynWczytaj.Text);
            liczbaGeneracji = Int32.Parse(liczbaGeneracjiWczytaj.Text);
            parametryWypisz.Text = "Liczba Osobnikow = " + liczbaOsobnikow + "\n" + "Liczba Prac = " + liczbaPrac + "\n" + "Liczba Maszyn = " + liczbaMaszyn + "\n" + "Liczba Generacji = " + liczbaGeneracji + "\n";
        }

        private void generujPopulacje_Click(object sender, RoutedEventArgs e)
        {
            Random random = new Random();
            Chromosom[] osobnik = new Chromosom[liczbaOsobnikow];

            for (int a = 0; a < liczbaOsobnikow; a++)
            {
                if (a == 0)
                {
                    Praca[] praca = new Praca[liczbaPrac];
                    for (int i = 0; i < praca.Length; i++)
                    {
                        praca[i] = new Praca();
                        praca[i].rnd = random;
                        praca[i].liczbaMaszyn = liczbaMaszyn;
                        praca[i].pracaTworzenie();
                    }
                    Chromosom chromek = new Chromosom();
                    chromek.liczbaPrac = liczbaPrac;
                    chromek.zadanie = praca;
                    osobnik[a] = chromek;
                    for (int i = 0; i < praca.Length; i++)
                    {
                        for (int b = 0; b < 2000; b++)
                        {
                            int rA, rB;
                            rA = random.Next(0, liczbaMaszyn);
                            rB = random.Next(0, liczbaMaszyn);
                            zamiana(ref osobnik[a].zadanie[i].zadania[rA], ref osobnik[a].zadanie[i].zadania[rB]);
                        }
                        osobnik[a].zadanie[i] = naprawa(osobnik[0].zadanie[i]);
                    }
                }
                else
                {
                    Praca[] praca = new Praca[liczbaPrac];
                    for (int i = 0; i < praca.Length; i++)
                    {
                        praca[i] = new Praca();
                        praca[i].rnd = osobnik[0].zadanie[i].rnd;
                        praca[i].liczbaMaszyn = osobnik[0].zadanie[i].liczbaMaszyn;
                        Zadanie[] zad = new Zadanie[liczbaMaszyn];
                        for (int j = 0; j < zad.Length; j++)
                        {
                            Zadanie temp = new Zadanie();
                            temp.nr_maszyny = osobnik[0].zadanie[i].zadania[j].nr_maszyny;
                            temp.czas = osobnik[0].zadanie[i].zadania[j].czas;
                            zad[j] = temp;
                        }
                        praca[i].zadania = zad;
                    }
                    Chromosom chromek = new Chromosom();
                    chromek.liczbaPrac = liczbaPrac;
                    chromek.zadanie = praca;
                    osobnik[a] = chromek;
                }
            }

            //Mieszanie prac kazdego chromosomu do stworzenie populacji
            for (int r = 1; r < liczbaOsobnikow; r++)
            {
                for (int a = 0; a < 200; a++)
                {
                    int rA, rB;
                    rA = random.Next(0, liczbaPrac);
                    rB = random.Next(0, liczbaPrac);
                    tasowanie(ref osobnik[r].zadanie[rA], ref osobnik[r].zadanie[rB]);
                }
            }

            osobnikGlowny = osobnik;
            generacja.Text = "";
        }

        private void wczytajPopulacje_Click(object sender, RoutedEventArgs e)
        {
            System.IO.StreamReader file = new System.IO.StreamReader(@"C:\Users\kowal\Desktop\generacjaStartowa.txt");

            liczbaOsobnikow = Int32.Parse(file.ReadLine());
            liczbaPrac = Int32.Parse(file.ReadLine());
            liczbaMaszyn = Int32.Parse(file.ReadLine());
            liczbaGeneracji = Int32.Parse(file.ReadLine());
            MyStaticValues.liczbaInstancji = liczbaGeneracji;

            Random random = new Random();
            Chromosom[] osobnik = new Chromosom[liczbaOsobnikow];
            for (int r = 0; r < liczbaOsobnikow; r++)
            {
                Praca[] praca = new Praca[liczbaPrac];
                for (int i = 0; i < praca.Length; i++)
                {
                    praca[i] = new Praca();
                    praca[i].rnd = random;
                    praca[i].liczbaMaszyn = liczbaMaszyn;
                    praca[i].pracaTworzenie();
                }
                Chromosom chromek = new Chromosom();
                chromek.liczbaPrac = liczbaPrac;
                chromek.zadanie = praca;
                osobnik[r] = chromek;
            }


            for (int a = 0; a < liczbaOsobnikow; a++)
            {
                for (int i = 0; i < liczbaPrac; i++)
                {
                    for (int s = 0; s < liczbaMaszyn; s++)
                    {
                        Chromosom chr = new Chromosom();
                        osobnik[a].zadanie[i].zadania[s].nr_maszyny = Int32.Parse(file.ReadLine());
                        osobnik[a].zadanie[i].zadania[s].czas = Int32.Parse(file.ReadLine());
                    }
                }
            }
            osobnikGlowny = osobnik;
            file.Close();
        }

        public void wczytajPopulacjeRodzicow(string co)
        {
            string plik = "";
            plik = co;
            System.IO.StreamReader file = new System.IO.StreamReader(@"C:\Users\kowal\Desktop\" + plik);
            //generacjaPoGeneracji.txt
            liczbaOsobnikow = Int32.Parse(file.ReadLine());
            liczbaPrac = Int32.Parse(file.ReadLine());
            liczbaMaszyn = Int32.Parse(file.ReadLine());
            liczbaGeneracji = Int32.Parse(file.ReadLine());
            MyStaticValues.liczbaInstancji = liczbaGeneracji;

            Random random = new Random();
            Chromosom[] osobnik = new Chromosom[liczbaOsobnikow];
            for (int r = 0; r < liczbaOsobnikow; r++)
            {
                Praca[] praca = new Praca[liczbaPrac];
                for (int i = 0; i < praca.Length; i++)
                {
                    praca[i] = new Praca();
                    praca[i].rnd = random;
                    praca[i].liczbaMaszyn = liczbaMaszyn;
                    praca[i].pracaTworzenie();
                }
                Chromosom chromek = new Chromosom();
                chromek.liczbaPrac = liczbaPrac;
                chromek.zadanie = praca;
                osobnik[r] = chromek;
            }


            for (int a = 0; a < liczbaOsobnikow; a++)
            {
                for (int i = 0; i < liczbaPrac; i++)
                {
                    for (int s = 0; s < liczbaMaszyn; s++)
                    {
                        Chromosom chr = new Chromosom();
                        osobnik[a].zadanie[i].zadania[s].nr_maszyny = Int32.Parse(file.ReadLine());
                        osobnik[a].zadanie[i].zadania[s].czas = Int32.Parse(file.ReadLine());
                    }
                }
            }
            osobnikGlowny = osobnik;
            file.Close();
        }

        public void zapiszPopulacjeRodzicow()
        {
            System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\kowal\Desktop\generacjapogeneracji.txt");
            file.WriteLine(liczbaOsobnikow);
            file.WriteLine(liczbaPrac);
            file.WriteLine(liczbaMaszyn);
            file.WriteLine(liczbaGeneracji);

            for (int a = 0; a < liczbaOsobnikow; a++)
            {
                for (int i = 0; i < liczbaPrac; i++)
                {
                    for (int s = 0; s < liczbaMaszyn; s++)
                    {
                        file.WriteLine(tabPoSelekcji[a].chr.zadanie[i].zadania[s].nr_maszyny);
                        file.WriteLine(tabPoSelekcji[a].chr.zadanie[i].zadania[s].czas);
                    }
                }
            }
            file.Close();
        }

        public void wyczyscZapiszPopulacjeRodzicow()
        {
            System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\kowal\Desktop\generacjapogeneracji.txt");
            file.WriteLine();
            file.Close();
        }

        private void wyczyscTekst_Click(object sender, RoutedEventArgs e)
        {
            generacja.Text = "";
            generacjaMutacji.Text = "";
        }

        private void zapiszPopulacje_Click(object sender, RoutedEventArgs e)
        {
            System.IO.StreamWriter f = new System.IO.StreamWriter(@"C:\Users\kowal\Desktop\generacjaStartowa.txt");
            f.WriteLine(liczbaOsobnikow);
            f.WriteLine(liczbaPrac);
            f.WriteLine(liczbaMaszyn);
            f.WriteLine(liczbaGeneracji);

            for (int a = 0; a < liczbaOsobnikow; a++)
            {
                for (int i = 0; i < liczbaPrac; i++)
                {
                    for (int s = 0; s < liczbaMaszyn; s++)
                    {
                        f.WriteLine(osobnikGlowny[a].zadanie[i].zadania[s].nr_maszyny);
                        f.WriteLine(osobnikGlowny[a].zadanie[i].zadania[s].czas);
                    }
                }
            }
            f.Close();
        }

        private void wyswietlPopulacje_Click(object sender, RoutedEventArgs e)
        {
            for (int a = 0; a < liczbaOsobnikow; a++)
            {
                parametryWypisz.Text = "Liczba Osobnikow = " + liczbaOsobnikow + "\n" + "Liczba Prac = " + liczbaPrac + "\n" + "Liczba Maszyn = " + liczbaMaszyn + "\n" + "Liczba Generacji = " + liczbaGeneracji + "\n";
                generacja.Text += "Chromosom nr" + (a + 1);
                generacja.Text += "\n";
                generacja.Text += "\t";
                for (int i = 0; i < liczbaMaszyn; i++)
                {
                    generacja.Text += "S" + (i + 1) + "\t";

                }
                generacja.Text += "\n";
                for (int i = 0; i < liczbaPrac; i++)
                {
                    generacja.Text += "J" + (i + 1) + "\t";
                    for (int s = 0; s < liczbaMaszyn; s++)
                    {
                        if (osobnikGlowny[a].zadanie[i].zadania[s].czas == 0)
                        {
                            generacja.Text += "- \t";
                        }
                        else
                        {
                            generacja.Text += osobnikGlowny[a].zadanie[i].zadania[s].ToString() + "\t";
                        }

                    }
                    generacja.Text += "\n";

                }
                generacja.Text += "\n";
                generacja.Text += "\n";
            }
        }

        public static void zamiana(ref Zadanie a, ref Zadanie b)
        {
            Zadanie temp = new Zadanie();
            temp.nr_maszyny = a.nr_maszyny;
            temp.czas = a.czas;
            a.nr_maszyny = b.nr_maszyny;
            a.czas = b.czas;
            b.nr_maszyny = temp.nr_maszyny;
            b.czas = temp.czas;
        }

        public void tasowanie(ref Praca praca1, ref Praca praca2)
        {

            Praca temp = new Praca();
            temp.liczbaMaszyn = praca1.liczbaMaszyn;
            temp.rnd = praca1.rnd;
            temp.zadania = praca1.zadania;

            praca1.liczbaMaszyn = praca2.liczbaMaszyn;
            praca1.rnd = praca2.rnd;
            praca1.zadania = praca2.zadania;

            praca2.liczbaMaszyn = temp.liczbaMaszyn;
            praca2.rnd = temp.rnd;
            praca2.zadania = temp.zadania;

        }

        public static bool czyTaSamaPraca(Praca pr1, Praca pr2)
        {
            bool wynik = false;
            for (int i = 0; i < liczbaMaszyn; i++)
            {
                if ((pr1.zadania[i].nr_maszyny == pr2.zadania[i].nr_maszyny) && (pr1.zadania[i].czas == pr2.zadania[i].czas))
                {
                    wynik = true;
                }
                else
                {
                    wynik = false;
                    break;
                }
            }
            return wynik;


        }

        public static Praca naprawa(Praca praca)
        {
            int count = 0;
            Praca p = new Praca();
            p.rnd = praca.rnd;
            p.liczbaMaszyn = praca.liczbaMaszyn;
            p.zadania = praca.zadania;
            for (int i = 0; i < p.zadania.Length; i++)
            {
                if (p.zadania[i].czas != 0)
                {
                    p.zadania[count].nr_maszyny = p.zadania[i].nr_maszyny;
                    p.zadania[count].czas = p.zadania[i].czas;
                    count++;
                }
            }

            while (count < p.zadania.Length)
            {
                p.zadania[count].nr_maszyny = 0;
                p.zadania[count].czas = 0;
                count++;
            }

            return p;

        }

        public int fCelu(int nr_osobnika, Chromosom[] ch)
        {
            generacja.Text = "";
            int fCelu = 0;
            int o = nr_osobnika;
            Maszyna[] maszyny = new Maszyna[liczbaMaszyn];
            for (int q = 0; q < liczbaMaszyn; q++)
            {
                maszyny[q] = new Maszyna();
                maszyny[q].czas = 0;
            }

            for (int j = 0; j < liczbaPrac; j++)
            {
                for (int z = 0; z < liczbaMaszyn; z++)
                {
                    if (ch[o].zadanie[j].zadania[z].czas == 0)
                    {
                    }
                    else if (j == 0)
                    {
                        if (z == 0)
                        {
                            maszyny[ch[o].zadanie[j].zadania[z].nr_maszyny - 1].czas += ch[o].zadanie[j].zadania[z].czas;
                        }
                        else
                        {
                            maszyny[ch[o].zadanie[j].zadania[z].nr_maszyny - 1].czas += ch[o].zadanie[j].zadania[z].czas + maszyny[ch[o].zadanie[j].zadania[z - 1].nr_maszyny - 1].czas;
                        }

                    }
                    else
                    {
                        if (z == 0)
                        {
                            maszyny[ch[o].zadanie[j].zadania[z].nr_maszyny - 1].czas += ch[o].zadanie[j].zadania[z].czas;
                        }
                        else if (maszyny[ch[o].zadanie[j].zadania[z].nr_maszyny - 1].czas < maszyny[ch[o].zadanie[j].zadania[z - 1].nr_maszyny - 1].czas)
                        {
                            maszyny[ch[o].zadanie[j].zadania[z].nr_maszyny - 1].czas = maszyny[ch[o].zadanie[j].zadania[z - 1].nr_maszyny - 1].czas + ch[o].zadanie[j].zadania[z].czas;
                        }
                        else
                        {
                            maszyny[ch[o].zadanie[j].zadania[z].nr_maszyny - 1].czas += ch[o].zadanie[j].zadania[z].czas;
                        }
                    }
                }
            }




            for (int i = 0; i < liczbaMaszyn; i++)
            {
                if (i == 0)
                {
                    fCelu = maszyny[i].czas;
                }
                else if (maszyny[i].czas > fCelu)
                {
                    fCelu = maszyny[i].czas;
                }
                else
                {
                    continue;
                }

            }
            return fCelu;
        }

        public class Maszyna
        {
            public int czas { get; set; }
        }

        public class Zadanie
        {
            public int nr_maszyny { get; set; }
            public int czas { get; set; }

            public override string ToString()
            {
                return this.nr_maszyny + "(" + czas + ") ";
            }
        }

        public class Praca
        {
            public Random rnd { get; set; }
            public int liczbaMaszyn { get; set; }
            public Zadanie[] zadania { get; set; }
            public void pracaTworzenie()
            {
                this.zadania = new Zadanie[this.liczbaMaszyn];
                for (int i = 0; i < zadania.Length; i++)
                {
                    this.zadania[i] = new Zadanie();
                    this.zadania[i].nr_maszyny = i + 1;
                    this.zadania[i].czas = rnd.Next(0, 11);
                }
            }
            public void pracaTworzenie(int a)
            {
                this.zadania = new Zadanie[this.liczbaMaszyn];
                for (int i = 0; i < zadania.Length; i++)
                {
                    this.zadania[i] = new Zadanie();
                    this.zadania[i].nr_maszyny = a;
                    this.zadania[i].czas = a;
                }
            }
        }

        public class Chromosom
        {
            public int liczbaPrac { get; set; }
            public Praca[] zadanie { get; set; }
        }

        public class Osobnik
        {
            public Chromosom chr { get; set; }
            public int funkcjaCelu { get; set; }

            public override string ToString()
            {
                return this.funkcjaCelu + " ";
            }
        }

        public class Ranking : Osobnik
        {
            public float ranga { get; set; }
            public float prawdopodobienstwo { get; set; }
            public float poczatekPrzedzialu { get; set; }
            public float koniecPrzedzialu { get; set; }
        }

        private void startAlgorytmu_Click(object sender, RoutedEventArgs e)
        {
            generacja.Text = "";
            generacjaMutacji.Text = "";
            pierwszyOsobnik = new Osobnik();
            mutacjeRandom = new Random();
            krzyzowanieRandom = new Random();
            krzyzowka = new Random();
            tablicaFunkcjiCelu = new int[liczbaGeneracji, 2];
            wyczyscZapiszFCelu();
            pierwszyNajlepszyDoPlikuCzystka();
            zapisywanieDanychDoOpisuCzystka();

            for (int generacjaInt = 1; generacjaInt < liczbaGeneracji + 1; generacjaInt++)
            {
                generacjaMutacji.Text = "";

                if (generacjaInt == 1)
                {
                    wczytajPopulacjeRodzicow("generacjaStartowa.txt");
                }
                else
                {
                    wczytajPopulacjeRodzicow("generacjaPoGeneracji.txt");
                }

                //..........................Tworzenie tablicy potomkow z mutacji bez fcelu..........................
                mutacjePotomkowie = new Chromosom[liczbaOsobnikow];
                for (int r = 0; r < liczbaOsobnikow; r++)
                {
                    Praca[] praca = new Praca[liczbaPrac];
                    for (int i = 0; i < praca.Length; i++)
                    {
                        praca[i] = new Praca();
                        praca[i].rnd = krzyzowka;
                        praca[i].liczbaMaszyn = liczbaMaszyn;
                        praca[i].pracaTworzenie(0);
                    }
                    Chromosom chromek = new Chromosom();
                    chromek.liczbaPrac = liczbaPrac;
                    chromek.zadanie = praca;

                    mutacjePotomkowie[r] = chromek;
                }

                //..........................Tworzenie tablicy potomkow z krzyzowania bez fcelu..........................
                krzyzowaniePotomkowie = new Chromosom[liczbaOsobnikow];
                for (int r = 0; r < liczbaOsobnikow; r++)
                {
                    Praca[] praca = new Praca[liczbaPrac];
                    for (int i = 0; i < praca.Length; i++)
                    {
                        praca[i] = new Praca();
                        praca[i].rnd = krzyzowka;
                        praca[i].liczbaMaszyn = liczbaMaszyn;
                        praca[i].pracaTworzenie(0);
                    }
                    Chromosom chromek = new Chromosom();
                    chromek.liczbaPrac = liczbaPrac;
                    chromek.zadanie = praca;

                    krzyzowaniePotomkowie[r] = chromek;
                }

                //..........................Tworzenie tablicy rodzicow z fcelu..........................
                tabRodzicow = new Osobnik[liczbaOsobnikow];
                for (int b = 0; b < liczbaOsobnikow; b++)
                {
                    Osobnik os = new Osobnik();
                    os.chr = osobnikGlowny[b];
                    os.funkcjaCelu = fCelu(b, osobnikGlowny);
                    tabRodzicow[b] = os;
                }
                if (generacjaInt == 1)
                {
                    tabRodzicow = tabRodzicow.OrderBy(si => si.funkcjaCelu).ToArray();
                    pierwszyOsobnik.chr = tabRodzicow[0].chr;
                    pierwszyOsobnik.funkcjaCelu = tabRodzicow[0].funkcjaCelu;
                }


                //..........................Krzyzowanie..........................
                for (int g = 0; g < liczbaOsobnikow; g++)
                {
                    if (krzyzowanieRandom.Next(0, 1001) < (int)(krzyzowanieProcent * 10))
                    {
                        int partnerKrzyzowania;
                        do
                        {
                            partnerKrzyzowania = krzyzowka.Next(0, liczbaOsobnikow);
                        } while (partnerKrzyzowania == g);
                        krzyzowania(osobnikGlowny[g], osobnikGlowny[partnerKrzyzowania]);
                    }
                }

                //..........................Naprawa krzyzowania..........................
                for (int t = 0; t < krzyzowaniePotomkowie.Length; t++)
                {
                    for (int y = 0; y < liczbaPrac; y++)
                    {
                        if (krzyzowaniePotomkowie[t].zadanie[y] != null)
                        {
                            krzyzowaniePotomkowie[t].zadanie[y] = naprawa(krzyzowaniePotomkowie[t].zadanie[y]);
                        }
                    }

                }

                //..........................Wczytywanie wczesniejszej tablicy z rodzicami..........................
                if (generacjaInt == 1)
                {
                    wczytajPopulacjeRodzicow("generacjaStartowa.txt");
                }
                else
                {
                    wczytajPopulacjeRodzicow("generacjaPoGeneracji.txt");
                }

                //..........................Mutacje..........................
                for (int f = 0; f < liczbaOsobnikow; f++)
                {
                    if (mutacjeRandom.Next(0, 1001) < (int)(mutacjeProcent * 10))
                    {
                        mutacja(osobnikGlowny[f]);
                    }
                }

                //..........................Naprawa mutacji..........................
                for (int j = 0; j < mutacjePotomkowie.Length; j++)
                {
                    for (int k = 0; k < liczbaPrac; k++)
                    {
                        mutacjePotomkowie[j].zadanie[k] = naprawa(mutacjePotomkowie[j].zadanie[k]);
                    }

                }

                //..........................Wczytywanie wczesniejszej tablicy z rodzicami..........................
                if (generacjaInt == 1)
                {
                    wczytajPopulacjeRodzicow("generacjaStartowa.txt");
                }
                else
                {
                    wczytajPopulacjeRodzicow("generacjaPoGeneracji.txt");
                }

                //..........................Tworzenie tablicy Mutacja + Krzyzowanie + Rodzice bez fcelu..........................
                nowaGeneracjaBezFCelu = new Chromosom[liczniktablicyMutacji + liczbaOsobnikow + liczniktablicyKrzyzowania];
                for (int l = 0; l < (liczniktablicyMutacji + liczbaOsobnikow + liczniktablicyKrzyzowania); l++)
                {
                    if (l < liczbaOsobnikow)
                    {
                        Chromosom os = new Chromosom();
                        os.liczbaPrac = osobnikGlowny[l].liczbaPrac;
                        os.zadanie = osobnikGlowny[l].zadanie;
                        nowaGeneracjaBezFCelu[l] = os;

                    }

                    else if (l < (liczbaOsobnikow + liczniktablicyKrzyzowania))
                    {
                        Chromosom os = new Chromosom();
                        os.liczbaPrac = krzyzowaniePotomkowie[l - liczbaOsobnikow].liczbaPrac;
                        os.zadanie = krzyzowaniePotomkowie[l - liczbaOsobnikow].zadanie;
                        nowaGeneracjaBezFCelu[l] = os;
                    }

                    else
                    {
                        Chromosom os = new Chromosom();
                        os.liczbaPrac = mutacjePotomkowie[l - liczbaOsobnikow - liczniktablicyKrzyzowania].liczbaPrac;
                        os.zadanie = mutacjePotomkowie[l - liczbaOsobnikow - liczniktablicyKrzyzowania].zadanie;
                        nowaGeneracjaBezFCelu[l] = os;
                    }
                }

                //..........................Tworzenie tablicy Mutacja + Krzyzowanie + Rodzice z fcelu..........................
                nowaGeneracja = new Osobnik[liczniktablicyMutacji + liczbaOsobnikow + liczniktablicyKrzyzowania];
                for (int m = 0; m < (liczniktablicyMutacji + liczbaOsobnikow + liczniktablicyKrzyzowania); m++)
                {
                    Osobnik o = new Osobnik();
                    o.chr = nowaGeneracjaBezFCelu[m];
                    o.funkcjaCelu = fCelu(m, nowaGeneracjaBezFCelu);
                    nowaGeneracja[m] = o;
                }

                //..........................Tworzenie tablicy dla osobnikow po selekcji..........................
                tabPoSelekcji = new Osobnik[liczbaOsobnikow];
                for (int n = 0; n < liczbaOsobnikow; n++)
                {
                    Osobnik o = new Osobnik();
                    o.chr = null;
                    o.funkcjaCelu = 0;
                    tabPoSelekcji[n] = o;
                }

                //..........................Selekcja..........................
                selekcja(nowaGeneracja);

                if (selekcje == "selekcjaElitarna")
                {
                    tabRodzicow = tabRodzicow.OrderBy(si => si.funkcjaCelu).ToArray();
                    tabPoSelekcji[0].chr = tabRodzicow[0].chr;
                    tabPoSelekcji[0].funkcjaCelu = tabRodzicow[0].funkcjaCelu;
                }

                //..........................Zapisanie najlepszej wart f celu do tablicy..........................
                if (generacjaInt == 1)
                {
                    tablicaFunkcjiCelu[(generacjaInt - 1), 0] = generacjaInt - 1;
                    int wartosc = najlepszyZNowejGeneracji(tabRodzicow).funkcjaCelu;
                    tablicaFunkcjiCelu[(generacjaInt - 1), 1] = wartosc;
                }
                else
                {
                    tablicaFunkcjiCelu[(generacjaInt - 1), 0] = generacjaInt - 1;
                    int wartosc = najlepszyZNowejGeneracji(tabPoSelekcji).funkcjaCelu;
                    tablicaFunkcjiCelu[(generacjaInt - 1), 1] = wartosc;
                }

                //..........................Czystki..........................
                zapiszPopulacjeRodzicow();
                liczniktablicyMutacji = 0;
                liczniktablicyKrzyzowania = 0;

            }
            zapiszFCelu();
            wyswietlPierwszyWCalosci();
            pierwszyNajlepszyDoPliku();
            wyswietlOstatniWCalosci();
            generacjaMutacji.Text += "Najlepszy osobnik: \n" + "wartosc funkcji celu: " + najlepszyZNowejGeneracji(tabPoSelekcji).ToString() + "\n" + "iteracja: " + iteracjaNajlepszego() + "\n" + "najlepszy chromosom: ";
            wypisywanieKolejnosciPrac(najlepszyZNowejGeneracji(tabPoSelekcji));
            zapisywanieDanychDoOpisu(najlepszyZNowejGeneracji(tabPoSelekcji));
            wyczyscZapiszPopulacjeRodzicow();

        }

        public Osobnik najlepszy()
        {
            Osobnik naj = new Osobnik();
            naj.chr = tabRodzicow[0].chr;
            naj.funkcjaCelu = fCelu(0, osobnikGlowny);
            for (int i = 1; i < liczbaOsobnikow; i++)
            {
                if (naj.funkcjaCelu > tabRodzicow[i].funkcjaCelu)
                {
                    naj.chr = tabRodzicow[i].chr;
                    naj.funkcjaCelu = fCelu(i, osobnikGlowny);
                }
            }

            return naj;
        }

        public Osobnik najlepszyZNowejGeneracji(Osobnik[] osek)
        {
            Osobnik naj = new Osobnik();
            naj.chr = osek[0].chr;
            naj.funkcjaCelu = osek[0].funkcjaCelu;
            for (int i = 1; i < osek.Length; i++)
            {
                if (naj.funkcjaCelu > osek[i].funkcjaCelu)
                {
                    naj.chr = osek[i].chr;
                    naj.funkcjaCelu = osek[i].funkcjaCelu;
                }
            }

            return naj;
        }

        public Osobnik[] najlepszyTablica(Osobnik[] duzaTab)
        {
            Osobnik[] naj = new Osobnik[liczbaOsobnikow];
            for (int n = 0; n < liczbaOsobnikow; n++)
            {
                Osobnik o = new Osobnik();
                o.chr = null;
                o.funkcjaCelu = 0;
                naj[n] = o;
            }

            Osobnik[] najSorted = new Osobnik[duzaTab.Length];
            for (int o = 0; o < duzaTab.Length; o++)
            {
                Osobnik osobniczek = new Osobnik();
                osobniczek.chr = null;
                osobniczek.funkcjaCelu = 0;
                najSorted[o] = osobniczek;
            }
            //..........................Sortowanie tablicy..........................
            najSorted = duzaTab.OrderBy(si => si.funkcjaCelu).ToArray();
            //..........................Wybor najlepszych..........................
            for (int p = 0; p < liczbaOsobnikow; p++)
            {
                naj[p] = najSorted[p];
            }

            return naj;
        }

        public void mutacja(Chromosom os)
        {

            switch (mutacje)
            {
                case "adjacentTwoJobExchange":
                    mutacjePotomkowie[liczniktablicyMutacji] = adjacentTwoJobExchangeMethod(os);
                    liczniktablicyMutacji++;
                    break;
                case "positionBasedMutation":
                    mutacjePotomkowie[liczniktablicyMutacji] = positionBasedMutationMethod(os);
                    liczniktablicyMutacji++;
                    break;
                case "orderBasedMutation":
                    mutacjePotomkowie[liczniktablicyMutacji] = orderBasedMutationMethod(os);
                    liczniktablicyMutacji++;
                    break;
                default:
                    break;
            }
        }

        public void krzyzowania(Chromosom os1, Chromosom os2)
        {
            switch (krzyzowanie)
            {
                case "onePointCrossover":
                    krzyzowaniePotomkowie[liczniktablicyKrzyzowania] = onePointCrossoverMethod(os1, os2);
                    liczniktablicyKrzyzowania++;
                    break;
                case "twoPointCrossover":
                    krzyzowaniePotomkowie[liczniktablicyKrzyzowania] = twoPointCrossoverMethod(os1, os2);
                    liczniktablicyKrzyzowania++;
                    break;
                default:
                    break;
            }
        }

        public void selekcja(Osobnik[] os)
        {

            switch (selekcje)
            {
                case "selekcjaTurniejowa":
                    tabPoSelekcji = selekcjaTurniejowaMethod(os);
                    break;
                case "selekcjaElitarna":
                    tabPoSelekcji = selekcjaElitarnaMethod(os);
                    break;
                case "selekcjaRankingowa":
                    tabPoSelekcji = selekcjaRankingowaMethod(os);
                    break;
                default:
                    break;
            }
        }

        public Osobnik[] selekcjaRankingowaMethod(Osobnik[] osek)
        {
            Random randomik = new Random();
            Ranking[] tablica = new Ranking[osek.Length];
            float prawd = 0;
            int sumaRang = 0;

            Chromosom[] tablicaDoZwrotuChromosom = new Chromosom[liczbaOsobnikow];
            for (int r = 0; r < liczbaOsobnikow; r++)
            {
                Praca[] praca = new Praca[liczbaPrac];
                for (int z = 0; z < praca.Length; z++)
                {
                    praca[z] = new Praca();
                    praca[z].rnd = krzyzowka;
                    praca[z].liczbaMaszyn = liczbaMaszyn;
                    praca[z].pracaTworzenie(0);
                }
                Chromosom chromek = new Chromosom();
                chromek.liczbaPrac = liczbaPrac;
                chromek.zadanie = praca;

                tablicaDoZwrotuChromosom[r] = chromek;
            }

            Osobnik[] tablicaDoZwrotuOsobnik = new Osobnik[liczbaOsobnikow];
            for (int b = 0; b < liczbaOsobnikow; b++)
            {
                Osobnik os = new Osobnik();
                os.chr = tablicaDoZwrotuChromosom[b];
                os.funkcjaCelu = fCelu(b, tablicaDoZwrotuChromosom);
                tablicaDoZwrotuOsobnik[b] = os;
            }

            osek = osek.OrderBy(si => si.funkcjaCelu).ToArray();

            for (int o = 0; o < osek.Length; o++)
            {
                sumaRang += osek.Length - o;
            }

            for (int i = 0; i < osek.Length; i++)
            {
                Ranking kr = new Ranking();
                kr.chr = osek[i].chr;
                kr.funkcjaCelu = osek[i].funkcjaCelu;
                kr.ranga = osek.Length - i;
                float zmienna = (float)kr.ranga / (float)sumaRang;
                zmienna *= 100;
                kr.prawdopodobienstwo = zmienna;
                if (i == 0)
                {
                    kr.poczatekPrzedzialu = 0;
                    kr.koniecPrzedzialu = kr.poczatekPrzedzialu + kr.prawdopodobienstwo;
                }
                else
                {
                    kr.poczatekPrzedzialu = tablica[i - 1].koniecPrzedzialu;
                    kr.koniecPrzedzialu = kr.poczatekPrzedzialu + kr.prawdopodobienstwo;
                }
                tablica[i] = kr;
            }

            for (int k = 0; k < liczbaOsobnikow; k++)
            {
                prawd = randomik.Next(0, (int)tablica[osek.Length - 1].koniecPrzedzialu);
                for (int l = 0; l < osek.Length; l++)
                {
                    if (tablica[l].poczatekPrzedzialu <= prawd && tablica[l].koniecPrzedzialu >= prawd)
                    {
                        tablicaDoZwrotuOsobnik[k].chr = tablica[l].chr;
                        tablicaDoZwrotuOsobnik[k].funkcjaCelu = tablica[l].funkcjaCelu;
                        break;
                    }
                }
            }

            return tablicaDoZwrotuOsobnik;
        }

        public Osobnik[] selekcjaElitarnaMethod(Osobnik[] osek)
        {
            Random randomik = new Random();
            Ranking[] tablica = new Ranking[osek.Length];
            int sumaRang = 0;

            Chromosom[] tablicaDoZwrotuChromosom = new Chromosom[liczbaOsobnikow];
            for (int r = 0; r < liczbaOsobnikow; r++)
            {
                Praca[] praca = new Praca[liczbaPrac];
                for (int z = 0; z < praca.Length; z++)
                {
                    praca[z] = new Praca();
                    praca[z].rnd = krzyzowka;
                    praca[z].liczbaMaszyn = liczbaMaszyn;
                    praca[z].pracaTworzenie(0);
                }
                Chromosom chromek = new Chromosom();
                chromek.liczbaPrac = liczbaPrac;
                chromek.zadanie = praca;

                tablicaDoZwrotuChromosom[r] = chromek;
            }

            Osobnik[] tablicaDoZwrotuOsobnik = new Osobnik[liczbaOsobnikow];
            for (int b = 0; b < liczbaOsobnikow; b++)
            {
                Osobnik os = new Osobnik();
                os.chr = tablicaDoZwrotuChromosom[b];
                os.funkcjaCelu = fCelu(b, tablicaDoZwrotuChromosom);
                tablicaDoZwrotuOsobnik[b] = os;
            }

            osek = osek.OrderBy(si => si.funkcjaCelu).ToArray();

            for (int o = 0; o < osek.Length; o++)
            {
                sumaRang += osek.Length - o;
            }

            for (int i = 0; i < osek.Length; i++)
            {
                Ranking kr = new Ranking();
                kr.chr = osek[i].chr;
                kr.funkcjaCelu = osek[i].funkcjaCelu;
                kr.ranga = osek.Length - i;
                float zmienna = (float)kr.ranga / (float)sumaRang;
                zmienna *= 100;
                kr.prawdopodobienstwo = zmienna;
                if (i == 0)
                {
                    kr.poczatekPrzedzialu = 0;
                    kr.koniecPrzedzialu = kr.poczatekPrzedzialu + kr.prawdopodobienstwo;
                }
                else
                {
                    kr.poczatekPrzedzialu = tablica[i - 1].koniecPrzedzialu;
                    kr.koniecPrzedzialu = kr.poczatekPrzedzialu + kr.prawdopodobienstwo;
                }
                tablica[i] = kr;
            }

            for (int i = 1; i < liczbaOsobnikow; i++)
            {
                int ktory = randomik.Next(0, liczbaOsobnikow);
                tablicaDoZwrotuOsobnik[i].chr = tablica[ktory].chr;
                tablicaDoZwrotuOsobnik[i].funkcjaCelu = osek[ktory].funkcjaCelu;
            }
            return tablicaDoZwrotuOsobnik;
        }

        public Osobnik[] selekcjaTurniejowaMethod(Osobnik[] osek)
        {
            int liczbaUczestnikowTurnieju = 0;
            if (liczbaOsobnikow == 5)
            {
                liczbaUczestnikowTurnieju = liczbaOsobnikow / 2;
            }
            else if (liczbaOsobnikow == 10)
            {
                liczbaUczestnikowTurnieju = liczbaOsobnikow / 5;
            }
            else if (liczbaOsobnikow == 20)
            {
                liczbaUczestnikowTurnieju = liczbaOsobnikow / 4;
            }
            else if (liczbaOsobnikow == 40)
            {
                liczbaUczestnikowTurnieju = liczbaOsobnikow / 10;
            }
            else if (liczbaOsobnikow == 80)
            {
                liczbaUczestnikowTurnieju = liczbaOsobnikow / 15;
            }
            else if (liczbaOsobnikow == 160)
            {
                liczbaUczestnikowTurnieju = liczbaOsobnikow / 20;
            }
            else
            {
                liczbaUczestnikowTurnieju = liczbaOsobnikow / 4;
            }


            Random randomik = new Random();
            Ranking[] tablica = new Ranking[osek.Length];
            float prawd = 0;
            int sumaRang = 0;

            Chromosom[] tablicaDoZwrotuChromosom = new Chromosom[liczbaOsobnikow];
            for (int r = 0; r < liczbaOsobnikow; r++)
            {
                Praca[] praca = new Praca[liczbaPrac];
                for (int z = 0; z < praca.Length; z++)
                {
                    praca[z] = new Praca();
                    praca[z].rnd = krzyzowka;
                    praca[z].liczbaMaszyn = liczbaMaszyn;
                    praca[z].pracaTworzenie(0);
                }
                Chromosom chromek = new Chromosom();
                chromek.liczbaPrac = liczbaPrac;
                chromek.zadanie = praca;

                tablicaDoZwrotuChromosom[r] = chromek;
            }

            Osobnik[] tablicaDoZwrotuOsobnik = new Osobnik[liczbaOsobnikow];
            for (int b = 0; b < liczbaOsobnikow; b++)
            {
                Osobnik os = new Osobnik();
                os.chr = tablicaDoZwrotuChromosom[b];
                os.funkcjaCelu = fCelu(b, tablicaDoZwrotuChromosom);
                tablicaDoZwrotuOsobnik[b] = os;
            }

            osek = osek.OrderBy(si => si.funkcjaCelu).ToArray();

            for (int o = 0; o < osek.Length; o++)
            {
                sumaRang += osek.Length - o;
            }

            for (int i = 0; i < osek.Length; i++)
            {
                Ranking kr = new Ranking();
                kr.chr = osek[i].chr;
                kr.funkcjaCelu = osek[i].funkcjaCelu;
                kr.ranga = osek.Length - i;
                float zmienna = (float)kr.ranga / (float)sumaRang;
                zmienna *= 100;
                kr.prawdopodobienstwo = zmienna;
                if (i == 0)
                {
                    kr.poczatekPrzedzialu = 0;
                    kr.koniecPrzedzialu = kr.poczatekPrzedzialu + kr.prawdopodobienstwo;
                }
                else
                {
                    kr.poczatekPrzedzialu = tablica[i - 1].koniecPrzedzialu;
                    kr.koniecPrzedzialu = kr.poczatekPrzedzialu + kr.prawdopodobienstwo;
                }
                tablica[i] = kr;
            }

            //----------------------------------------------------------------------------

            for (int k = 0; k < liczbaOsobnikow; k++)
            {
                Chromosom[] tablicaTurniejowaChromosom = new Chromosom[liczbaUczestnikowTurnieju];
                for (int r = 0; r < liczbaUczestnikowTurnieju; r++)
                {
                    Praca[] praca = new Praca[liczbaPrac];
                    for (int z = 0; z < praca.Length; z++)
                    {
                        praca[z] = new Praca();
                        praca[z].rnd = krzyzowka;
                        praca[z].liczbaMaszyn = liczbaMaszyn;
                        praca[z].pracaTworzenie(0);
                    }
                    Chromosom chromek = new Chromosom();
                    chromek.liczbaPrac = liczbaPrac;
                    chromek.zadanie = praca;

                    tablicaTurniejowaChromosom[r] = chromek;
                }

                Osobnik[] tablicaTurniejowaOsobnik = new Osobnik[liczbaUczestnikowTurnieju];
                for (int b = 0; b < liczbaUczestnikowTurnieju; b++)
                {
                    Osobnik os = new Osobnik();
                    os.chr = tablicaTurniejowaChromosom[b];
                    os.funkcjaCelu = fCelu(b, tablicaTurniejowaChromosom);
                    tablicaTurniejowaOsobnik[b] = os;
                }
                for (int r = 0; r < liczbaUczestnikowTurnieju; r++)
                {
                    int bryg = randomik.Next(0, liczbaOsobnikow);
                    tablicaTurniejowaOsobnik[r].chr = tablica[bryg].chr;
                    tablicaTurniejowaOsobnik[r].funkcjaCelu = tablica[bryg].funkcjaCelu;
                }
                tablicaTurniejowaOsobnik = tablicaTurniejowaOsobnik.OrderBy(si => si.funkcjaCelu).ToArray();
                tablicaDoZwrotuOsobnik[k] = tablicaTurniejowaOsobnik[0];
            }

            return tablicaDoZwrotuOsobnik;
        }

        public void zapiszFCelu()
        {
            System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\kowal\Desktop\daneDoWykresu.txt");

            for (int a = 0; a < liczbaGeneracji; a++)
            {

                file.WriteLine(tablicaFunkcjiCelu[a, 0]);
                file.WriteLine(tablicaFunkcjiCelu[a, 1]);
            }
            file.Close();
        }

        public void wyczyscZapiszFCelu()
        {
            System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\kowal\Desktop\daneDoWykresu.txt");
            file.WriteLine();
            file.Close();
        }

        public void wypisywanieKolejnosciPrac(Osobnik os)
        {
            generacjaMutacji.Text += "\n[";
            for (int i = 0; i < liczbaPrac; i++)
            {
                for (int j = 0; j < liczbaPrac; j++)
                {
                    if (czyTaSamaPraca(os.chr.zadanie[i], pierwszyOsobnik.chr.zadanie[j]))
                    {
                        if (i == (liczbaPrac - 1))
                        {
                            generacjaMutacji.Text += "J" + (j + 1) + "]";
                        }
                        else
                        {
                            generacjaMutacji.Text += "J" + (j + 1) + "; ";
                        }
                    }
                }
            }
        }

        public void zapisywanieDanychDoOpisu(Osobnik os)
        {
            System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\kowal\Desktop\daneDoOpisu.txt");
            file.WriteLine("Najlepszy osobnik:");
            file.WriteLine("wartosc funkcji celu: " + najlepszyZNowejGeneracji(tabPoSelekcji).ToString());
            file.WriteLine("iteracja: " + iteracjaNajlepszego());
            file.WriteLine("najlepszy chromosom:");
            file.Write("[");
            for (int i = 0; i < liczbaPrac; i++)
            {
                for (int j = 0; j < liczbaPrac; j++)
                {
                    if (czyTaSamaPraca(os.chr.zadanie[i], pierwszyOsobnik.chr.zadanie[j]))
                    {
                        if (i == (liczbaPrac - 1))
                        {
                            file.Write("J" + (j + 1) + "]");
                        }
                        else
                        {
                            file.Write("J" + (j + 1) + "; ");
                        }
                    }
                }
            }
            file.Close();
        }

        public void pierwszyNajlepszyDoPliku()
        {
            System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\kowal\Desktop\tabelaPierszegoNajlepszegoOsobnika.txt");
            file.WriteLine("Chromosom najlepiej przystosowany w pierwszej iteracji");
            file.WriteLine();
            file.Write("\t");
            for (int i = 0; i < liczbaMaszyn; i++)
            {
                file.Write("S" + (i + 1) + "\t");

            }
            file.WriteLine();
            for (int i = 0; i < liczbaPrac; i++)
            {
                file.Write("J" + (i + 1) + "\t");
                for (int s = 0; s < liczbaMaszyn; s++)
                {
                    if (pierwszyOsobnik.chr.zadanie[i].zadania[s].czas == 0)
                    {
                        file.Write("- \t");
                    }
                    else
                    {
                        file.Write(pierwszyOsobnik.chr.zadanie[i].zadania[s].ToString() + "\t");
                    }

                }
                file.WriteLine();

            }
            file.WriteLine();
            file.WriteLine();
            file.Close();
        }

        public void pierwszyNajlepszyDoPlikuCzystka()
        {
            System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\kowal\Desktop\tabelaPierszegoNajlepszegoOsobnika.txt");
            file.WriteLine();
            file.Close();
        }

        public void zapisywanieDanychDoOpisuCzystka()
        {

            System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\kowal\Desktop\daneDoOpisu.txt");
            file.WriteLine();
            file.Close();
        }

        public int iteracjaNajlepszego()
        {
            int indexNajlepszy = 0;
            int wartFCeluNajlepsza = pierwszyOsobnik.funkcjaCelu;
            System.IO.StreamReader file = new System.IO.StreamReader(@"C:\Users\kowal\Desktop\daneDoWykresu.txt");
            int[,] tabWczytana = new int[liczbaGeneracji, 2];
            for (int i = 0; i < liczbaGeneracji; i++)
            {
                tabWczytana[i, 0] = Int32.Parse(file.ReadLine());
                tabWczytana[i, 1] = Int32.Parse(file.ReadLine());
            }

            for (int j = 0; j < liczbaGeneracji; j++)
            {
                if (tabWczytana[j, 1] < wartFCeluNajlepsza)
                {
                    wartFCeluNajlepsza = tabWczytana[j, 1];
                    indexNajlepszy = tabWczytana[j, 0];
                }
            }

            file.Close();
            return indexNajlepszy;
        }

        public void wyswietlPierwszyWCalosci()
        {
            generacja.Text += "Chromosom najlepiej przystosowany w pierwszej iteracji";
            generacja.Text += "\n";
            generacja.Text += "\t";
            for (int i = 0; i < liczbaMaszyn; i++)
            {
                generacja.Text += "S" + (i + 1) + "\t";

            }
            generacja.Text += "\n";
            for (int i = 0; i < liczbaPrac; i++)
            {
                generacja.Text += "J" + (i + 1) + "\t";
                for (int s = 0; s < liczbaMaszyn; s++)
                {
                    if (pierwszyOsobnik.chr.zadanie[i].zadania[s].czas == 0)
                    {
                        generacja.Text += "- \t";
                    }
                    else
                    {
                        generacja.Text += pierwszyOsobnik.chr.zadanie[i].zadania[s].ToString() + "\t";
                    }

                }
                generacja.Text += "\n";

            }
            generacja.Text += "\n";
            generacja.Text += "\n";

        }

        public void wyswietlOstatniWCalosci()
        {
            generacja.Text += "Chromosom najlepiej przystosowany";
            generacja.Text += "\n";
            generacja.Text += "\t";
            for (int i = 0; i < liczbaMaszyn; i++)
            {
                generacja.Text += "S" + (i + 1) + "\t";

            }
            generacja.Text += "\n";
            for (int i = 0; i < liczbaPrac; i++)
            {
                generacja.Text += "J" + (i + 1) + "\t";
                for (int s = 0; s < liczbaMaszyn; s++)
                {
                    if (najlepszyZNowejGeneracji(tabPoSelekcji).chr.zadanie[i].zadania[s].czas == 0)
                    {
                        generacja.Text += "- \t";
                    }
                    else
                    {
                        generacja.Text += najlepszyZNowejGeneracji(tabPoSelekcji).chr.zadanie[i].zadania[s].ToString() + "\t";
                    }

                }
                generacja.Text += "\n";

            }
            generacja.Text += "\n";
            generacja.Text += "\n";

        }

        private void rysuj_Click(object sender, RoutedEventArgs e)
        {

        }

        private void krzyzowanieProcentWczytaj_Click(object sender, RoutedEventArgs e)
        {
            krzyzowanieProcent = float.Parse(krzyzowanieProcenty.Text, System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
        }

        private void mutacjaProcentWczytaj_Click(object sender, RoutedEventArgs e)
        {
            mutacjeProcent = float.Parse(mutacjeProcenty.Text, System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
        }
    }
}