package eu.pedu.adv18s._5_1100.mikp03_mikan.logika;

import static eu.pedu.adv18s._5_1100.mikp03_mikan.logika.Inventar.KAPACITA;
import eu.pedu.adv18s_fw.game_txt.IPlace;
import java.util.Collection;
import java.util.Collections;
import java.util.Set;
import java.util.HashSet;
import java.util.Map;
import java.util.HashMap;

/**
 * Trida Prostor - popisuje jednotlivé prostory (místnosti) hry
 *
 * Tato třída je součástí jednoduché textové hry.
 *
 * "Prostor" reprezentuje jedno místo (místnost, prostor, ..) ve scénáři hry.
 * Prostor může mít sousední prostory připojené přes východy. Pro každý východ
 * si prostor ukládá odkaz na sousedící prostor.
 *
 * @author Michael Kolling, Lubos Pavlicek, Jarmila Pavlickova
 * @version pro školní rok 2016/2017
 */
public class Prostor implements IPlace{

    private String nazev;
    private String popis;
    private boolean jeVidet = true;
    private Set<Prostor> vychody;
    private Set<Vec> veci = new HashSet<Vec>();
    private Map<String, Postava> postavy;
    private String nazevObjektu;

    /**
     * Konstruktor třídy
     *
     * @param nazev Název prostoru.
     * @param popis Popis prostoru.
     * @param nazvyObjektu Nazvy objektů.
     */
    public Prostor(String nazev, String popis, String ... nazvyObjektu) {
        this.nazev = nazev;
        this.popis = popis;
        this.nazevObjektu = nazevObjektu;
        this.jeVidet = jeVidet;
        vychody = new HashSet<>();
        postavy = new HashMap<>();
        for (String nazevObjektu : nazvyObjektu) {
            boolean zvednutelny = true;
            if (nazevObjektu.charAt(0) == ' ') {
                zvednutelny = false;
                nazevObjektu = nazevObjektu.substring(1);
            }
            veci.add(new Vec(nazevObjektu, zvednutelny));
        }
    }

    /**
     * Definuje východ z prostoru (sousední/vedlejsi prostor). Vzhledem k tomu,
     * že je použit Set pro uložení východů, může být sousední prostor uveden
     * pouze jednou (tj. nelze mít dvoje dveře do stejné sousední místnosti).
     * Druhé zadání stejného prostoru tiše přepíše předchozí zadání (neobjeví se
     * žádné chybové hlášení). Lze zadat též cestu ze do sebe sama.
     *
     * @param vedlejsi prostor, který sousedi s aktualnim prostorem.
     *
     */
    public void setVychod(Prostor vedlejsi) {
        vychody.add(vedlejsi);
    }

    /**
     * Metoda equals pro porovnání dvou prostorů. Překrývá se metoda equals ze
     * třídy Object. Dva prostory jsou shodné, pokud mají stejný název. Tato
     * metoda je důležitá z hlediska správného fungování seznamu východů (Set).
     *
     * Bližší popis metody equals je u třídy Object.
     *
     * @param o object, který se má porovnávat s aktuálním
     * @return hodnotu true, pokud má zadaný prostor stejný název, jinak false
     */
      @Override
    public boolean equals(Object o) {
        // porovnáváme zda se nejedná o dva odkazy na stejnou instanci
        if (this == o) {
            return true;
        }
        // porovnáváme jakého typu je parametr
        if (!(o instanceof Prostor)) {
            return false;    // pokud parametr není typu Prostor, vrátíme false
        }
        // přetypujeme parametr na typ Prostor
        Prostor druhy = (Prostor) o;

        //metoda equals třídy java.util.Objects porovná hodnoty obou názvů.
        //Vrátí true pro stejné názvy a i v případě, že jsou oba názvy null,
        //jinak vrátí false.

       return (java.util.Objects.equals(this.nazev, druhy.nazev));
    }

    /**
     * metoda hashCode vraci ciselny identifikator instance, ktery se pouziva
     * pro optimalizaci ukladani v dynamickych datovych strukturach. Pri
     * prekryti metody equals je potreba prekryt i metodu hashCode. Podrobny
     * popis pravidel pro vytvareni metody hashCode je u metody hashCode ve
     * tride Object
     */
    @Override
    public int hashCode() {
        int vysledek = 3;
        int hashNazvu = java.util.Objects.hashCode(this.nazev);
        vysledek = 37 * vysledek + hashNazvu;
        return vysledek;
    }


    /**
     * Vrací název prostoru (byl zadán při vytváření prostoru jako parametr
     * konstruktoru)
     *
     * @return název prostoru
     */
    public String getNazev() {
        return nazev;
    }

    public String getNazevVeci() {
        return nazevObjektu;
    }

    /**
     * Vrací "dlouhý" popis prostoru, který může vypadat následovně: Jsi v
     * mistnosti/prostoru vstupni hala budovy VSE na Jiznim meste. vychody:
     * chodba bufet ucebna
     *
     * @return Dlouhý popis prostoru
     */
    public String dlouhyPopis() {
        return "Jsi v mistnosti/prostoru " + popis + ".\n"
                + popisVychodu() +"\n"
                + getVeci() +"\n"
                + getPostavy();
    }

    /**
     * Vrací textový řetězec, který popisuje sousední východy, například:
     * "vychody: hala ".
     *
     * @return Popis východů - názvů sousedních prostorů
     */
    private String popisVychodu() {
        String vracenyText = "východy: ";
        vracenyText = vychody.stream().filter((sousedni) ->
                (sousedni.jeVidet())).map((sousedni) ->
                 " " + sousedni.getNazev()).reduce(vracenyText, String::concat);
        return vracenyText;
    }

    /**
     * Vrací prostor, který sousedí s aktuálním prostorem a jehož název je zadán
     * jako parametr. Pokud prostor s udaným jménem nesousedí s aktuálním
     * prostorem, vrací se hodnota null.
     *
     * @param nazevSouseda Jméno sousedního prostoru (východu)
     * @return Prostor, který se nachází za příslušným východem, nebo hodnota
     * null, pokud prostor zadaného jména není sousedem.
     */
    public Prostor vratSousedniProstor(String nazevSouseda) {
        if (nazevSouseda == null) {
            return null;
        }
        for (Prostor sousedni : vychody) {
            if (sousedni.getNazev().equals(nazevSouseda)) {
                return sousedni;
            }
        }
        return null;
    }

    /**
     * Metoda vloží věc.
     *
     * @param vec věc třídy Vec
     * @return boolean - true, pokud se to povede.
     */
    public boolean vlozVec(Vec vec){
        boolean zvedam = (veci.size() < KAPACITA) && veci.add(vec);
        return zvedam;
    }

    /**
     * Metoda najde věc.
     *
     * @param nazevVeci třídy String
     * @return vrátí nalezenou věc v prostoru.
     */
    public Vec najdiVec(String nazevVeci){
        for (Vec vec : veci) {
            if (vec.getNazev().toLowerCase().equals(nazevVeci)) {
                return vec;
            }
        }
        return null;
    }

    /**
     * Odebere věc.
     *
     * @param jmenoVeci třídy Vec
     * @return vrací buď jméno odebrané věci nebo nic
     */
    public Vec odeberVec(Vec jmenoVeci){
        jmenoVeci = jmenoVeci;
        for (Vec vec : veci) {
            if (vec.getNazev().toLowerCase().equals(jmenoVeci)) {
                return vec;
            }
        }
        return null;
    }

    /**
     * Vrací seznam věcí z prostoru.
     *
     * @return  vrací názvy věcí.
     */

    public Collection<Vec> getVeci() {
        return Collections.unmodifiableCollection(veci);

    }

    /**
     * Metoda vrací seznam postav z prostoru.
     *
     * @return vrací názvy postav v prostoru
     */

    public String getPostavy() {
        String nazvy = "  jsou zde tyto postavy: ";
        nazvy = postavy.keySet().stream().map((jmenoPostav) ->
                jmenoPostav + " ").reduce(nazvy, String::concat);
        return nazvy;
    }

    /**
     * Metoda, zda-li se nachází věc v prostoru.
     *
     * @param jmenoVeci třídy String
     * @return boolean - true, pokud ano.
     */

    public boolean obsahujeVec(String jmenoVeci) {
        return veci.stream().anyMatch((vec) ->
                (vec.getNazev().toLowerCase().equals(jmenoVeci)));
    }

    /**
     * Vloží postavu do prostoru.
     *
     * @param postava třída Postava.
     *
     * @return boolean - true, pokud se v prostoru nachází.
     */

    public boolean vlozPostavu(Postava postava)
    {
        if(postavy.containsKey(postava.getJmeno())) {
            return false;
        }
        else{
            postavy.put(postava.getJmeno(),postava);
            return true;
        }
    }

    /**
     * Metoda najde postavu.
     *
     * @param jmeno String jméno postavy
     * @return vrací jméno postavy
     */

    public Postava najdiPostavu(String jmeno)
    {
        return postavy.get(jmeno);
    }

    /**
     * Odebere postavu.
     *
     * @param jmeno String jméno postavy
     * @return odebere postavu
     */
    public Postava odeberPostavu(String jmeno){
        return postavy.remove(jmeno);
    }

    /**
     * Nastaví viditelnost.
     *
     * @param viditelna boolean, jestli je mísntost viditelná
     */
    public void budeVidet(boolean viditelna ) {
        jeVidet = viditelna;
    }

    /**
     * Zjistí, jestli je místnost viditelná.
     *
     * @return boolean - true, pokud je viditelná.
     */
    public boolean jeVidet() {
        return jeVidet;
    }

    @Override
    public Collection<Prostor> getNeighbors() {
        return Collections.unmodifiableCollection(vychody);
    }

    @Override
    public Collection<Vec> getItems() {
        return Collections.unmodifiableCollection(veci);
    }

    @Override
    public String getName() {
        return getNazev();
    }
}