package edu.ktu.ds.lab3.demo;

import edu.ktu.ds.lab3.gui.ValidationException;
import edu.ktu.ds.lab3.utils.HashType;
import edu.ktu.ds.lab3.utils.Ks;
import edu.ktu.ds.lab3.utils.ParsableHashMap;
import edu.ktu.ds.lab3.utils.ParsableMap;

import java.util.*;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Semaphore;
import java.util.stream.Stream;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.io.IOException;

/**
 * @author eimutis
 */
public class SimpleBenchmark {

    public static final String FINISH_COMMAND = "                               ";
    private static final ResourceBundle MESSAGES = ResourceBundle.getBundle("edu.ktu.ds.lab3.gui.messages");

    private final Timekeeper timekeeper;

    private final String[] BENCHMARK_NAMES = {"Ktu contains", "Java contains", "Ktu rem", "Java rem", "get0.75", "get0.25"};
    private final int[] COUNTS = {10000, 20000, 40000, 80000};

    private final ParsableMap<String, Car> carsMap
            = new ParsableHashMap<>(String::new, Car::new, 10, 0.75f, HashType.DIVISION);
    private final ParsableMap<String, Car> carsMap2
            = new ParsableHashMap<>(String::new, Car::new, 10, 0.25f, HashType.DIVISION);
    private final java.util.HashMap<String, Car> carsMap3
            = new java.util.HashMap<String, Car>();
    private final Queue<String> chainsSizes = new LinkedList<>();

   // private final ParsableMap<Integer, String> wordsMap = new ParsableHashMap<>(Integer::new, String::new);

    /**
     * For console benchmark
     */
    public SimpleBenchmark() {
        timekeeper = new Timekeeper(COUNTS);
    }

    /**
     * For Gui benchmark
     *
     * @param resultsLogger
     * @param semaphore
     */
    public SimpleBenchmark(BlockingQueue<String> resultsLogger, Semaphore semaphore) {
        semaphore.release();
        timekeeper = new Timekeeper(COUNTS, resultsLogger, semaphore);
    }

    public static void main(String[] args) {
        executeTest();
    }

    public static void executeTest() {
        // suvienodiname skaičių formatus pagal LT lokalę (10-ainis kablelis)
        Locale.setDefault(new Locale("LT"));
        Ks.out("Greitaveikos tyrimas:\n");
        new SimpleBenchmark().startBenchmark();
    }

    public void startBenchmark() {
        try {
            benchmark();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } catch (Exception ex) {
            ex.printStackTrace(System.out);
        }
    }

    public void benchmark() throws InterruptedException {
        try {
            chainsSizes.add(MESSAGES.getString("maxChainLength"));
            chainsSizes.add("   kiekis      " + BENCHMARK_NAMES[0] + "   " + BENCHMARK_NAMES[1]);
            for (int k : COUNTS) {
                String[] words;
                try (Stream<String> stream1 = Files.lines(Paths.get("C:\\Users\\juskuc\\Desktop\\Lab3_MaisosLenteles\\data\\zodynas.txt"))) {

                    words = stream1
                            .toArray(String[]::new);


                } catch (IOException e) {
                    e.printStackTrace();
                }


                Car[] carsArray = CarsGenerator.generateShuffleCars(k);
                String[] carsIdsArray = CarsGenerator.generateShuffleIds(k);
                carsMap.clear();
                carsMap2.clear();
                carsMap3.clear();
                timekeeper.startAfterPause();
                timekeeper.start();

                for (int i = 0; i < k; i++) {
                    carsMap.contains(carsIdsArray[i]);
                }
                timekeeper.finish(BENCHMARK_NAMES[0], k);
                String str = "   " + k + "          " + carsMap.getMaxChainSize();
                for (int i = 0; i < k; i++) {
                     carsMap.contains(carsIdsArray[i]);
                }
                timekeeper.finish(BENCHMARK_NAMES[1], k);

                str += "         " + carsMap2.getMaxChainSize();
                chainsSizes.add(str);

                for (int i = 0; i < k; i++) {
                    carsMap.remove(carsIdsArray[i]);
                }
                timekeeper.finish(BENCHMARK_NAMES[2], k);

                for (int i = 0; i < k; i++) {
                    carsMap3.remove(carsIdsArray[i]);
                }
                timekeeper.finish(BENCHMARK_NAMES[3], k);

                Arrays.stream(carsIdsArray).forEach(carsMap::get);
                timekeeper.finish(BENCHMARK_NAMES[4], k);

                Arrays.stream(carsIdsArray).forEach(carsMap2::get);
                timekeeper.finish(BENCHMARK_NAMES[5], k);
                timekeeper.seriesFinish();
            }

            StringBuilder sb = new StringBuilder();
            chainsSizes.forEach(p -> sb.append(p).append(System.lineSeparator()));
            timekeeper.logResult(sb.toString());
            timekeeper.logResult(FINISH_COMMAND);
        } catch (ValidationException e) {
            timekeeper.logResult(e.getMessage());
        }
    }
}
package edu.ktu.ds.lab3.demo;

import edu.ktu.ds.lab3.utils.Ks;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Semaphore;

/**
 * @author eimutis
 */
public class Timekeeper {

    private int[] tyrimoImtis;
    private long startTime;
    private final long startTimeTot;
    private double sumTime;
    private int tyrimoInd;
    private int kiekioInd;
    private int tyrimųN;
    private final int tyrimųNmax = 30;
    private final int kiekioN;
    private double[][] laikai;
    private String tyrimųEilutė;
    private final String kiekioFormatas = "%8d(%2d) ";
    private String header = "  kiekis(*k) ";

    private final BlockingQueue<String> resultsLogger;
    private final Semaphore semaphore;

    /**
     * For console benchmark
     * @param kiekiai
     */
    public Timekeeper(int[] kiekiai) {
        this(kiekiai, null, null);
    }

    /**
     * For Gui benchmark
     *
     * @param kiekiai
     * @param resultsLogger
     * @param semaphore
     */
    public Timekeeper(int[] kiekiai, BlockingQueue<String> resultsLogger, Semaphore semaphore) {
        this.tyrimoImtis = kiekiai;
        this.resultsLogger = resultsLogger;
        this.semaphore = semaphore;
        kiekioN = tyrimoImtis.length;
        laikai = new double[kiekioN][tyrimųNmax];
        startTimeTot = System.nanoTime();
    }

    public void start() throws InterruptedException {
        tyrimoInd = 0;
        if (kiekioInd >= kiekioN) {
            logResult("Duomenų kiekis keičiamas daugiau kartų nei buvo planuota");
            // System.exit(0);
        }
        tyrimųEilutė = String.format(kiekioFormatas, tyrimoImtis[kiekioInd],
                tyrimoImtis[kiekioInd] / tyrimoImtis[0]);
        Runtime.getRuntime().gc();
        Runtime.getRuntime().gc();
        Runtime.getRuntime().gc();
        startTime = System.nanoTime();
    }

    public void startAfterPause() {
        Runtime.getRuntime().gc();
        Runtime.getRuntime().gc();
        Runtime.getRuntime().gc();
        startTime = System.nanoTime();
    }

    public void finish(String vardas, int k) throws InterruptedException {
        double executionTime = ((System.nanoTime() - startTime) / 1e9) / k * 10000;
        sumTime += executionTime;
        if (startTime == 0) {
            logResult("Metodas finish panaudotas be start metodo !!!\n");
            //   System.exit(0);
        }
        if (kiekioInd == 0) {
            header += String.format("%9s ", vardas);
        }
        if (tyrimoInd >= tyrimųNmax) {
            logResult("Jau atlikta daugiau tyrimų nei numatyta  !!!\n");
            //  System.exit(0);
        }
        laikai[kiekioInd][tyrimoInd++] = executionTime;
        tyrimųEilutė += String.format("%9.4f ", executionTime);
        Runtime.getRuntime().gc();
        Runtime.getRuntime().gc();
        Runtime.getRuntime().gc();
        startTime = System.nanoTime();
    }

    public void seriesFinish() throws InterruptedException {
        if (kiekioInd == 0) {
            logResult(header + "\n");
        }
        logResult(tyrimųEilutė + "\n");
        kiekioInd++;
        tyrimųN = tyrimoInd;
        if (kiekioInd == kiekioN) {
            summary();
        }
    }

    private void summary() throws InterruptedException {
        StringBuilder sb = new StringBuilder();
        double totTime = (System.nanoTime() - startTimeTot) / 1e9;
        sb.append(String.format("       Bendras tyrimo laikas %8.3f sekundžių", totTime)).append("\n");
        sb.append(String.format("    Išmatuotas tyrimo laikas %8.3f sekundžių", sumTime)).append("\n");
        sb.append(String.format("    t.y. %5.1f%% sudaro pagalbiniai darbai",
                (totTime - sumTime) / totTime * 100)).append("\n");
        sb.append("\n");
        sb.append("Normalizuota (santykinė) laikų lentelė\n");
        sb.append(header).append("\n");
        double d1 = laikai[0][0];
        for (int i = 0; i < kiekioN; i++) {
            tyrimųEilutė = String.format(kiekioFormatas, tyrimoImtis[i],
                    tyrimoImtis[i] / tyrimoImtis[0]);
            for (int j = 0; j < tyrimųN; j++) {
                tyrimųEilutė += String.format("%9.2f ", laikai[i][j] / d1);
            }
            sb.append(tyrimųEilutė).append("\n");
        }
        sb.append("\n");
        logResult(sb.toString());
    }

    public void logResult(String result) throws InterruptedException {
        if (resultsLogger != null && semaphore != null) {
            resultsLogger.put(result);
            semaphore.acquire();
        } else {
            Ks.out(result);
        }
    }
}