// 1. Abstraktní produkty (rozhraní pro jednotlivé prvky)
interface ITlacitko {
   void vykresli();
}

// 2. Konkrétní produkty (implementace pro každou rodinu)
class MaterialTlacitko implements ITlacitko {
   public void vykresli() { System.out.println("Vykresluji tlačítko v Material designu."); }
}
class CupertinoTlacitko implements ITlacitko {
   public void vykresli() { System.out.println("Vykresluji tlačítko v Cupertino stylu (iOS)."); }
}

// 3. Abstraktní továrna (rozhraní pro továrnu)
interface IGUIFactory {
   ITlacitko vytvorTlacitko();
   ICheckbox vytvorCheckbox();
}

// 4. Konkrétní továrny (jedna pro každou rodinu produktů)
class MaterialFactory implements IGUIFactory {
   public ITlacitko vytvorTlacitko() { return new MaterialTlacitko(); }
}

class CupertinoFactory implements IGUIFactory {
   public ITlacitko vytvorTlacitko() { return new CupertinoTlacitko(); }
}

// 5. Klient (aplikace)
class Aplikace {
   private ITlacitko tlacitko;

   // Aplikace dostane továrnu a neví, jaká konkrétně to je.
   public Aplikace(IGUIFactory factory) {
       tlacitko = factory.vytvorTlacitko();
   }

   public void vykresliGUI() {
       tlacitko.vykresli();
   }
}

// Hlavní program, kde se rozhoduje
public class Main {
   public static void main(String[] args) {
       // Zde se na JEDINÉM místě rozhodne, jaký styl se použije
       String os = "Android"; // Může se načíst z konfigurace
       IGUIFactory factory;

       if (os.equals("Android")) {
           factory = new MaterialFactory();
       } else {
           factory = new CupertinoFactory();
       }

       Aplikace app = new Aplikace(factory);
       app.vykresliGUI();
   }
}

// 1. ROZHRANÍ STAVITELE
interface DokumentBuilder {
   void pridejNadpis(String text);
   void pridejOdstavec(String text);
}

// 2. REPREZENTACE A: HTML formátovač
class HtmlBuilder implements DokumentBuilder {
   private StringBuilder html = new StringBuilder();

   public void pridejNadpis(String text) { html.append("<h1>").append(text).append("</h1>\n"); }
   public void pridejOdstavec(String text) { html.append("<p>").append(text).append("</p>\n"); }
   public String getVysledek() { return html.toString(); }
}

// 3. REPREZENTACE B: Čistý text do konzole
class TextBuilder implements DokumentBuilder {
   private StringBuilder text = new StringBuilder();

   public void pridejNadpis(String nadpis) { text.append("=== ").append(nadpis.toUpperCase()).append(" ===\n"); }
   public void pridejOdstavec(String odstavec) { text.append(odstavec).append("\n"); }
   public String getVysledek() { return text.toString(); }
}

// 4. DIRECTOR (Proces konstrukce) - Je naprosto oddělený od výsledného formátu!
class GeneratorReportu {
   public void vygenerujUzaverku(DokumentBuilder builder) {
       // Tady je ten "stejný proces konstrukce"
       builder.pridejNadpis("Roční uzávěrka");
       builder.pridejOdstavec("Firma je v zisku.");
   }
}

// --- POUŽITÍ ---
public class Main {
   public static void main(String[] args) {
       GeneratorReportu generator = new GeneratorReportu();

       // Chci HTML reprezentaci
       HtmlBuilder htmlBuilder = new HtmlBuilder();
       generator.vygenerujUzaverku(htmlBuilder);
       System.out.println(htmlBuilder.getVysledek()); 
       // Vypíše: <h1>Roční uzávěrka</h1> \n <p>Firma je v zisku.</p>

       // Chci textovou reprezentaci (stejný proces, jiný výsledek)
       TextBuilder textBuilder = new TextBuilder();
       generator.vygenerujUzaverku(textBuilder);
       System.out.println(textBuilder.getVysledek());
       // Vypíše: === ROČNÍ UZÁVĚRKA === \n Firma je v zisku.
   }
}

// Třída pro připojení k databázi (chceme ji v aplikaci jen 1x)
class Databaze {
   
   // 1. Statická proměnná pro uchování jediné instance
   private static Databaze instance;

   // 2. Privátní konstruktor zabrání vytvoření pomocí 'new' zvenčí
   private Databaze() {
       System.out.println("Vytvářím spojení s databází (toto by se mělo vypsat jen jednou).");
   }

   // 3. Globální přístupový bod k instanci (nejjednodušší možná varianta)
   public static Databaze getInstance() {
       // Pokud instance ještě neexistuje, vytvoříme ji
       if (instance == null) {
           instance = new Databaze();
       }
       // Vrátíme existující instanci
       return instance;
   }

   public void vykonejDotaz(String sql) {
       System.out.println("Vykonávám: " + sql);
   }
}

// --- POUŽITÍ ---
public class SingletonPattern {
   public static void main(String[] args) {
       // Databaze db = new Databaze(); // CHYBA: Konstruktor je privátní!
       
       Databaze db1 = Databaze.getInstance();
       db1.vykonejDotaz("SELECT * FROM users");
       
       Databaze db2 = Databaze.getInstance(); // Nevytvoří nové spojení, vrátí to samé
       
       System.out.println("Jsou db1 a db2 stejný objekt? " + (db1 == db2)); // Vypíše: true
   }
}

// 1. Společné rozhraní pro PRODUKTY
interface Zbran {
   void utoc();
}

class Mec implements Zbran {
   public void utoc() { System.out.println("Šmik! (Útok mečem)"); }
}

class Luk implements Zbran {
   public void utoc() { System.out.println("Pew pew! (Střelba z luku)"); }
}

// 2. CREATOR (Tvůrce)
abstract class Kovar {
   
   // TOVÁRNÍ METODA - to je jádro vzoru. 
   // Nechává na potomcích, aby rozhodli, co přesně se vyrobí.
   protected abstract Zbran vyrobZbran();
   
   // Společná byznys logika, která tovární metodu využívá
   public void ozbrojHrdinu() {
       Zbran z = vyrobZbran(); // Nevíme co to je, ale víme, že to umí útočit
       System.out.print("Hrdina je připraven: ");
       z.utoc();
   }
}

// 3. KONKRÉTNÍ TVŮRCI (Concrete Creators)
class KovarMecu extends Kovar {
   @Override
   protected Zbran vyrobZbran() { return new Mec(); }
}

class KovarLuku extends Kovar {
   @Override
   protected Zbran vyrobZbran() { return new Luk(); }
}

// --- POUŽITÍ ---
public class FactoryMethodPattern {
   public static void main(String[] args) {
       // Hráč navštívil kováře mečů
       Kovar kovar1 = new KovarMecu();
       kovar1.ozbrojHrdinu(); // Vypíše: Hrdina je připraven: Šmik!
       
       // Hráč navštívil výrobce luků
       Kovar kovar2 = new KovarLuku();
       kovar2.ozbrojHrdinu(); // Vypíše: Hrdina je připraven: Pew pew!
   }
}

// 1. State (rozhraní pro všechny stavy)
interface IStavObjednavky {
   void zaplatit(Objednavka objednavka);
   void odeslat(Objednavka objednavka);
   void dorucit(Objednavka objednavka);
}

// 2. Context (hlavní objekt)
class Objednavka {
   private IStavObjednavky aktualniStav;

   public Objednavka() {
       // Počáteční stav
       this.aktualniStav = new NovaObjednavkaStav();
       System.out.println("Objednávka vytvořena. Stav: Nová");
   }
   
   // Kontext umožňuje stavům měnit svůj vlastní stav
   public void setStav(IStavObjednavky novyStav) {
       this.aktualniStav = novyStav;
   }

   // Kontext deleguje akce na aktuální stav
   public void zaplatit() {
       aktualniStav.zaplatit(this);
   }

   public void odeslat() {
       aktualniStav.odeslat(this);
   }
   
   public void dorucit() {
       aktualniStav.dorucit(this);
   }
}

// 3. ConcreteState (implementace pro každý stav)
class NovaObjednavkaStav implements IStavObjednavky {
   public void zaplatit(Objednavka objednavka) {
       System.out.println("Objednávka byla zaplacena.");
       // Přechod do dalšího stavu
       objednavka.setStav(new ZaplacenaStav());
       System.out.println("Stav: Zaplacená");
   }

   public void odeslat(Objednavka objednavka) {
       System.out.println("Chyba: Nelze odeslat nezaplacenou objednávku!");
   }
   
   public void dorucit(Objednavka objednavka) {
       System.out.println("Chyba: Nelze doručit nezaplacenou objednávku!");
   }
}

class ZaplacenaStav implements IStavObjednavky {
   public void zaplatit(Objednavka objednavka) {
       System.out.println("Chyba: Objednávka je již zaplacena.");
   }

   public void odeslat(Objednavka objednavka) {
       System.out.println("Objednávka byla odeslána.");
       // Přechod do dalšího stavu
       objednavka.setStav(new OdeslanaStav());
       System.out.println("Stav: Odeslaná");
   }
   
   public void dorucit(Objednavka objednavka) {
       System.out.println("Chyba: Nelze doručit neodeslanou objednávku!");
   }
}

class OdeslanaStav implements IStavObjednavky {
   // ... podobná logika pro doručení ...
   public void zaplatit(Objednavka objednavka) { /* ... chyba ... */ }
   public void odeslat(Objednavka objednavka) { /* ... chyba ... */ }
   public void dorucit(Objednavka objednavka) {
       System.out.println("Objednávka byla doručena. Cyklus končí.");
       objednavka.setStav(new DorucenaStav()); // Finální stav
       System.out.println("Stav: Doručená");
   }
}

class DorucenaStav implements IStavObjednavky {
   // Finální stav - všechny akce jsou neplatné
   public void zaplatit(Objednavka o) {System.out.println("Objednávka je již uzavřena.");}
   public void odeslat(Objednavka o) {System.out.println("Objednávka je již uzavřena.");}
   public void dorucit(Objednavka o) {System.out.println("Objednávka je již uzavřena.");}
}


// Klient, který používá Kontext
public class Main {
   public static void main(String[] args) {
       Objednavka objednavka = new Objednavka();
       
       objednavka.odeslat(); // Zkusíme odeslat - mělo by selhat
       objednavka.zaplatit(); // Zaplatíme
       objednavka.zaplatit(); // Zkusíme zaplatit znovu - mělo by selhat
       objednavka.odeslat(); // Teď už to půjde
       objednavka.dorucit(); // A doručíme
   }
}

import java.util.ArrayList;
import java.util.List;

// 1. ROZHRANÍ POZOROVATELE (Observer)
// Všichni, kdo chtějí dostávat upozornění, musí umět toto.
interface Odberatel {
   void upozorni(String zprava);
}

// 2. KONKRÉTNÍ POZOROVATEL
class Fanousek implements Odberatel {
   private String jmeno;

   public Fanousek(String jmeno) { 
       this.jmeno = jmeno; 
   }

   @Override
   public void upozorni(String zprava) {
       System.out.println(jmeno + " dostal notifikaci: " + zprava);
   }
}

// 3. SUBJEKT / VYDAVATEL (Observable)
class YouTubeKanal {
   // Seznam všech, kteří odebírají tento kanál
   private List<Odberatel> seznamOdberatelu = new ArrayList<>();

   // Metody pro správu odběrů (Subscribe / Unsubscribe)
   public void pridejOdberatele(Odberatel o) { 
       seznamOdberatelu.add(o); 
   }
   
   public void odeberOdberatele(Odberatel o) { 
       seznamOdberatelu.remove(o); 
   }

   // Změna stavu, která spustí hromadné upozornění
   public void vydejNoveVideo(String nazevVidea) {
       System.out.println("\n--- Kanál právě vydal video: " + nazevVidea + " ---");
       
       // Vydavatel projde všechny odběratele a zavolá jejich metodu
       for (Odberatel odberatel : seznamOdberatelu) {
           odberatel.upozorni("Nové video ke zhlédnutí -> " + nazevVidea);
       }
   }
}

// --- POUŽITÍ ---
public class ObserverPattern {
   public static void main(String[] args) {
       YouTubeKanal mujKanal = new YouTubeKanal();

       // Vytvoříme diváky
       Fanousek pepa = new Fanousek("Pepa");
       Fanousek karel = new Fanousek("Karel");

       // Pepa a Karel dali odběr
       mujKanal.pridejOdberatele(pepa);
       mujKanal.pridejOdberatele(karel);

       // Kanál vydá video - Pepa i Karel dostanou upozornění
       mujKanal.vydejNoveVideo("Naučte se Javu za 10 minut");
       
       // Pepa zrušil odběr (un-subscribe)
       mujKanal.odeberOdberatele(pepa); 
       
       // Kanál vydá další video - teď už dostane upozornění jen Karel
       mujKanal.vydejNoveVideo("Návrhové vzory snadno a rychle");
   }
}