package adamira.cz;

import sugar.Sys;

public class Hangman2 {

  static String[][] obrazy =
    {
      { "         * * * *         ",
        "      *          *       ",
        "     *   O     O   *     ",
        "     *             *     ",
        "     *      U      *     ",
        "     *    _____    *     ",
        "       *         *       ",
        "         * * * *         "
      },
      { "     *                   ",
        "     *                   ",
        "     *                   ",
        "     *                   ",
        "     *                   ",
        "     *                   ",
        "     *                   ",
        " * * * * * * * * * * * * "
      },
      { "     * * * * * * *       ",
        "     *                   ",
        "     *                   ",
        "     *                   ",
        "     *                   ",
        "     *                   ",
        "     *                   ",
        " * * * * * * * * * * * * "
      },
      { "     * * * * * * *       ",
        "     *   *               ",
        "     * *                 ",
        "     *                   ",
        "     *                   ",
        "     *                   ",
        "     *                   ",
        " * * * * * * * * * * * * "
      },
      { "     * * * * * * *       ",
        "     *   *     *         ",
        "     * *       *         ",
        "     *                   ",
        "     *                   ",
        "     *                   ",
        "     *                   ",
        " * * * * * * * * * * * * "
      },
      { "     * * * * * * *       ",
        "     *   *     *         ",
        "     * *       *         ",
        "     *       *   *       ",
        "     *         *         ",
        "     *                   ",
        "     *                   ",
        " * * * * * * * * * * * * "
      },
      { "        * * * * *        ",
        "      *   o   o   *      ",
        "      *     u     *      ",
        "        *  xxx  *        ",
        "          * * *          ",
        " * * * *         * * * * ",
        "         * * * *         ",
        " * * * *         * * * * "
      }
    };

  static String[] vety = {
      "nazdar lidi",
      "kocka leze dirou",
      "prsi prsi jen se leje",
      "pes",
      "rek",
      "prs",
      "prd",
      "krk",
      "prk"
  };

///////////////////////////////////////////////////////////////////////////////

  // funkce, ktera zjisti, zda zadany znak je pismeno
  static boolean jePismeno(char znak) {
    return (znak >= 'a') && (znak <= 'z');
  }

///////////////////////////////////////////////////////////////////////////////

  // funkce, ktera zjisti, zda zadany znak je pismeno
  // a neni na seznamu spatnych pismen
  static boolean jeDobrePismeno(char znak, boolean[] spatnaPismena) {
    return jePismeno(znak) && (!spatnaPismena[znak - 'a']);
  }

///////////////////////////////////////////////////////////////////////////////

  // funkce, ktera najde shody masky s vetami:
  // do pole shody[] ulozi logicke hodnoty a vraci pocet shod
  static int najdiShody(  String maska, boolean[] shody,
                          boolean[] spatnaPismena, char uhodnutyZnak) {
    int pocetShod = 0;
    for (int i=0; i<vety.length; i++)
      if (vety[i].length() == maska.length()) {
        shody[i] = true; // shoda vety a masky
        boolean jeTamUhodnutyZnak = (uhodnutyZnak == 0);
        for (int j=0; j<maska.length(); j++) {
          if (! ( (maska.charAt(j) == vety[i].charAt(j)) ||
                 ( (maska.charAt(j) == '.') &&
                  jeDobrePismeno(vety[i].charAt(j), spatnaPismena)
                  )))
            shody[i] = false;
          if (vety[i].charAt(j) == uhodnutyZnak) jeTamUhodnutyZnak = true;
        }
        if (!jeTamUhodnutyZnak) shody[i] = false;
        if (shody[i]) pocetShod++;
      }
      else
        shody[i] = false;
    return pocetShod;
  }

  static int najdiShody(  String maska, boolean[] shody,
                          boolean[] spatnaPismena) {
    return najdiShody(maska, shody, spatnaPismena, (char) 0);
  }

///////////////////////////////////////////////////////////////////////////////

  // metoda, ktera zobrazi obrazek a zadanou zpravu
  public static void zobraz(String zprava, int pocetChyb, String maska) {
    for (int radek = 0; radek < 100; radek++) Sys.pln();
    Sys.pln(obrazy[pocetChyb][0] + "     Hra HANGMAN");
    Sys.pln(obrazy[pocetChyb][1] + "     ");
    Sys.pln(obrazy[pocetChyb][2] + "     Pocet chyb: " + pocetChyb);
    Sys.pln(obrazy[pocetChyb][3] + "     ");
    Sys.pln(obrazy[pocetChyb][4] + "     Hadany text:");
    Sys.pln(obrazy[pocetChyb][5] + "        " + maska);
    Sys.pln(obrazy[pocetChyb][6] + "     ");
    Sys.p  (obrazy[pocetChyb][7] + "     " + zprava);
  }

///////////////////////////////////////////////////////////////////////////////

  // funkce, ktera zobrazi obrazek se zadanou zpravou
  // a ceka, az uzivatel zada text "ano" nebo "ne"
  // navratova hodnota je logickou hodnotou odpovedi
  public static boolean zobrazAnoNe(String zprava, int pocetChyb, String maska) {
    while (true) {
      zobraz(zprava + " [ano/ne]: ", pocetChyb, maska);
      String odpoved = Sys.readLine();
      if (odpoved.compareTo("ano")==0) return true;
      if (odpoved.compareTo("ne" )==0) return false;
    }
  }

///////////////////////////////////////////////////////////////////////////////

  // funkce, ktera zjisti pismeno, ktere se ve vetach se shodnou maskou
  // vyskytuje nejcasteji a neni na nesznamu spatnych pismen
  public static char najdiNejcastejsiPismeno(boolean[] shody, boolean[] spatnaPismena) {
    // zjistim, vyskyty jednotlivych pismen
    int[] vyskytyPismen = new int[spatnaPismena.length];
    for (int i=0; i<vyskytyPismen.length; i++)
      vyskytyPismen[i] = 0;
    for (int i=0; i<vety.length; i++)
      if (shody[i])
        for (int j=0; j<vety[i].length(); j++) {
          char znak = vety[i].charAt(j);
          if (jeDobrePismeno(znak, spatnaPismena)) vyskytyPismen[znak-'a']++;
        }
    // najdu pismeno, ktere se vyskytuje ve zbyvajicich vetach nejvickrat
    char nejcastejsi = 'a';
    int maxVyskytu = 0;
    for (int i=0; i<vyskytyPismen.length; i++)
      if (vyskytyPismen[i] > maxVyskytu) {
        maxVyskytu = vyskytyPismen[i];
        nejcastejsi = (char) (i + 'a');
      }
    return nejcastejsi;
  }

///////////////////////////////////////////////////////////////////////////////

  // funkce, ktera zjisti, jestli jsem vyhral
  public static boolean vyhralJsem(String maska) {
    for (int i=0; i<maska.length(); i++)
      if (maska.charAt(i) == '.') return false;
    return true;
  }

///////////////////////////////////////////////////////////////////////////////

  // funkce, ktera zjisti, jestli jsem prohral
  public static boolean prohralJsem(int pocetChyb) {
    return (pocetChyb >= obrazy.length - 1);
  }

///////////////////////////////////////////////////////////////////////////////

  // funkce, ktera ke vstupnimu poli retezcu prida dalsi retezec
  public static String[] pridejRetezec(String[] vstup, String Retezec) {
    String[] vystup = new String[vstup.length + 1];
    for (int i=0; i<vstup.length; i++)
      vystup[i] = vstup[i];
    vystup[vstup.length] = Retezec;
    return vystup;
  }

///////////////////////////////////////////////////////////////////////////////

  // funkce, ktera se uzivatele zepta na masku vety
  public static String zeptejSeNaMasku(boolean[] shody, boolean[] spatnaPismena) {
    String[] masky = {};
    for (int i=0; i<vety.length; i++)
      if (shody[i]) {
        String novaMaska = "";
        for (int j=0; j<vety[i].length(); j++) {
          char znak = vety[i].charAt(j);
          if (jeDobrePismeno(znak, spatnaPismena))
            novaMaska += '.';
          else
            novaMaska += znak;
        }
        boolean maskaUzJe = false;
        for (int j=0; j<masky.length; j++)
          if (masky[j].compareTo(novaMaska) == 0)
            maskaUzJe = true;
        if (!maskaUzJe) masky = pridejRetezec(masky, novaMaska);
      }
    if (masky.length == 1)
      return masky[0]; // pokud je jen jedna varianta, nema smysl se na ni ptat
    else {
      Sys.pln();
      Sys.pln("Veta, kterou si myslite, ma jednu z nasledujicich podob:");
      for (int i = 1; i <= masky.length; i++)
        Sys.pln("   " + i + ") " + masky[i - 1]);
      int cislo;
      do {
        Sys.p("Zadejte cislo radku: ");
        cislo = Sys.readInt();
      }
      while ( (cislo < 1) || (cislo > masky.length));
      return masky[cislo - 1];
    }
  }

///////////////////////////////////////////////////////////////////////////////

  // hlavni metoda
  public static void main(String[] args) {

    // priprava
    boolean[] shody = new boolean[vety.length];
      // true = prislusna veta odpovida masce
    int pocetShod; // pocet hodnot "true" v poli shody[]
    int pocetChyb = 0; // kolik jsem udelal chyb
    String maska; // maska vety, kterou hadam
    int pocetPismen = 'z' - 'a' + 1;
    boolean[] spatnaPismena = new boolean[pocetPismen];
      // true = o prislusnem pismenu uzivatel rekl, ze ve slove neni,
      //        nebo jsem pismeno uhodl => nema smysl se na nej znovu ptat
    for (int i=0; i<spatnaPismena.length; i++) spatnaPismena[i] = false;
    for (int i=0; i<shody.length; i++) shody[i] = true;

    // zobrazim seznam vet, ktere znam
    Sys.pln("Vety ktere znam:");
    for (int i=0; i<vety.length; i++)
      Sys.pln("     " + vety[i]);
    Sys.pln("Jednu vetu si vduchu vyberte a zapamatujte si ji. [ENTER]");
    Sys.readLine();

    // nactu masku vety
    maska = zeptejSeNaMasku(shody, spatnaPismena);
    pocetShod = najdiShody(maska, shody, spatnaPismena);

    // hlavni cyklus (hadam pismenka)
    while (true) {

       // vyhral jsem ???
       if (vyhralJsem(maska)) {
         zobraz("Vyhral jsem! Ha ha ha!", pocetChyb, maska);
         break;
       }

       // prohral jsem ???
       if (prohralJsem(pocetChyb)) {
         zobraz("Gratuluji! Vyhral jste.", pocetChyb, maska);
         break;
       }

       // najdu pismeno, ktere se vyskytuje ve vetach shodnych s maskou nejvickrat
       char hadat = najdiNejcastejsiPismeno(shody, spatnaPismena);

       // zeptam se uzivatele, jestli je toto pismenko ve vete, kterou si mysli
       do {
         if (zobrazAnoNe("Obsahuje veta pismeno '" + hadat + "'?", pocetChyb, maska)) {
           // pokud pismenko ve vete je, zeptam se uzivatele na novou masku vety
           pocetShod = najdiShody(maska, shody, spatnaPismena, hadat);
           spatnaPismena [hadat-'a'] = true;
           maska = zeptejSeNaMasku(shody, spatnaPismena);
           pocetShod = najdiShody(maska, shody, spatnaPismena);
         }
         else {
           // pokud odpovedel "ne", overim platnost teto odpovedi
           spatnaPismena[hadat-'a'] = true;
           pocetShod = najdiShody(maska, shody, spatnaPismena);
           if (pocetShod < 1)
             spatnaPismena[hadat-'a'] = false; // uzivatel si vymysli
           else
             pocetChyb++; // o ou - spletl jsem se
         }
       } while (pocetShod < 1);

    }
  }

}