import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Random;

public class Funkcije {

    // Funkcija racuna dobrotu jedinke (int jedinka) prema funkciji prikaznoj u tekstu zadatka
    // Dozvoljene ulazne vrijednosti su u otvorenom intervalu [0, 1023]
    // Funkcija vraca -1 ako je zadana nedozvoljena vrijednost
    public static double dobrota(int jedinka) {

        if (jedinka < 0 || jedinka >= 1024) {
            return -1;
        }

        if (jedinka >= 0 && jedinka < 30) {
            return 60.0;
        }
        else if (jedinka >= 30 && jedinka < 90) {
            return (double)jedinka + 30.0;
        }
        else if (jedinka >= 90 && jedinka < 120) {
            return 120.0;
        }
        else if (jedinka >= 120 && jedinka < 210) {
            return -0.83333 * (double)jedinka + 220;
        }
        else if (jedinka >= 210 && jedinka < 270) {
            return 1.75 * (double)jedinka - 322.5;
        }
        else if (jedinka >= 270 && jedinka < 300) {
            return 150.0;
        }
        else if (jedinka >= 300 && jedinka < 360) {
            return 2.0 * (double)jedinka - 450;
        }
        else if (jedinka >= 360 && jedinka < 510) {
            return -1.8 * (double)jedinka + 918;
        }
        else if (jedinka >= 510 && jedinka < 630) {
            return 1.5 * (double)jedinka - 765;
        }
        else if (jedinka >= 630 && jedinka < 720) {
            return -1.33333 * (double)jedinka + 1020;
        }
        else if (jedinka >= 720 && jedinka < 750) {
            return 60.0;
        }
        else if (jedinka >= 750 && jedinka < 870) {
            return 1.5 * (double)jedinka - 1065;
        }
        else if (jedinka >= 870 && jedinka < 960) {
            return -2.66667 * (double)jedinka + 2560;
        }
        else {
            return 0;
        }
    }

    // funkcija stvara populaciju od 20 jedinki nasumično generiranih brojeva u intervalu [0, 1023]
    public static List<Integer> stvoriPopulaciju(int vel_pop) {
        List<Integer> populacija = new ArrayList<>();

        for (int i = 0; i < vel_pop; i++) {
            populacija.add(new Random().nextInt(1023));
        }

        return populacija;
    }

    // jednostavka selekcija - odabir roditelja čija je vjerojatnost selekcije proporcionalna njihovoj dobroti
    // funkcija racuna dobrotu svake jedinke i odbacuje iz populacije one jednike kod kojih je omjer
    // dobrota jedinke / dobrota cijele populacije najmanji
    // funkcija vraća 10 najboljih jedinki nove populacije
    public static List<Integer> jednostavnaSelekcija(List<Integer> populacija) {

        populacija.sort((j1,j2)->Double.compare(dobrota(j1),dobrota(j2)));
        int polaPopulacije=populacija.size()/2;

        for(int i=0;i<polaPopulacije;i++){
            populacija.remove(0);
        }

        return populacija;
    }

    // funkcija vraća slučajna dva roditelja iz populacije
    public static List<Integer> vratiDvaSlucajnaRoditelja(List<Integer> populacija) {
        List<Integer> dvaSlucajnaRoditelja = new ArrayList<>();
        int index1 = 0, index2 = 0;

        do {
            index1 = new Random().nextInt(populacija.size());
            index2 = new Random().nextInt(populacija.size());
        } while (index1 == index2);

        dvaSlucajnaRoditelja.add(populacija.get(index1));
        dvaSlucajnaRoditelja.add(populacija.get(index2));

        return dvaSlucajnaRoditelja;
    }

    // funkcija pretvara Integer u binarni broj i svaku znamenku stavlja u Integer polje
    public static Integer[] pretvoriIntegerUbinarniBroj(Integer broj) {
        List<Integer> pomocnaLista = new ArrayList<>();
        List<Integer> binarnaLista = new ArrayList<>();

        int bit = 0, brojDodatnihNula = 0;

        while (broj > 0) {
            bit = broj % 2;
            pomocnaLista.add(bit);
            broj /= 2;
        }

        brojDodatnihNula = 10 - pomocnaLista.size();
        if (brojDodatnihNula != 0) {
            for (int i = 0; i < brojDodatnihNula; i++) {
                pomocnaLista.add(0);
            }
        }

        for (int i = pomocnaLista.size() - 1; i >= 0; i--) {
            binarnaLista.add(pomocnaLista.get(i));
        }

        Integer[] binarniBroj = binarnaLista.toArray(new Integer[10]);

        return binarniBroj;
    }

    // funkcija pretvara binarni broj u Integer
    public static Integer pretvoriBinarniBrojUinteger(Integer[] broj) {
        Integer intBroj = 0;

        for (int i = broj.length - 1, j = 0; i >= 0; i--, j++) {
            intBroj = (int) (intBroj + broj[i]*Math.pow(2, j));
        }

        return intBroj;
    }

    // funkcija koja vraca true ako je vjerojatnost krizanja 90% ili true ako je vjerojatnost mutacije 1%
    public static boolean izracunajVjerojatnost(Double vjerojatnost) {
        Double broj = new Random().nextDouble();

        if (broj < vjerojatnost) {
            return true;
        }

        return false;
    }

    // funkcija racuna maksimalnu dobrotu populacije
    public static Double maksimalnaDobrotaPopulacije(List<Integer> populacija){
        Double maxDobrota = dobrota(populacija.stream().max(Comparator.comparingDouble((jedinka)->dobrota(jedinka))).get());

        return maxDobrota;
    }

    // funkcija racuna prosjecnu vrijednost dobrote populacije
    public static Double prosjecnaVrijednostDobrotePopulacije(List<Integer> populacija){
        Double prosjekDobrote = populacija.stream().mapToDouble((jedinka)->dobrota(jedinka)).average().orElse(0);

        return prosjekDobrote;
    }

    // funkcija vraća najbolju jedinku populacije (elitizam)
    public static Integer najboljaJedinkaPopulacije(List<Integer> populacija) {

        populacija.sort((j1, j2) -> Double.compare(dobrota(j1), dobrota(j2)));

        return populacija.get(populacija.size() - 1);
    }

    // funkcija kriza random roditelje i stvara djecu te vraca novu populaciju
    public static List<Integer> populacijaNakonKrizanjaImutacije(List<Integer> populacija, Double Pc, Double Pm) {
        List<Integer> novaPopulacija = new ArrayList<>();
        List<Integer> djeca = new ArrayList<>();
        int brojacIsteDjece=0;
        for (int k = 0; k < populacija.size(); k++) {
            boolean imaDuplikata = false;

            List<Integer> roditelji = vratiDvaSlucajnaRoditelja(populacija);

            Integer intRoditelj1 = roditelji.get(0);
            Integer intRoditelj2 = roditelji.get(1);

            Integer[] roditelj1 = pretvoriIntegerUbinarniBroj(intRoditelj1);
            Integer[] roditelj2 = pretvoriIntegerUbinarniBroj(intRoditelj2);
            Integer[] dijete = new Integer[10] ;
            Integer intDijete = 0;

            for (int i = 0; i < dijete.length; i++) {
                dijete[i] = 0;
            }

            if (izracunajVjerojatnost(Pc)) {
                for (int i = 0; i < roditelj1.length; i++) {
                    if (roditelj1[i] == roditelj2[i]) {
                        dijete[i] = roditelj1[i];
                    }
                    else {
                        if (new Random().nextBoolean()) {
                            dijete[i] = roditelj1[i];
                        }
                        else {
                            dijete[i] = roditelj2[i];
                        }
                    }
                }
            }

            roditelji.clear();
            intDijete = pretvoriBinarniBrojUinteger(dijete);

            // provjeravam da li već postoji to dijete, ako da, ponavljam križanje, if je tu da bi se spriječila beskonačna petlja ako se uvijek dobivaju ista dijeca
            if(brojacIsteDjece<=500) {
                for (int j = 0; j < djeca.size(); j++) {
                    if (djeca.get(j).equals(intDijete)) {
                        brojacIsteDjece++;
                        imaDuplikata = true;
                        k--;
                        break;
                    }
                }
            }

            // ako dobiveno dijete ne postoji, dodajem ga u populaciju
            if (imaDuplikata == false) {
                brojacIsteDjece=0;
                djeca.add(intDijete);
            }
        }

        novaPopulacija.addAll(djeca);
        novaPopulacija.addAll(populacija);

        // sortiramo novu populaciju po vrijednosti dobrote, zadnja jedinka u novoj populaciji je najbolja
        novaPopulacija.sort((j1, j2) -> Double.compare(dobrota(j1), dobrota(j2)));

        // napravi mutaciju nad svim jedinkama osim nad najboljom (zadnjom u populaciji) -> elitizam, čuvamo najbolju jedinku
        for (int i = 0; i < novaPopulacija.size()-1; i++) {
            Integer[] jedinka = pretvoriIntegerUbinarniBroj(novaPopulacija.get(i));
            for (int j = 0; j < jedinka.length; j++) {
                if (izracunajVjerojatnost(Pm)) {
                    if (jedinka[j] == 1) {
                        jedinka[j] = 0;
                    }
                    else {
                        jedinka[j] = 1;
                    }
                }
            }
        }

        return novaPopulacija;
    }

}