import java.util.*;
import java.util.Random;
import java.util.HashMap;
import java.util.Collections;

/**
 * Trida simuluje tazeni ciselnych her
 * 
 * @author Jirka Krhanek
 * @version 2006-01-30
 */
public class Generator
{
    // instancni promenne
    private Random generovaneCislo;
    private int tazeneCislo;
    // pole
    private int[] tazeneCisla;
    private int kolik, zkolika, kolikrat;
    private String vypis;
    // slovnik typu HashMap - HashMap je genericka trida
    private HashMap<Integer,Integer> slovnik;
    
/**
 * Konstruktor pro vytvoreni objektu Generator
 * 
 * @param kolik kolik cisel bude tazeno
 * @param zkolika z kolika cisel bude tazeno
 */
    public Generator(int kolik, int zkolika)
    {
        // inicializace promennych
        this.kolik = kolik;
        this.zkolika = zkolika;
        kolikrat = 0;
        // vytvoreni noveho objektu Random()
        generovaneCislo = new Random();
        // inicializace velikosti pole
        tazeneCisla = new int[kolik];
        vypis = "";
        // vytvoreni noveho slovniku
        slovnik = new HashMap<Integer,Integer>(zkolika);

    }

/**
 * Metoda vygeneruje pseudonahodne cislo
 * 
 */
    public void vygenerovatCislo()
    {
        // generovani pseudonahodneho cisla v rozsahu podle parametru a zvetsene o 1, aby nebyla generovana 0
        int x = generovaneCislo.nextInt(zkolika) + 1;
        // pomoci metody setTazeneCislo je vygenerovane cislo predano do promene tazeneCislo
        setTazeneCislo(x);
    }

/**
 * Metoda nastavi tazene cislo 
 * 
 * @param hodnota hodnota nastavuje tazene cislo
 */
    public void setTazeneCislo(int hodnota)
    {
        // prirazeni parametru promenne
        tazeneCislo = hodnota;
    }
/**
 * Metoda ziska tazene cislo
 * @return tazene cislo
 */
    public int getTazeneCislo()
    {
        // vraci tazeneCislo
        return tazeneCislo;
    }

 /**
 * Metoda vygeneruje potrebny pocet cisel
 */
    public void vygenerovatCisla()
    {
        // deklarace promenne typu boolean
        boolean next;
        // pro vsechna tazena cisla
        for(int i = 0; i < kolik; i++)
        {          
            do
            {
                next = false;
                // vygenerujeme cislo
                vygenerovatCislo();
                // pro vsechna zatim vytazena cisla
                for(int n = 0; n < i; n++)
                {
                    // zjistime jestli uz nahodou cislo neni v poli vytazenych cisel
                    if(tazeneCisla[n]==tazeneCislo)
                    {
                        // pokud ano, nastavime next na true a vyskocime z cyklu
                        next = true;
                        break;
                    }
                }
            }
            // vykonava se dokud se nenajde jeste netazene cislo
            while(next);        
            // vytazene cislo na vyhovuje, tak ho priradime do pole tazenych cisel na spravnou pozici
            tazeneCisla[i] = tazeneCislo;   
        }
        // nakonec pole setridime podle velikosti cisel
        Arrays.sort(tazeneCisla);        
    }

 /**
 * Metoda vypise jeden tah
 *
 * @return vraci se vypis tazenych cisel
 */
    public String vypisTazeneCisla()
    {
        // pro vsechna vytazena cisla
        for(int i = 0; i < tazeneCisla.length; i++)
        {           
            // jestlize se jedna o posledni tazene cislo
            if(i == (tazeneCisla.length - 1))
            {
                // zapiseme cislo do vypisu a odradkujeme
                vypis += tazeneCisla[i] + "\n";
            }
            // jinak
            else
            {
                // zapiseme cislo do vypisu a udelame za nim carku
                vypis += tazeneCisla[i] + ",";
            }
        }
        // vratime vypis
        return vypis;
    }
 
/**
 * Metoda vynuluje vypis cisel
 */
    public void vynulovatVypis()
    {
        // priradime prazdny retezec
        vypis = "";
    }
    
/**
 * Metoda vynuluje slovnik - kazda hodnota bude 0
 */
    public void vynulovatSlovnik()
    {
        // pro cely slovnik
        for(int i = 1; i <= zkolika; i++)
        {
            // pridame k jednotlivym klicum hodnotu 0
            slovnik.put(i,0);
        }
    }

/**
 * Metoda zvysuje hodnotu tazenych cisel ve slovniku
 */
    public void naplnitSlovnik()
    {
        // lokalni promenne
        int y;
        int z = 0;
        // pro vsechna tazena cisla
        for(int i = 0; i < tazeneCisla.length; i++)
        {
            // vezmeme hodnotu tazeneho cisla
            y = tazeneCisla[i];
            // vezmeme hodnotu patrici k hodnote tazeneho cisla a zvedneme ji o jednicku
            z = (int)slovnik.get(y) + 1;
            // a na danou hodnotu tazeneho cisla zapiseme novou hodnotu cetnosti zvednutou o jednicku
            slovnik.put(y,z);
        }
    }
   
/**
 * Metoda zjisti tri nejcasteji tazena cisla
 *
 * @return vraci se retezec se 3 nejcasteji tazenymi cisly
 */
    public String nejviceTazene()
    {
        // lokalni promenne
        int cifra;
        int prvniHodnota = 0, druhaHodnota = 0, tretiHodnota = 0;
        int prvniKlic = 0, druhyKlic = 0, tretiKlic = 0;
        // pro cely slovnik
        for(int i = 1; i <= zkolika; i++)
        {
            // zjistime si hodnotu na danem klici slovniku a priradime promenne cifra
            cifra = (int)slovnik.get(i);
            // a porovname ji s prvniHodnota, pokud je hodnota cifra vetsi nebo rovna nez prvniHodnota
            if(cifra >= prvniHodnota)
            {
                // dojde k tomuto prehazeni cisel - z 2 do 3, z 1 do 2, a cifra a i do 1
                tretiHodnota = druhaHodnota;
                tretiKlic = druhyKlic;
                druhaHodnota = prvniHodnota;
                druhyKlic = prvniKlic;
                prvniHodnota = cifra;
                prvniKlic = i;
            }
            // a porovname ji s druhaHodnota, pokud je hodnota cifra vetsi nebo rovna nez druhaHodnota
            else if(cifra >= druhaHodnota)
            {
                // dojde k tomuto prehazeni cisel - z 2 do 3, a cifra a i do 2
                tretiHodnota = druhaHodnota;
                tretiKlic = druhyKlic;
                druhaHodnota = cifra;
                druhyKlic = i;
            }
            // a porovname ji s tretiHodnota, pokud je hodnota cifra vetsi nebo rovna nez tretiHodnota
            else if(cifra >= tretiHodnota)
            {
                // dojde k tomuto prehazeni cisel - cifra a i do 3
                tretiHodnota = cifra;
                tretiKlic = i;
            }
        }
        // hodnoty z lokalnich promennych spojime a predame retezci celek
        String celek =  prvniKlic + "-" + prvniHodnota + "x, " + 
                        druhyKlic + "-" + druhaHodnota + "x, " + 
                        tretiKlic + "-" + tretiHodnota + "x";
        // a vratime celek
        return celek;
    }
 
/**
 * Metoda zjisti tri nemene tazena cisla
 *
 * @return vraci se retezec se 3 nejmene tazenymi cisly
 */
    public String nejmeneTazene(int pocetTahu)
    {
        // lokalni promenne
        int cifra;
        int prvniHodnota = pocetTahu, druhaHodnota = pocetTahu, tretiHodnota = pocetTahu;
        int prvniKlic = 0, druhyKlic = 0, tretiKlic = 0;
        // pro cely slovnik
        for(int i = 1; i <= zkolika; i++)
        {
            // zjistime si hodnotu na danem klici slovniku a priradime promenne cifra
            cifra = (int)slovnik.get(i);
            // a porovname ji s prvniHodnota, pokud je hodnota cifra mensi nebo rovna nez prvniHodnota
            if(cifra <= prvniHodnota)
            {
                // dojde k tomuto prehazeni cisel - z 2 do 3, z 1 do 2, a cifra a i do 1
                tretiHodnota = druhaHodnota;
                tretiKlic = druhyKlic;
                druhaHodnota = prvniHodnota;
                druhyKlic = prvniKlic;
                prvniHodnota = cifra;
                prvniKlic = i;
            }
            // a porovname ji s druhaHodnota, pokud je hodnota cifra mensi nebo rovna nez druhaHodnota
            else if(cifra <= druhaHodnota)
            {
                // dojde k tomuto prehazeni cisel - z 2 do 3, a cifra a i do 2
                tretiHodnota = druhaHodnota;
                tretiKlic = druhyKlic;
                druhaHodnota = cifra;
                druhyKlic = i;
            }
            // a porovname ji s tretiHodnota, pokud je hodnota cifra mensi nebo rovna nez tretiHodnota
            else if(cifra <= tretiHodnota)
            {
                // dojde k tomuto prehazeni cisel - cifra a i do 3
                tretiHodnota = cifra;
                tretiKlic = i;
            }
        }
        // hodnoty z lokalnich promennych spojime a predame retezci celek
        String celek =  prvniKlic + "-" + prvniHodnota + "x, " + 
                        druhyKlic + "-" + druhaHodnota + "x, " + 
                        tretiKlic + "-" + tretiHodnota + "x";
        // a vratime celek
        return celek;
    }
}