Objektové programovanie

-- =============================================================================
-- 🌱 VEGÁNSKE RECEPTY – Výučbový dátový model
-- =============================================================================
-- Databáza : MySQL 8.x
-- Kódovanie : utf8mb4
-- Reset     : mysql -u root -p vegan_recipes < vegan_recepty.sql
-- =============================================================================
--
-- SCHÉMA
-- =============================================================================
--
--  ČÍSELNÍKY
--  ┌──────────────┐ ┌──────────────────┐ ┌───────────────┐
--  │    units     │ │ingredient_categor│ │ nutrition_type│
--  │──────────────│ │──────────────────│ │───────────────│
--  │ id           │ │ id               │ │ id            │
--  │ name         │ │ name             │ │ name          │
--  │ multiplier   │ └────────┬─────────┘ │ unit          │
--  └──────┬───────┘          │           └───────┬───────┘
--         │                  │                   │
--  ┌──────────────┐ ┌──────────────────┐         │
--  │  difficulties│ │  cooking_methods │         │
--  │──────────────│ │──────────────────│         │
--  │ id           │ │ id               │         │
--  │ name         │ │ name             │         │
--  └──────┬───────┘ └────────┬─────────┘         │
--         │                  │                   │
--  ┌──────────────┐ ┌──────────────────┐         │
--  │recipe_categor│ │    seasons       │         │
--  │──────────────│ │──────────────────│         │
--  │ id           │ │ id               │         │
--  │ name         │ │ name             │         │
--  └──────┬───────┘ └────────┬─────────┘         │
--         │                  │                   │
--  HLAVNÉ ENTITY             │                   │
--                            │                   │
--  ┌──────────────┐          │                   │
--  │    users     │          │                   │
--  │──────────────│          │                   │
--  │ id           │          │                   │
--  │ name         │          │                   │
--  │ email        │          │                   │
--  │ password     │          │                   │
--  └──────┬───────┘          │                   │
--         │                  │                   │
--         │         ┌────────▼─────────┐         │
--         │         │   ingredients    │         │
--         │         │──────────────────│         │
--         │         │ id               │         │
--         │         │ name             │         │
--         │         │ base_unit(g/ml/ks│         │
--         │         │ g_per_piece      │         │
--         │         │ category_id ─────┘(číselník│
--         │         │ season_id        │         │
--         │         └────────┬─────────┘         │
--         │                  │                   │
--         │         ┌────────▼──────────────────▼┐
--         │         │   ingredient_nutrition      │
--         │         │ (ingredient_id, type_id,    │
--         │         │  value per 100g)            │
--         │         └─────────────────────────────┘
--         │
--  ┌──────▼───────────────────────────────────────┐
--  │                   recipes                    │
--  │──────────────────────────────────────────────│
--  │ id, title, description, instructions         │
--  │ servings, prep_time_min, cook_time_min        │
--  │ is_favorite, user_id                         │
--  │ difficulty_id ──────────► difficulties       │
--  │ cooking_method_id ──────► cooking_methods    │
--  └──────┬───────────────────────────────────────┘
--         │
--    ┌────┴──────────────────────┐
--    │                           │
--  ┌─▼─────────────────┐  ┌─────▼──────────────┐
--  │ recipe_ingredients│  │  recipe_category_map│
--  │ (recipe_id,       │  │  (recipe_id,        │
--  │  ingredient_id,   │  │   category_id)      │
--  │  amount,          │  └─────────────────────┘
--  │  unit_id)         │
--  └───────────────────┘
--
--  VIEW: recipe_nutrition
--  → kalórie a makrá na celý recept aj na porciu
--
-- =============================================================================

SET FOREIGN_KEY_CHECKS = 0;
SET NAMES utf8mb4;

-- =============================================================================
-- DROP – v správnom poradí (pivot → závislé → hlavné → číselníky)
-- =============================================================================
DROP TABLE IF EXISTS recipe_category_map;
DROP TABLE IF EXISTS recipe_ingredients;
DROP TABLE IF EXISTS ingredient_nutrition;
DROP TABLE IF EXISTS recipes;
DROP TABLE IF EXISTS ingredients;
DROP TABLE IF EXISTS users;
DROP TABLE IF EXISTS recipe_categories;
DROP TABLE IF EXISTS cooking_methods;
DROP TABLE IF EXISTS difficulties;
DROP TABLE IF EXISTS nutrition_types;
DROP TABLE IF EXISTS ingredient_categories;
DROP TABLE IF EXISTS seasons;
DROP TABLE IF EXISTS units;
DROP VIEW  IF EXISTS recipe_nutrition;

SET FOREIGN_KEY_CHECKS = 1;


-- =============================================================================
-- ČÍSELNÍKY
-- =============================================================================

-- -----------------------------------------------------------------------------
-- units – jednotky merania
-- -----------------------------------------------------------------------------
-- multiplier = koeficient prepočtu na základnú jednotku (g alebo ml)
-- Výpočet kalórií: amount × multiplier / 100 × calories_per_100g
--
-- Príklad:
--   2 lyžice olivového oleja (884 kcal/100g)
--   = 2 × 15 / 100 × 884 = 265 kcal
--
-- Pre base_unit = ks sa multiplier ignoruje,
-- použije sa ingredients.g_per_piece namiesto neho.
-- -----------------------------------------------------------------------------
CREATE TABLE units (
    id          INT UNSIGNED        NOT NULL AUTO_INCREMENT,
    name        VARCHAR(30)         NOT NULL,
    multiplier  DECIMAL(10, 4)      NOT NULL DEFAULT 1
                    COMMENT 'Prepočet na g alebo ml. Pre ks sa ignoruje.',
    CONSTRAINT pk_units         PRIMARY KEY (id),
    CONSTRAINT uq_units_name    UNIQUE (name),
    CONSTRAINT chk_units_mult   CHECK (multiplier > 0)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
  COMMENT='Jednotky merania s koeficientom pre výpočet kalórií';

INSERT INTO units (name, multiplier) VALUES
('g',       1),
('dag',     10),
('kg',      1000),
('ml',      1),
('l',       1000),
('lyžička', 5),
('lyžica',  15),
('šálka',   240),
('ks',      1);


-- -----------------------------------------------------------------------------
-- ingredient_categories – kategórie surovín
-- -----------------------------------------------------------------------------
CREATE TABLE ingredient_categories (
    id      INT UNSIGNED    NOT NULL AUTO_INCREMENT,
    name    VARCHAR(80)     NOT NULL,
    CONSTRAINT pk_ingredient_categories     PRIMARY KEY (id),
    CONSTRAINT uq_ingredient_categories     UNIQUE (name)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
  COMMENT='Kategórie surovín: zelenina, ovocie, strukoviny, obilniny...';

INSERT INTO ingredient_categories (name) VALUES
('Zelenina'),
('Ovocie'),
('Strukoviny'),
('Obilniny a múky'),
('Orechy a semienka'),
('Koreniny a bylinky'),
('Oleje a tuky'),
('Rastlinné mlieka a alternatívy'),
('Ostatné');


-- -----------------------------------------------------------------------------
-- nutrition_types – typy nutričných hodnôt
-- -----------------------------------------------------------------------------
CREATE TABLE nutrition_types (
    id      INT UNSIGNED    NOT NULL AUTO_INCREMENT,
    name    VARCHAR(80)     NOT NULL,
    unit    VARCHAR(20)     NOT NULL COMMENT 'Jednotka nutričnej hodnoty: kcal, g...',
    CONSTRAINT pk_nutrition_types   PRIMARY KEY (id),
    CONSTRAINT uq_nutrition_types   UNIQUE (name)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
  COMMENT='Typy nutričných hodnôt – pridanie novej = len INSERT, žiadna zmena schémy';

INSERT INTO nutrition_types (name, unit) VALUES
('Kalórie',     'kcal'),
('Bielkoviny',  'g'),
('Sacharidy',   'g'),
('Tuky',        'g'),
('Vláknina',    'g'),
('Cukry',       'g'),
('Soľ',         'g');


-- -----------------------------------------------------------------------------
-- recipe_categories – kategórie receptov
-- -----------------------------------------------------------------------------
CREATE TABLE recipe_categories (
    id      INT UNSIGNED    NOT NULL AUTO_INCREMENT,
    name    VARCHAR(80)     NOT NULL,
    CONSTRAINT pk_recipe_categories     PRIMARY KEY (id),
    CONSTRAINT uq_recipe_categories     UNIQUE (name)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
  COMMENT='Kategórie receptov: raňajky, polievka, hlavné jedlo, dezert...';

INSERT INTO recipe_categories (name) VALUES
('Raňajky'),
('Polievka'),
('Hlavné jedlo'),
('Šalát'),
('Dezert'),
('Nápoj a smoothie'),
('Omáčka a dip'),
('Pečivo');


-- -----------------------------------------------------------------------------
-- cooking_methods – spôsoby prípravy
-- -----------------------------------------------------------------------------
CREATE TABLE cooking_methods (
    id      INT UNSIGNED    NOT NULL AUTO_INCREMENT,
    name    VARCHAR(80)     NOT NULL,
    CONSTRAINT pk_cooking_methods   PRIMARY KEY (id),
    CONSTRAINT uq_cooking_methods   UNIQUE (name)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
  COMMENT='Spôsob tepelnej alebo inej úpravy receptu';

INSERT INTO cooking_methods (name) VALUES
('Varenie'),
('Pečenie'),
('Dusenie'),
('Restovanie'),
('Grilovanie'),
('Raw – bez úpravy'),
('Mixovanie'),
('Chladenie a mrazenie');


-- -----------------------------------------------------------------------------
-- difficulties – obtiažnosť receptu
-- -----------------------------------------------------------------------------
CREATE TABLE difficulties (
    id      INT UNSIGNED    NOT NULL AUTO_INCREMENT,
    name    VARCHAR(50)     NOT NULL,
    CONSTRAINT pk_difficulties  PRIMARY KEY (id),
    CONSTRAINT uq_difficulties  UNIQUE (name)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
  COMMENT='Obtiažnosť prípravy receptu';

INSERT INTO difficulties (name) VALUES
('Ľahký'),
('Stredný'),
('Náročný');


-- -----------------------------------------------------------------------------
-- seasons – ročné obdobia
-- -----------------------------------------------------------------------------
CREATE TABLE seasons (
    id      INT UNSIGNED    NOT NULL AUTO_INCREMENT,
    name    VARCHAR(50)     NOT NULL,
    CONSTRAINT pk_seasons   PRIMARY KEY (id),
    CONSTRAINT uq_seasons   UNIQUE (name)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
  COMMENT='Ročné obdobia pre sezónnosť surovín';

INSERT INTO seasons (name) VALUES
('Jar'),
('Leto'),
('Jeseň'),
('Zima'),
('Celý rok');


-- =============================================================================
-- HLAVNÉ ENTITY
-- =============================================================================

-- -----------------------------------------------------------------------------
-- users – používatelia
-- Zatiaľ 1 admin. Pripravené na rozšírenie o registráciu.
-- -----------------------------------------------------------------------------
CREATE TABLE users (
    id          INT UNSIGNED    NOT NULL AUTO_INCREMENT,
    name        VARCHAR(100)    NOT NULL,
    email       VARCHAR(150)    NOT NULL,
    password    VARCHAR(255)    NOT NULL COMMENT 'bcrypt hash – nikdy plain text!',
    created_at  TIMESTAMP       NOT NULL DEFAULT CURRENT_TIMESTAMP,
    CONSTRAINT pk_users         PRIMARY KEY (id),
    CONSTRAINT uq_users_email   UNIQUE (email)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
  COMMENT='Používatelia – zatiaľ 1 admin, pripravené na rozšírenie';

INSERT INTO users (name, email, password) VALUES
('Admin', 'admin@veganrecepty.sk', '$2b$12$HASH_SEM_PRIDE_BCRYPT');


-- -----------------------------------------------------------------------------
-- ingredients – suroviny
-- -----------------------------------------------------------------------------
-- base_unit určuje "rozmer" suroviny:
--   g   → sypné a tuhé (múka, ryža, zelenina...)
--   ml  → tekuté (olej, mlieko, šťava...)
--   ks  → kusové (jablko, vajce, cibuľa...)
--
-- g_per_piece – priemerná hmotnosť 1 kusu v gramoch
--   Použije sa IBA keď base_unit = 'ks'
--   Pre g a ml je NULL
--
-- Výpočet kalórií podľa base_unit:
--   g / ml : amount × unit.multiplier / 100 × nutrition_value
--   ks     : amount × g_per_piece     / 100 × nutrition_value
-- -----------------------------------------------------------------------------
CREATE TABLE ingredients (
    id              INT UNSIGNED        NOT NULL AUTO_INCREMENT,
    name            VARCHAR(100)        NOT NULL,
    base_unit       ENUM('g','ml','ks') NOT NULL COMMENT 'Základná dimenzia suroviny',
    g_per_piece     DECIMAL(8, 2)       NULL
                        COMMENT 'Priemerná hmotnosť 1 kusu v g. Len pre base_unit = ks.',
    category_id     INT UNSIGNED        NOT NULL,
    season_id       INT UNSIGNED        NULL COMMENT 'NULL = sezóna neznáma',
    CONSTRAINT pk_ingredients           PRIMARY KEY (id),
    CONSTRAINT uq_ingredients_name      UNIQUE (name),
    -- g_per_piece je povinné pre ks a zakázané pre g a ml
    CONSTRAINT chk_ingredients_piece    CHECK (
        (base_unit = 'ks' AND g_per_piece IS NOT NULL) OR
        (base_unit != 'ks' AND g_per_piece IS NULL)
    ),
    CONSTRAINT fk_ingredients_category  FOREIGN KEY (category_id)
        REFERENCES ingredient_categories(id),
    CONSTRAINT fk_ingredients_season FOREIGN KEY (season_id)
    REFERENCES seasons(id) ON DELETE SET NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
  COMMENT='Suroviny – základ pre výpočet nutričných hodnôt receptov';

INSERT INTO ingredients (name, base_unit, g_per_piece, category_id, season_id) VALUES
-- Zelenina (category_id=1)
('Paradajky',           'ks',   120,    1, 2),
('Červená cibuľa',      'ks',   130,    1, 5),
('Cesnak',              'ks',   5,      1, 5),
('Mrkva',               'ks',   80,     1, 4),
('Špenát',              'g',    NULL,   1, 1),
('Paprika červená',     'ks',   150,    1, 2),
('Brokolica',           'ks',   350,    1, 3),
('Cuketa',              'ks',   250,    1, 2),
-- Ovocie (category_id=2)
('Citrón',              'ks',   100,    2, 5),
('Avokádo',             'ks',   200,    2, 5),
('Banán',               'ks',   120,    2, 5),
-- Strukoviny (category_id=3)
('Červená šošovica',    'g',    NULL,   3, 5),
('Cícer',               'g',    NULL,   3, 5),
('Čierne fazule',       'g',    NULL,   3, 5),
-- Obilniny (category_id=4)
('Quinoa',              'g',    NULL,   4, 5),
('Ovesné vločky',       'g',    NULL,   4, 5),
('Hnedá ryža',          'g',    NULL,   4, 5),
('Celozrnná múka',      'g',    NULL,   4, 5),
-- Orechy a semienka (category_id=5)
('Kešu oriešky',        'g',    NULL,   5, 5),
('Chia semienka',       'g',    NULL,   5, 5),
('Tahini',              'g',    NULL,   5, 5),
-- Koreniny (category_id=6)
('Kurkuma',             'g',    NULL,   6, 5),
('Kari prášok',         'g',    NULL,   6, 5),
('Rímska rasca',        'g',    NULL,   6, 5),
('Čerstvá bazalka',     'g',    NULL,   6, 2),
-- Oleje (category_id=7)
('Olivový olej',        'ml',   NULL,   7, 5),
('Kokosový olej',       'ml',   NULL,   7, 5),
-- Rastlinné mlieka (category_id=8)
('Kokosové mlieko',     'ml',   NULL,   8, 5),
('Mandľové mlieko',     'ml',   NULL,   8, 5),
('Tofu',                'g',    NULL,   8, 5),
-- Ostatné (category_id=9)
('Sójová omáčka',       'ml',   NULL,   9, 5),
('Javorový sirup',      'ml',   NULL,   9, 5),
('Kakao prášok',        'g',    NULL,   9, 5);


-- -----------------------------------------------------------------------------
-- ingredient_nutrition – nutričné hodnoty surovín (pivot M:N)
-- -----------------------------------------------------------------------------
-- Všetky hodnoty sú na 100 g (alebo 100 ml pre tekuté suroviny).
-- Výhoda pivot prístupu: pridanie nového nutričného ukazovateľa
-- = len INSERT do nutrition_types + INSERT sem. Žiadna zmena schémy.
-- -----------------------------------------------------------------------------
CREATE TABLE ingredient_nutrition (
    ingredient_id       INT UNSIGNED    NOT NULL,
    nutrition_type_id   INT UNSIGNED    NOT NULL,
    value               DECIMAL(8, 2)   NOT NULL
                            COMMENT 'Hodnota na 100g alebo 100ml',
    CONSTRAINT pk_ingredient_nutrition      PRIMARY KEY (ingredient_id, nutrition_type_id),
    CONSTRAINT chk_nutrition_value          CHECK (value >= 0),
    CONSTRAINT fk_nutrition_ingredient      FOREIGN KEY (ingredient_id)
        REFERENCES ingredients(id)     ON DELETE CASCADE,
    CONSTRAINT fk_nutrition_type            FOREIGN KEY (nutrition_type_id)
        REFERENCES nutrition_types(id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
  COMMENT='Nutričné hodnoty surovín na 100g/100ml – flexibilný pivot';

-- Nutričné hodnoty (nutrition_type_id: 1=kcal, 2=bielk, 3=sachar, 4=tuky, 5=vlák, 6=cukry)
INSERT INTO ingredient_nutrition (ingredient_id, nutrition_type_id, value) VALUES
-- Paradajky (id=1)
(1, 1, 18.00), (1, 2, 0.90), (1, 3, 3.90), (1, 4, 0.20), (1, 5, 1.20), (1, 6, 2.60),
-- Červená cibuľa (id=2)
(2, 1, 40.00), (2, 2, 1.10), (2, 3, 9.30), (2, 4, 0.10), (2, 5, 1.70), (2, 6, 4.20),
-- Cesnak (id=3)
(3, 1, 149.00),(3, 2, 6.40), (3, 3, 33.10),(3, 4, 0.50), (3, 5, 2.10), (3, 6, 1.00),
-- Špenát (id=5)
(5, 1, 23.00), (5, 2, 2.90), (5, 3, 3.60), (5, 4, 0.40), (5, 5, 2.20), (5, 6, 0.40),
-- Avokádo (id=10)
(10,1, 160.00),(10,2, 2.00), (10,3, 9.00), (10,4, 14.70),(10,5, 6.70), (10,6, 0.60),
-- Banán (id=11)
(11,1, 89.00), (11,2, 1.10), (11,3, 23.00),(11,4, 0.30), (11,5, 2.60), (11,6, 12.20),
-- Červená šošovica (id=12)
(12,1, 353.00),(12,2, 25.80),(12,3, 60.10),(12,4, 1.10), (12,5, 10.70),(12,6, 2.00),
-- Cícer (id=13)
(13,1, 364.00),(13,2, 19.30),(13,3, 60.70),(13,4, 6.00), (13,5, 17.40),(13,6, 10.70),
-- Quinoa (id=15)
(15,1, 368.00),(15,2, 14.10),(15,3, 64.20),(15,4, 6.10), (15,5, 7.00), (15,6, 0.00),
-- Ovesné vločky (id=16)
(16,1, 389.00),(16,2, 16.90),(16,3, 66.30),(16,4, 6.90), (16,5, 10.60),(16,6, 1.00),
-- Olivový olej (id=25)
(25,1, 884.00),(25,2, 0.00), (25,3, 0.00), (25,4, 100.00),(25,5, 0.00),(25,6, 0.00),
-- Kokosové mlieko (id=27)
(27,1, 230.00),(27,2, 2.30), (27,3, 5.50), (27,4, 23.80),(27,5, 2.20), (27,6, 3.30),
-- Tofu (id=29)
(29,1, 76.00), (29,2, 8.10), (29,3, 1.90), (29,4, 4.80), (29,5, 0.30), (29,6, 0.50),
-- Kakao prášok (id=32)
(32,1, 228.00),(32,2, 19.60),(32,3, 57.90),(32,4, 13.70),(32,5, 33.20),(32,6, 1.80);


-- -----------------------------------------------------------------------------
-- recipes – recepty
-- -----------------------------------------------------------------------------
CREATE TABLE recipes (
    id                  INT UNSIGNED        NOT NULL AUTO_INCREMENT,
    user_id             INT UNSIGNED        NOT NULL,
    difficulty_id       INT UNSIGNED        NOT NULL,
    cooking_method_id   INT UNSIGNED        NOT NULL,
    title               VARCHAR(200)        NOT NULL,
    description         TEXT                NULL,
    instructions        TEXT                NULL,
    servings            TINYINT UNSIGNED    NOT NULL DEFAULT 2
                            COMMENT 'Počet porcií',
    prep_time_min       SMALLINT UNSIGNED   NULL
                            COMMENT 'Čas prípravy v minútach',
    cook_time_min       SMALLINT UNSIGNED   NULL
                            COMMENT 'Čas varenia v minútach',
    is_favorite         BOOLEAN             NOT NULL DEFAULT FALSE,
    created_at          TIMESTAMP           NOT NULL DEFAULT CURRENT_TIMESTAMP,
    updated_at          TIMESTAMP           NOT NULL DEFAULT CURRENT_TIMESTAMP
                            ON UPDATE CURRENT_TIMESTAMP,
    CONSTRAINT pk_recipes               PRIMARY KEY (id),
    CONSTRAINT chk_recipes_servings     CHECK (servings > 0),
    CONSTRAINT chk_recipes_prep         CHECK (prep_time_min IS NULL OR prep_time_min >= 0),
    CONSTRAINT chk_recipes_cook         CHECK (cook_time_min IS NULL OR cook_time_min >= 0),
    CONSTRAINT fk_recipes_user          FOREIGN KEY (user_id)
        REFERENCES users(id),
    CONSTRAINT fk_recipes_difficulty    FOREIGN KEY (difficulty_id)
        REFERENCES difficulties(id),
    CONSTRAINT fk_recipes_method        FOREIGN KEY (cooking_method_id)
        REFERENCES cooking_methods(id),
    FULLTEXT KEY ft_recipes_title (title)
        COMMENT 'Full-text vyhľadávanie podľa názvu receptu'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
  COMMENT='Recepty – hlavná entita aplikácie';

INSERT INTO recipes (user_id, difficulty_id, cooking_method_id, title, description, instructions, servings, prep_time_min, cook_time_min, is_favorite) VALUES
(1, 1, 1,
 'Krémová paradajková polievka',
 'Jednoduchá a výživná polievka z čerstvých paradajok s kokosovým mliekom.',
 '1. Opraž cibuľu a cesnak na oleji.\n2. Pridaj nakrájané paradajky, soľ a korenie.\n3. Duste 10 minút.\n4. Rozmixuj do hladka.\n5. Vlej kokosové mlieko a prihrej.',
 4, 10, 20, TRUE),

(1, 1, 7,
 'Avokádový toast',
 'Rýchle a sýte raňajky. Krémové avokádo na opečenom chlebe.',
 '1. Opraž chlieb.\n2. Avokádo roztlač vidličkou, dochuť soľou a citrónom.\n3. Nanes na chlieb a podávaj.',
 2, 10, 5, FALSE),

(1, 2, 1,
 'Červená šošovica na karí',
 'Sýte aromatické karí s kokosovým mliekom. Ideálne s ryžou.',
 '1. Opraž cibuľu, cesnak, kari a kurkumu.\n2. Pridaj šošovicu a kokosové mlieko.\n3. Var 20 minút do zmäknutia.\n4. Podávaj s ryžou a koriandrom.',
 4, 15, 25, TRUE),

(1, 2, 7,
 'Buddha bowl s tofu a quinoou',
 'Farebná miska plná bielkovín, zdravých tukov a vlákniny.',
 '1. Uvar quinou.\n2. Marinuj tofu v sójovej omáčke a opečie.\n3. Poukladaj do misky so zeleninou a tahini omáčkou.',
 2, 20, 20, FALSE),

(1, 1, 6,
 'Smoothie z banána a mandľového mlieka',
 'Rýchle raňajky alebo desiata plná energie.',
 '1. Všetky ingrediencie daj do mixéra.\n2. Mixuj 1 minútu do hladka.\n3. Ihneď podávaj.',
 2, 5, 0, FALSE);


-- =============================================================================
-- PIVOT TABUĽKY (M:N väzby)
-- =============================================================================

-- -----------------------------------------------------------------------------
-- recipe_ingredients – suroviny receptu s množstvami
-- -----------------------------------------------------------------------------
-- Výpočet kalórií závisí od base_unit suroviny:
--   base_unit = g alebo ml → amount × unit.multiplier / 100 × nutrition_value
--   base_unit = ks         → amount × ingredient.g_per_piece / 100 × nutrition_value
-- -----------------------------------------------------------------------------
CREATE TABLE recipe_ingredients (
    recipe_id       INT UNSIGNED        NOT NULL,
    ingredient_id   INT UNSIGNED        NOT NULL,
    amount          DECIMAL(8, 2)       NOT NULL,
    unit_id         INT UNSIGNED        NOT NULL,
    note            VARCHAR(255)        NULL
                        COMMENT 'Napr. nakrájané, prelisované, bez kôstky...',
    CONSTRAINT pk_recipe_ingredients    PRIMARY KEY (recipe_id, ingredient_id),
    CONSTRAINT chk_ri_amount           CHECK (amount > 0),
    CONSTRAINT fk_ri_recipe             FOREIGN KEY (recipe_id)
        REFERENCES recipes(id)      ON DELETE CASCADE,
    CONSTRAINT fk_ri_ingredient         FOREIGN KEY (ingredient_id)
        REFERENCES ingredients(id)  ON DELETE RESTRICT,
    CONSTRAINT fk_ri_unit               FOREIGN KEY (unit_id)
        REFERENCES units(id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
  COMMENT='Suroviny receptu s množstvami – základ výpočtu kalórií';

-- Recept 1: Paradajková polievka (unit: 1=g, 8=ks, 6=lyžička, 7=lyžica, 4=ml)
INSERT INTO recipe_ingredients (recipe_id, ingredient_id, amount, unit_id, note) VALUES
(1, 1,  4,  9, 'nakrájané'),        -- 4 ks paradajok
(1, 2,  1,  9, 'nakrájaná'),        -- 1 ks cibule
(1, 3,  3,  9, 'prelisovaný'),      -- 3 ks cesnaku
(1, 25, 2,  7, NULL),               -- 2 lyžice olivového oleja
(1, 27, 400,4, NULL);               -- 400 ml kokosového mlieka

-- Recept 2: Avokádový toast
INSERT INTO recipe_ingredients (recipe_id, ingredient_id, amount, unit_id, note) VALUES
(2, 10, 2,  9, 'zrelé'),            -- 2 ks avokáda
(2, 9,  1,  9, NULL),               -- 1 ks citróna
(2, 25, 1,  7, NULL);               -- 1 lyžica olivového oleja

-- Recept 3: Karí so šošovicou
INSERT INTO recipe_ingredients (recipe_id, ingredient_id, amount, unit_id, note) VALUES
(3, 12, 300,1, NULL),               -- 300 g šošovice
(3, 2,  1,  9, 'nakrájaná'),        -- 1 ks cibule
(3, 3,  4,  9, NULL),               -- 4 ks cesnaku
(3, 27, 400,4, NULL),               -- 400 ml kokosového mlieka
(3, 23, 2,  7, NULL),               -- 2 lyžice kari prášku
(3, 22, 1,  6, NULL),               -- 1 lyžička kurkumy
(3, 17, 300,1, 'uvarená'),          -- 300 g ryže
(3, 25, 1,  7, NULL);               -- 1 lyžica kokosového oleja

-- Recept 4: Buddha bowl
INSERT INTO recipe_ingredients (recipe_id, ingredient_id, amount, unit_id, note) VALUES
(4, 15, 150,1, NULL),               -- 150 g quinoy
(4, 29, 200,1, 'nakrájané'),        -- 200 g tofu
(4, 5,  80, 1, NULL),               -- 80 g špenátu
(4, 21, 2,  7, NULL),               -- 2 lyžice tahini
(4, 30, 2,  7, NULL);               -- 2 lyžice sójovej omáčky

-- Recept 5: Smoothie
INSERT INTO recipe_ingredients (recipe_id, ingredient_id, amount, unit_id, note) VALUES
(5, 11, 2,  9, 'zrelé'),            -- 2 ks banánov
(5, 28, 300,4, NULL),               -- 300 ml mandľového mlieka
(5, 20, 1,  7, NULL);               -- 1 lyžica chia semienok


-- -----------------------------------------------------------------------------
-- recipe_category_map – M:N recepty ↔ kategórie receptov
-- -----------------------------------------------------------------------------
CREATE TABLE recipe_category_map (
    recipe_id   INT UNSIGNED    NOT NULL,
    category_id INT UNSIGNED    NOT NULL,
    CONSTRAINT pk_recipe_category_map   PRIMARY KEY (recipe_id, category_id),
    CONSTRAINT fk_rcm_recipe            FOREIGN KEY (recipe_id)
        REFERENCES recipes(id)          ON DELETE CASCADE,
    CONSTRAINT fk_rcm_category          FOREIGN KEY (category_id)
        REFERENCES recipe_categories(id) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
  COMMENT='M:N väzba receptov a kategórií – jeden recept môže mať viac kategórií';

INSERT INTO recipe_category_map (recipe_id, category_id) VALUES
(1, 2),     -- polievka → Polievka
(2, 1),     -- toast → Raňajky
(2, 3),     -- toast → Hlavné jedlo
(3, 3),     -- karí → Hlavné jedlo
(4, 3),     -- buddha bowl → Hlavné jedlo
(4, 4),     -- buddha bowl → Šalát
(5, 1),     -- smoothie → Raňajky
(5, 6);     -- smoothie → Nápoj a smoothie


-- =============================================================================
-- VIEW – výpočet nutričných hodnôt receptu
-- =============================================================================
-- Vzorec závisí od base_unit suroviny:
--   g / ml : amount × unit.multiplier / 100 × nutrition.value
--   ks     : amount × ingredient.g_per_piece / 100 × nutrition.value
--
-- VIEW vráti hodnoty za celý recept aj prepočítané na 1 porciu.
-- =============================================================================
CREATE VIEW recipe_nutrition AS
SELECT
    r.id                                        AS recipe_id,
    r.title,
    r.servings,
    nt.name                                     AS nutrition_name,
    nt.unit                                     AS nutrition_unit,
    ROUND(SUM(
        CASE i.base_unit
            WHEN 'ks' THEN ri.amount * i.g_per_piece  / 100 * n.value
            ELSE           ri.amount * u.multiplier   / 100 * n.value
        END
    ), 2)                                       AS total_value,
    ROUND(SUM(
        CASE i.base_unit
            WHEN 'ks' THEN ri.amount * i.g_per_piece  / 100 * n.value
            ELSE           ri.amount * u.multiplier   / 100 * n.value
        END
    ) / r.servings, 2)                          AS value_per_serving
FROM recipes r
JOIN recipe_ingredients  ri ON ri.recipe_id      = r.id
JOIN ingredients          i ON i.id              = ri.ingredient_id
JOIN units                u ON u.id              = ri.unit_id
JOIN ingredient_nutrition n ON n.ingredient_id   = i.id
JOIN nutrition_types     nt ON nt.id             = n.nutrition_type_id
GROUP BY r.id, r.title, r.servings, nt.id, nt.name, nt.unit
ORDER BY r.id, nt.id;


-- =============================================================================
-- UKÁŽKOVÉ DOPYTY (odkomentuj podľa potreby)
-- =============================================================================

-- 1. Kalórie receptu na porciu
-- SELECT title, servings, total_value AS total_kcal, value_per_serving AS kcal_per_serving
-- FROM recipe_nutrition WHERE nutrition_name = 'Kalórie';

-- 2. Všetky nutričné hodnoty jedného receptu
-- SELECT nutrition_name, nutrition_unit, total_value, value_per_serving
-- FROM recipe_nutrition WHERE recipe_id = 3;

-- 3. Recepty podľa kategórie
-- SELECT r.id, r.title FROM recipes r
-- JOIN recipe_category_map rcm ON rcm.recipe_id = r.id
-- JOIN recipe_categories rc ON rc.id = rcm.category_id
-- WHERE rc.name = 'Hlavné jedlo';

-- 4. Recepty obsahujúce danú surovinu
-- SELECT DISTINCT r.id, r.title FROM recipes r
-- JOIN recipe_ingredients ri ON ri.recipe_id = r.id
-- JOIN ingredients i ON i.id = ri.ingredient_id
-- WHERE i.name = 'Červená šošovica';

-- 5. Full-text vyhľadávanie receptov
-- SELECT id, title FROM recipes
-- WHERE MATCH(title) AGAINST('paradajková' IN NATURAL LANGUAGE MODE);

-- 6. Obľúbené recepty
-- SELECT id, title, prep_time_min, cook_time_min FROM recipes
-- WHERE is_favorite = TRUE;

-- 7. Sezónne suroviny (napríklad letné)
-- SELECT i.name, ic.name AS kategoria FROM ingredients i
-- JOIN ingredient_categories ic ON ic.id = i.category_id
-- JOIN seasons s ON s.id = i.season_id
-- WHERE s.name = 'Leto';

-- 8. Recepty podľa spôsobu prípravy
-- SELECT r.title, d.name AS obtiznost FROM recipes r
-- JOIN cooking_methods cm ON cm.id = r.cooking_method_id
-- JOIN difficulties d ON d.id = r.difficulty_id
-- WHERE cm.name = 'Varenie';
-- =============================================================================

$pdo = new PDO($dsn, $username, $password, $options);

// $dsn      — Data Source Name — reťazec s adresou a názvom databázy
// $username — používateľské meno pre MySQL
// $password — heslo
// $options  — pole s nastaveniami správania (voliteľné, ale vždy ho píšeme)

"mysql:host=ADRESA;dbname=DATABAZA;charset=utf8mb4"

// Príklady:
"mysql:host=localhost;dbname=vegan;charset=utf8mb4"   // lokálny server
"mysql:host=db;dbname=vegan;charset=utf8mb4"          // Docker kontajner 'db'

// Keby sme prešli na PostgreSQL — zmeníme len tento riadok:
"pgsql:host=db;dbname=vegan"                          // zvyšok kódu ostane rovnaký

$options = [
    // Ako PDO hlási chyby
    // ERRMODE_EXCEPTION = pri chybe hodí výnimku → skočí do catch bloku
    // Alternatívy (nepoužívame):
    //   ERRMODE_SILENT  — chyby ticho ignoruje (nebezpečné)
    //   ERRMODE_WARNING — vypíše varovanie ale pokračuje
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,

    // Formát v akom fetch() vracia riadky
    // FETCH_ASSOC = asociatívne pole — rovnaký výsledok ako fetch_assoc() v MySQLi
    //   $row['title'], $row['id'], $row['name']...
    // Alternatívy:
    //   FETCH_NUM  — číselné indexy: $row[0], $row[1]...
    //   FETCH_OBJ  — objekt: $row->title, $row->id...
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,

    // Skutočné vs. emulované prepared statements
    // false = PDO pošle prepared statement priamo do MySQL — maximálna bezpečnosť
    // true  = PDO ich emuluje samo v PHP — menej bezpečné, starší spôsob
    PDO::ATTR_EMULATE_PREPARES => false,
];

$pdo->query($sql)       // spustí SQL bez parametrov — vráti PDOStatement
                        // použijeme keď SQL neobsahuje žiadne externé hodnoty

$pdo->prepare($sql)     // pripraví SQL šablónu s placeholdermi — vráti PDOStatement
                        // použijeme vždy keď SQL obsahuje hodnoty od používateľa

$pdo->lastInsertId()    // vráti AUTO_INCREMENT id posledného INSERT
                        // obdoba $conn->insert_id v MySQLi

$pdo->beginTransaction() // začne transakciu — zmeny sa uložia až po commit()
$pdo->commit()           // potvrdí transakciu — uloží zmeny
$pdo->rollBack()         // zruší transakciu — vráti späť všetky zmeny

// ── Pre prepared statements ───────────────────────────────
$stmt->execute($params)  // spustí prepared statement, dosadí hodnoty za placeholdery
                         // $params = asociatívne pole [':placeholder' => hodnota]
                         // alebo indexované pole pre ? placeholdery

// ── Načítanie výsledkov ───────────────────────────────────
$stmt->fetch()           // vráti jeden riadok ako asociatívne pole — alebo FALSE
                         // obdoba fetch_assoc() v MySQLi

$stmt->fetchAll()        // vráti VŠETKY riadky naraz ako pole polí
                         // obdoba while(fetch_assoc()) — ale všetko naraz do poľa

$stmt->fetchColumn()     // vráti hodnotu prvého stĺpca prvého riadku
                         // užitočné pre COUNT(*), MAX(id)...

// ── Informácie o výsledku ─────────────────────────────────
$stmt->rowCount()        // počet riadkov ovplyvnených INSERT / UPDATE / DELETE
                         // pre SELECT nie je spoľahlivé — na to použiť count(fetchAll())

// Jeden riadok
$result->fetch_assoc()         →   $stmt->fetch()

// Všetky riadky
while($r = $res->fetch_assoc())  →   $stmt->fetchAll()

// Počet riadkov
$result->num_rows              →   $stmt->rowCount()   // pozri poznámku vyššie

// Posledné INSERT id
$conn->insert_id               →   $pdo->lastInsertId()

try {
    // Skús vykonať tento kód
    $pdo = new PDO($dsn, DB_USER, DB_PASS, $options);

    // Ak sa dostaneme sem — všetko prebehlo bez chyby

} catch (PDOException $e) {
    // Sem skočíme ak new PDO() zlyhalo
    // $e je objekt triedy PDOException

    echo $e->getMessage();   // text popisujúci chybu
    echo $e->getCode();      // číslo chyby
}

<?php
// ── 1. Konštanty — údaje o serveri ────────────────────────
//
//  define('NAZOV', 'hodnota') vytvorí konštantu.
//  Konštanta sa od premennej líši tromi vecami:
//    - nezačína dolárikom
//    - hodnotu nemožno zmeniť počas behu skriptu
//    - platí všade — aj vo vnútri tried a funkcií
//      (premennú by sme museli posielať ako parameter)

define('DB_HOST',    'db');        // názov Docker kontajnera — bez Dockeru: 'localhost'
define('DB_NAME',    'vegan');     // názov databázy — musí existovať v MySQL
define('DB_USER',    'root');      // používateľské meno pre MySQL
define('DB_PASS',    'root');      // heslo — v produkcii nikdy 'root'
define('DB_CHARSET', 'utf8mb4');   // utf8mb4 = plná podpora diakritiky aj emoji

// ── 2. DSN — Data Source Name ─────────────────────────────
//  Reťazec ktorý hovorí PDO: akú databázu, kde beží server,
//  aké kódovanie. Každá databáza má iný formát DSN.
//  Výsledok: "mysql:host=db;dbname=vegan;charset=utf8mb4"

$dsn = "mysql:host=" . DB_HOST . ";dbname=" . DB_NAME . ";charset=" . DB_CHARSET;

// ── 3. Options — nastavenia správania PDO ─────────────────
//  Asociatívne pole: kľúč = čo nastavujeme, hodnota = ako.
//  Tieto tri riadky píšeme vždy — sú to best practices.

$options = [
    PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION, // chyby ako výnimky
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,       // fetch vracia asociatívne pole
    PDO::ATTR_EMULATE_PREPARES   => false,                  // skutočné prepared statements
];

// ── 4. Vytvorenie PDO objektu ─────────────────────────────
//  Na rozdiel od MySQLi — PDO pri chybe HODÍ výnimku.
//  Preto pripojenie zabalíme do try/catch.

try {
    $pdo = new PDO($dsn, DB_USER, DB_PASS, $options);
    // echo "✅ PDO pripojenie úspešné"; // odkomentuj na testovanie

} catch (PDOException $e) {
    // ⚠️ Toto vypíšeme len počas vývoja — nie v produkcii!
    die("❌ Chyba pripojenia: " . $e->getMessage());
}
// Po tomto riadku je $pdo dostupné v celom skripte.

// Keď napíšeme toto...
$model = new DifficultyModel($pdo);

// PHP automaticky zavolá toto:
public function __construct(PDO $pdo)
{
    $this->pdo = $pdo;   // uloží $pdo do vlastnosti objektu
}

// $this znamená "tento konkrétny objekt"
// rovnako ako $conn odkazoval na konkrétne MySQLi pripojenie

-- Len id a name — ideálny základ pre prvý model
┌────┬──────────┐
│ id │ name     │
├────┼──────────┤
│  1 │ Ľahký    │
│  2 │ Stredný  │
│  3 │ Náročný  │
└────┴──────────┘

<?php
class DifficultyModel
{
    // ── Vlastnosť ─────────────────────────────────────────
    //  Uchováva PDO objekt cez ktorý všetky metódy komunikujú s DB.
    //  Typ PDO = sem môže ísť JEDINE objekt triedy PDO, nič iné.
    //  Zatiaľ public — v T04 (Zapuzdrenie) zmeníme na private.
    public PDO $pdo;

    // ── Konštruktor ───────────────────────────────────────
    //  Zavolá sa automaticky pri:  $model = new DifficultyModel($pdo);
    //  Parameter $pdo dostane náš objekt pripojenia z connect.php
    //  a uloží ho do vlastnosti $this->pdo.
    public function __construct(PDO $pdo)
    {
        $this->pdo = $pdo;
    }

    // ── getAll() ─────────────────────────────────────────
    //  Vráti všetky záznamy z tabuľky difficulties.
    //  query() — SQL bez parametrov, žiadne riziko SQL Injection.
    //  fetchAll() — všetky riadky naraz do poľa.
    public function getAll(): array
    {
        $stmt = $this->pdo->query(
            "SELECT id, name FROM difficulties ORDER BY id"
        );
        return $stmt->fetchAll();
        // Vráti:
        // [
        //   ['id' => 1, 'name' => 'Ľahký'],
        //   ['id' => 2, 'name' => 'Stredný'],
        //   ['id' => 3, 'name' => 'Náročný'],
        // ]
    }

    // ── getById() ────────────────────────────────────────
    //  Vráti jeden záznam podľa ID.
    //  prepare() + execute() — ID prichádza zvonku, musíme použiť
    //  prepared statement (ochrana pred SQL Injection).
    //  fetch() — jeden riadok alebo FALSE ak nenájdený.
    public function getById(int $id): array|false
    {
        $stmt = $this->pdo->prepare(
            "SELECT id, name FROM difficulties WHERE id = :id"
        );
        $stmt->execute([':id' => $id]);
        return $stmt->fetch();
    }

    // ── getCount() ───────────────────────────────────────
    //  Vráti počet záznamov v tabuľke.
    //  fetchColumn() — vráti hodnotu prvého stĺpca prvého riadku.
    //  Ideálne pre COUNT(*) ktorý vždy vráti jedno číslo.
    public function getCount(): int
    {
        $stmt = $this->pdo->query(
            "SELECT COUNT(*) FROM difficulties"
        );
        return (int) $stmt->fetchColumn();
        // (int) pretypuje výsledok na celé číslo
    }
}

<?php
require_once 'connect.php';          // vytvorí $pdo
require_once 'DifficultyModel.php';  // načíta triedu

// Vytvoríme objekt — konštruktor dostane $pdo
// PHP zavolá __construct($pdo) automaticky
$model = new DifficultyModel($pdo);

// ── Všetky záznamy ────────────────────────────────────────
$difficulties = $model->getAll();    // vráti pole

echo "<h2>Obtiažnosti (" . $model->getCount() . ")</h2>";

foreach ($difficulties as $row) {
    echo $row['id'] . " — " . $row['name'] . "<br>";
}

// ── Jeden záznam ──────────────────────────────────────────
$one = $model->getById(2);

if ($one) {
    echo "Našiel som: " . $one['name'];
} else {
    echo "Záznam neexistuje.";
}

public function getAllWithDifficulty(): array
{
    $stmt = $this->pdo->query(
        "SELECT
             r.id,
             r.title,
             r.servings,
             r.prep_time_min,
             d.name AS difficulty      -- AS = alias, premenujeme stĺpec vo výsledku
         FROM recipes r                -- r = alias pre tabuľku recipes
         INNER JOIN difficulties d     -- d = alias pre tabuľku difficulties
             ON d.id = r.difficulty_id -- podmienka spojenia: cudzí kľúč = primárny kľúč
         ORDER BY r.id"
    );
    return $stmt->fetchAll();
    // Každý riadok výsledku bude:
    // ['id' => 1, 'title' => 'Karí...', 'servings' => 4, 'prep_time_min' => 15, 'difficulty' => 'Stredný']
}

CREATE TABLE recipes (
    id            INT UNSIGNED NOT NULL AUTO_INCREMENT,
    difficulty_id INT UNSIGNED NOT NULL,

    CONSTRAINT pk_recipes            PRIMARY KEY (id),
    CONSTRAINT fk_recipes_difficulty FOREIGN KEY (difficulty_id)
        REFERENCES difficulties(id)
        ON DELETE RESTRICT          -- ← pravidlo pre mazanie
) ENGINE=InnoDB;

-- CONSTRAINT meno_constraintu  TYP_CONSTRAINTU  (stĺpec)
-- Meno je ľubovoľné — píšeme ho preto aby sme vedeli
-- čo presne zlyhalo keď databáza hlási chybu.

-- Príklad: zmažem recept → automaticky sa zmažú aj jeho ingrediencie
CREATE TABLE recipe_ingredients (
    recipe_id     INT UNSIGNED NOT NULL,
    ingredient_id INT UNSIGNED NOT NULL,

    CONSTRAINT fk_ri_recipe FOREIGN KEY (recipe_id)
        REFERENCES recipes(id)
        ON DELETE CASCADE      -- keď zmažem recept, recipe_ingredients sa zmažú sami
);

-- Príklad: chcem zmazať obtiažnosť "Ľahký" ale existujú recepty ktoré ju používajú
CREATE TABLE recipes (
    difficulty_id INT UNSIGNED NOT NULL,

    CONSTRAINT fk_recipes_difficulty FOREIGN KEY (difficulty_id)
        REFERENCES difficulties(id)
        ON DELETE RESTRICT     -- databáza odmietne DELETE ak nejaký recept má difficulty_id = toto id
                               -- RESTRICT je DEFAULT — ak ON DELETE vynecháme, platí RESTRICT
);

-- Príklad: zmažem sezónu "Leto" → surovina ostane, len season_id sa nastaví na NULL
CREATE TABLE ingredients (
    season_id INT UNSIGNED NULL,   -- ← stĺpec MUSÍ byť NULL-able!

    CONSTRAINT fk_ingredients_season FOREIGN KEY (season_id)
        REFERENCES seasons(id)
        ON DELETE SET NULL   -- keď zmažem sezónu, suroviny ostanú bez sezóny (NULL)
                             -- nie sú zmazané, len stratia väzbu
);

-- Závislé záznamy nemajú zmysel bez rodiča   →   ON DELETE CASCADE
--   recipe_ingredients bez recipes
--   recipe_category_map bez recipes

-- Číselník, nesmie sa zmazať ak ho niekto používa  →   ON DELETE RESTRICT (default)
--   difficulties mazáme? Nie kým ju recept používa.
--   cooking_methods, recipe_categories — to isté.

-- Vzťah je voliteľný, záznam má zmysel aj bez väzby  →   ON DELETE SET NULL
--   ingredients.season_id — surovina bez sezóny je ok
--   recipes.cooking_method_id — keby bolo voliteľné

$model = new DifficultyModel($pdo);

// ⚠️ Toto PHP dovolí — public vlastnosť je prístupná odkiaľkoľvek
$model->pdo = null;       // omylom prepíšeme pripojenie
$model->pdo = $inePdo;    // omylom dosadíme iný objekt

// Výsledok: pri ďalšom volaní metódy model spadne
// a chybu budeme hľadať dlho lebo nie je zrejmé kde nastala
$model->getAll();  // ❌ spadne — ale prečo?

class DifficultyModel
{
    private PDO $pdo;   // ← zmenené z public na private

    public function __construct(PDO $pdo)
    {
        $this->pdo = $pdo;  // zvnútra triedy — OK
    }
}

$model = new DifficultyModel($pdo);
$model->pdo = null;   // ❌ Error: Cannot access private property DifficultyModel::$pdo
echo $model->pdo;     // ❌ Error: Cannot access private property DifficultyModel::$pdo
// PHP okamžite ukáže kde je chyba — nemusíme hádať

class DifficultyModel
{
    public    string $name;      // dostupná odkiaľkoľvek — zvonku, v triede, v potomkoch
    protected PDO    $pdo;       // dostupná len v triede a jej potomkoch (dedenie — T05)
    private   int    $callCount; // dostupná len vo vnútri tejto triedy — nikde inde
}

class DifficultyModel
{
    private PDO $pdo;

    // ── private pomocná metóda ────────────────────────────
    // Volá ju len táto trieda — zvonku nie je dostupná
    // Overí či názov nie je prázdny a vráti očistený reťazec
    private function validateName(string $name): string
    {
        $name = trim($name);  // odstráni medzery zo začiatku a konca

        if ($name === '') {
            throw new InvalidArgumentException("Názov nesmie byť prázdny.");
        }

        return $name;
    }

    // ── public metódy volajú validateName() interne ───────
    public function insert(string $name): int
    {
        $name = $this->validateName($name);  // overíme pred INSERT

        $stmt = $this->pdo->prepare(
            "INSERT INTO difficulties (name) VALUES (:name)"
        );
        $stmt->execute([':name' => $name]);
        return (int) $this->pdo->lastInsertId();
    }

    public function update(int $id, string $name): bool
    {
        $name = $this->validateName($name);  // overíme pred UPDATE

        $stmt = $this->pdo->prepare(
            "UPDATE difficulties SET name = :name WHERE id = :id"
        );
        $stmt->execute([':name' => $name, ':id' => $id]);
        return $stmt->rowCount() > 0;
    }
}

class MojaTrieda
{
    private string $nazov;
    private int    $pocet;

    // ── GETTER — čítanie private vlastnosti ───────────────
    // Názov: get + názov vlastnosti s veľkým začiatočným písmenom
    // Nemá parametre, návratový typ = typ vlastnosti
    public function getNazov(): string
    {
        return $this->nazov;
    }

    // ── SETTER — zápis s validáciou ───────────────────────
    // Názov: set + názov vlastnosti s veľkým začiatočným písmenom
    // Má jeden parameter — novú hodnotu
    // Návratový typ void = nič nevracia
    public function setPocet(int $pocet): void
    {
        if ($pocet < 0) {
            throw new InvalidArgumentException("Počet nesmie byť záporný.");
        }
        $this->pocet = $pocet;
    }
}

// Použitie zvonku:
$obj = new MojaTrieda();
$obj->getNazov();       // ✅ getter — čítanie OK
$obj->setPocet(5);      // ✅ setter — zápis cez metódu OK
$obj->nazov = "hack";   // ❌ Error: Cannot access private property

$model = new DifficultyModel($pdo);
echo $model;  // ❌ Error: Object of class DifficultyModel
              //    could not be converted to string

class DifficultyModel
{
    private PDO $pdo;

    // PHP zavolá túto metódu automaticky keď použijeme echo $model
    public function __toString(): string
    {
        return "DifficultyModel | záznamy: " . $this->getCount();
    }
}

$model = new DifficultyModel($pdo);
echo $model;  // ✅ Vypíše: DifficultyModel | záznamy: 3

class PrikladovaTrieda
{
    private array $data = [];

    // Zavolá sa keď čítame vlastnosť ktorá neexistuje
    public function __get(string $name): mixed
    {
        return $this->data[$name] ?? null;
    }

    // Zavolá sa keď zapisujeme vlastnosť ktorá neexistuje
    public function __set(string $name, mixed $value): void
    {
        $this->data[$name] = $value;
    }
}

$obj = new PrikladovaTrieda();
$obj->color = "green";    // zavolá __set('color', 'green')
echo $obj->color;         // zavolá __get('color') → vypíše: green

public function __destruct()
{
    // Zavolá sa keď objekt zanikne
    // Napr. na zatvorenie súboru, uvoľnenie zdrojov
    // PDO to robí samo — my tu nič nepíšeme
}

<?php
class DifficultyModel
{
    private PDO $pdo;

    public function __construct(PDO $pdo)
    {
        $this->pdo = $pdo;
    }

    public function __toString(): string
    {
        return "DifficultyModel | záznamy: " . $this->getCount();
    }

    // ── READ ──────────────────────────────────────────────

    public function getAll(): array
    {
        $stmt = $this->pdo->query(
            "SELECT id, name FROM difficulties ORDER BY id"
        );
        return $stmt->fetchAll();
    }

    public function getById(int $id): array|false
    {
        $stmt = $this->pdo->prepare(
            "SELECT id, name FROM difficulties WHERE id = :id"
        );
        $stmt->execute([':id' => $id]);
        return $stmt->fetch();
    }

    public function getCount(): int
    {
        $stmt = $this->pdo->query("SELECT COUNT(*) FROM difficulties");
        return (int) $stmt->fetchColumn();
    }

    // Počet receptov pre každú obtiažnosť
    public function countRecipes(): array
    {
        $stmt = $this->pdo->query(
            "SELECT d.id, d.name, COUNT(r.id) AS recipe_count
             FROM difficulties d
             LEFT JOIN recipes r ON r.difficulty_id = d.id
             GROUP BY d.id, d.name
             ORDER BY d.id"
        );
        return $stmt->fetchAll();
        // Vráti:
        // [['id'=>1, 'name'=>'Ľahký',   'recipe_count'=>3],
        //  ['id'=>2, 'name'=>'Stredný', 'recipe_count'=>5], ...]
    }

    // ── INSERT ────────────────────────────────────────────

    public function insert(string $name): int
    {
        $stmt = $this->pdo->prepare(
            "INSERT INTO difficulties (name) VALUES (:name)"
        );
        $stmt->execute([':name' => trim($name)]);
        return (int) $this->pdo->lastInsertId();
    }

    // ── UPDATE ────────────────────────────────────────────

    public function update(int $id, string $name): bool
    {
        $stmt = $this->pdo->prepare(
            "UPDATE difficulties SET name = :name WHERE id = :id"
        );
        $stmt->execute([':name' => trim($name), ':id' => $id]);
        return $stmt->rowCount() > 0;
        // rowCount() = počet zmenených riadkov
        // true ak sa niečo zmenilo, false ak id neexistovalo
    }

    // ── DELETE ────────────────────────────────────────────
    //
    //  POZOR: ak obtiažnosť používa nejaký recept,
    //  databáza hodí výnimku (RESTRICT constraint).
    //  Zachytíme ju v try/catch v ciselniky.php — nie tu.
    //  Model nech hodí výnimku ďalej — volajúci kód sa rozhodne čo s ňou.

    public function delete(int $id): bool
    {
        $stmt = $this->pdo->prepare(
            "DELETE FROM difficulties WHERE id = :id"
        );
        $stmt->execute([':id' => $id]);
        return $stmt->rowCount() > 0;
    }
}

<?php
class CookingMethodModel
{
    private PDO $pdo;

    public function __construct(PDO $pdo) { $this->pdo = $pdo; }
    public function __toString(): string  { return "CookingMethodModel | záznamy: " . $this->getCount(); }

    public function getAll(): array        { /* SELECT id, name FROM cooking_methods */ }
    public function getById(int $id)       { /* WHERE id = :id */ }
    public function getCount(): int        { /* COUNT(*) FROM cooking_methods */ }
    public function countRecipes(): array  { /* LEFT JOIN recipes ON cooking_method_id */ }
    public function insert(string $name)   { /* INSERT */ }
    public function update(int $id, string $name) { /* UPDATE */ }
    public function delete(int $id)        { /* DELETE */ }
}

<?php
require_once 'connect.php';
require_once 'DifficultyModel.php';
require_once 'CookingMethodModel.php';
require_once 'RecipeCategoryModel.php';
require_once 'IngredientCategoryModel.php';

// ── 1. Vyberieme model podľa GET parametra ────────────────
$modelKey = $_GET['model'] ?? 'difficulty';

$model = match($modelKey) {
    'difficulty'   => new DifficultyModel($pdo),
    'cooking'      => new CookingMethodModel($pdo),
    'category'     => new RecipeCategoryModel($pdo),
    'ingredient'   => new IngredientCategoryModel($pdo),
    default        => new DifficultyModel($pdo),
};

// ── 2. Spracujeme akciu ───────────────────────────────────
$action  = $_GET['action'] ?? 'list';
$message = '';

if ($action === 'delete' && isset($_GET['id'])) {
    try {
        $model->delete((int) $_GET['id']);
        $message = "✅ Záznam bol zmazaný.";
    } catch (PDOException $e) {
        // RESTRICT constraint — databáza nedovolí zmazanie
        $message = "❌ Nedá sa zmazať — záznam používajú recepty.";
    }
    $action = 'list';  // po akcii zobrazíme zoznam
}

if ($action === 'insert' && isset($_POST['name'])) {
    $model->insert($_POST['name']);
    $message = "✅ Záznam bol pridaný.";
    $action  = 'list';
}

if ($action === 'update' && isset($_POST['name'], $_POST['id'])) {
    $model->update((int) $_POST['id'], $_POST['name']);
    $message = "✅ Záznam bol upravený.";
    $action  = 'list';
}

// ── 3. Načítame dáta ──────────────────────────────────────
$items     = $model->getAll();
$editItem  = null;

if ($action === 'edit' && isset($_GET['id'])) {
    $editItem = $model->getById((int) $_GET['id']);
}
?>

<!-- ── Navigácia medzi číselníkmi ── -->
<nav style="margin-bottom:1rem">
    <a href="?model=difficulty">Obtiažnosti</a> |
    <a href="?model=cooking">Spôsoby prípravy</a> |
    <a href="?model=category">Kategórie receptov</a> |
    <a href="?model=ingredient">Kategórie surovín</a>
</nav>

<?php if ($message): ?>
    <p><?= $message ?></p>
<?php endif; ?>

<!-- ── Formulár na pridanie / úpravu ── -->
<?php if ($action === 'edit' && $editItem): ?>
    <form method="post" action="?model=<?= $modelKey ?>&action=update">
        <input type="hidden" name="id" value="<?= $editItem['id'] ?>">
        <input type="text"   name="name" value="<?= $editItem['name'] ?>">
        <button type="submit">Uložiť</button>
        <a href="?model=<?= $modelKey ?>">Zrušiť</a>
    </form>
<?php else: ?>
    <form method="post" action="?model=<?= $modelKey ?>&action=insert">
        <input type="text" name="name" placeholder="Nová hodnota...">
        <button type="submit">+ Pridať</button>
    </form>
<?php endif; ?>

<!-- ── Tabuľka hodnôt ── -->
<table border="1" cellpadding="6">
    <tr><th>ID</th><th>Názov</th><th>Akcie</th></tr>
    <?php foreach ($items as $item): ?>
    <tr>
        <td><?= $item['id'] ?></td>
        <td><?= $item['name'] ?></td>
        <td>
            <a href="?model=<?= $modelKey ?>&action=edit&id=<?= $item['id'] ?>">✏️ Upraviť</a>
            <a href="?model=<?= $modelKey ?>&action=delete&id=<?= $item['id'] ?>"
               onclick="return confirm('Naozaj zmazať?')">🗑️ Zmazať</a>
        </td>
    </tr>
    <?php endforeach; ?>
</table>

<?php
// ============================================================
//  BaseModel — spoločný základ pre všetky číselníkové modely
//  T05: DifficultyModel, CookingMethodModel... budú z neho dediť
// ============================================================

class BaseModel
{
    // protected = dostupné v tejto triede AJ v potomkoch
    // private   = dostupné len v tejto triede — potomkovia by ho nevideli
    protected PDO    $pdo;
    protected string $table;   // každý potomok nastaví svoj názov tabuľky

    public function __construct(PDO $pdo)
    {
        $this->pdo = $pdo;
    }

    public function getAll(): array
    {
        $stmt = $this->pdo->query(
            "SELECT id, name FROM {$this->table} ORDER BY id"
        );
        return $stmt->fetchAll();
    }

    public function getById(int $id): array|false
    {
        $stmt = $this->pdo->prepare(
            "SELECT id, name FROM {$this->table} WHERE id = :id"
        );
        $stmt->execute([':id' => $id]);
        return $stmt->fetch();
    }

    public function getCount(): int
    {
        $stmt = $this->pdo->query(
            "SELECT COUNT(*) FROM {$this->table}"
        );
        return (int) $stmt->fetchColumn();
    }

    public function insert(string $name): int
    {
        $stmt = $this->pdo->prepare(
            "INSERT INTO {$this->table} (name) VALUES (:name)"
        );
        $stmt->execute([':name' => trim($name)]);
        return (int) $this->pdo->lastInsertId();
    }

    public function update(int $id, string $name): bool
    {
        $stmt = $this->pdo->prepare(
            "UPDATE {$this->table} SET name = :name WHERE id = :id"
        );
        $stmt->execute([':name' => trim($name), ':id' => $id]);
        return $stmt->rowCount() > 0;
    }

    public function delete(int $id): bool
    {
        $stmt = $this->pdo->prepare(
            "DELETE FROM {$this->table} WHERE id = :id"
        );
        $stmt->execute([':id' => $id]);
        return $stmt->rowCount() > 0;
    }
}

// ── V T05 prepíšeme modely takto: ────────────────────────────
//
// class DifficultyModel extends BaseModel
// {
//     protected string $table = 'difficulties';
//
//     // getAll, getById, getCount, insert, update, delete
//     // sú zdedené z BaseModel — nepíšeme ich znova
//
//     // Pridáme len to čo je špecifické pre tento model:
//     public function countRecipes(): array { ... }
// }

class DifficultyModel
{
    private PDO $pdo;
    public function __construct(PDO $pdo) { $this->pdo = $pdo; }
    public function getAll(): array        { /* SELECT ... FROM difficulties */ }
    public function getById(int $id)       { /* WHERE id = :id */ }
    public function getCount(): int        { /* COUNT(*) FROM difficulties */ }
    public function insert(string $name)   { /* INSERT INTO difficulties */ }
    public function update(int $id, ...)   { /* UPDATE difficulties */ }
    public function delete(int $id)        { /* DELETE FROM difficulties */ }
}

class CookingMethodModel
{
    private PDO $pdo;
    public function __construct(PDO $pdo) { $this->pdo = $pdo; }
    public function getAll(): array        { /* SELECT ... FROM cooking_methods */ }
    public function getById(int $id)       { /* WHERE id = :id */ }
    public function getCount(): int        { /* COUNT(*) FROM cooking_methods */ }
    public function insert(string $name)   { /* INSERT INTO cooking_methods */ }
    public function update(int $id, ...)   { /* UPDATE cooking_methods */ }
    public function delete(int $id)        { /* DELETE FROM cooking_methods */ }
}

// ... a ďalšie 2 modely — rovnaká štruktúra, len iný názov tabuľky

class Potomok extends Rodic
{
    // Potomok zdedí všetko z Rodic
    // Tu dopíšeme len to čo je špecifické pre Potomok
}

// Rodič — spoločný základ pre všetky číselníkové modely
class BaseModel
{
    protected PDO    $pdo;
    protected string $table;   // každý potomok nastaví svoju tabuľku

    public function __construct(PDO $pdo)
    {
        $this->pdo = $pdo;
    }

    public function getAll(): array
    {
        $stmt = $this->pdo->query(
            "SELECT id, name FROM {$this->table} ORDER BY id"
        );
        return $stmt->fetchAll();
    }

    // ... getById, getCount, insert, update, delete
}

// Potomok — zdedí všetko z BaseModel, nastaví len svoju tabuľku
class DifficultyModel extends BaseModel
{
    protected string $table = 'difficulties';
    // getAll, getById, getCount, insert, update, delete sú zdedené
    // — nepíšeme ich znova
}

class CookingMethodModel extends BaseModel
{
    protected string $table = 'cooking_methods';
    // rovnaké metódy zdedené — nič viac nepíšeme
}

class Zviera
{
    protected string $meno;

    public function __construct(string $meno)
    {
        $this->meno = $meno;  // rodič nastaví meno
    }

    public function predstavSa(): string
    {
        return "Volám sa " . $this->meno;
    }
}

// Potomok BEZ vlastného konštruktora — zdedí rodiča automaticky
class Pes extends Zviera
{
    // konštruktor nepíšeme — zavolá sa Zviera::__construct() automaticky
}

$pes = new Pes("Rex");
echo $pes->predstavSa();  // ✅ Volám sa Rex

// ─────────────────────────────────────────────────────────────

// Potomok S vlastným konštruktorom — musí zavolať rodiča
class Macka extends Zviera
{
    private string $farba;

    public function __construct(string $meno, string $farba)
    {
        parent::__construct($meno);  // ← zavolá Zviera::__construct()
        $this->farba = $farba;       // potom nastaví čo Macka potrebuje navyše
    }

    public function predstavSa(): string
    {
        return "Volám sa " . $this->meno . " a som " . $this->farba;
    }
}

$macka = new Macka("Micka", "čierna");
echo $macka->predstavSa();  // ✅ Volám sa Micka a som čierna

// ─────────────────────────────────────────────────────────────

// Čo sa stane keď zabudneme zavolať parent::__construct()
class ZlaMacka extends Zviera
{
    private string $farba;

    public function __construct(string $meno, string $farba)
    {
        // zabudli sme parent::__construct($meno)
        $this->farba = $farba;
    }
}

$zla = new ZlaMacka("Micka", "čierna");
echo $zla->predstavSa();  // ❌ Volám sa   ← $meno nie je nastavené

// DifficultyModel nepotrebuje vlastný konštruktor
// — zdedí BaseModel::__construct(PDO $pdo) automaticky
class DifficultyModel extends BaseModel
{
    protected string $table = 'difficulties';
}

// Ak by DifficultyModel potreboval niečo navyše:
class DifficultyModel extends BaseModel
{
    protected string $table = 'difficulties';

    public function __construct(PDO $pdo)
    {
        parent::__construct($pdo);  // ← nastaví $this->pdo
        // tu môžeme pridať čokoľvek navyše
    }
}

class DifficultyModel extends BaseModel
{
    protected string $table = 'difficulties';

    // getAll, getById, getCount, insert, update, delete — zdedené z BaseModel
    // countRecipes() nie je v BaseModel — dopíšeme ju tu

    public function countRecipes(): array
    {
        $stmt = $this->pdo->query(
            "SELECT d.id, d.name, COUNT(r.id) AS recipe_count
             FROM difficulties d
             LEFT JOIN recipes r ON r.difficulty_id = d.id
             GROUP BY d.id, d.name
             ORDER BY d.id"
        );
        return $stmt->fetchAll();
    }
}

class CookingMethodModel extends BaseModel
{
    protected string $table = 'cooking_methods';

    // Iný JOIN — prepojenie cez cooking_method_id
    public function countRecipes(): array
    {
        $stmt = $this->pdo->query(
            "SELECT m.id, m.name, COUNT(r.id) AS recipe_count
             FROM cooking_methods m
             LEFT JOIN recipes r ON r.cooking_method_id = m.id
             GROUP BY m.id, m.name
             ORDER BY m.id"
        );
        return $stmt->fetchAll();
    }
}

<?php
class BaseModel
{
    protected PDO    $pdo;
    protected string $table;

    public function __construct(PDO $pdo)
    {
        $this->pdo = $pdo;
    }

    public function getAll(): array
    {
        $stmt = $this->pdo->query(
            "SELECT id, name FROM {$this->table} ORDER BY id"
        );
        return $stmt->fetchAll();
    }

    public function getById(int $id): array|false
    {
        $stmt = $this->pdo->prepare(
            "SELECT id, name FROM {$this->table} WHERE id = :id"
        );
        $stmt->execute([':id' => $id]);
        return $stmt->fetch();
    }

    public function getCount(): int
    {
        $stmt = $this->pdo->query(
            "SELECT COUNT(*) FROM {$this->table}"
        );
        return (int) $stmt->fetchColumn();
    }

    public function insert(string $name): int
    {
        $name = $this->validateName($name);
        $stmt = $this->pdo->prepare(
            "INSERT INTO {$this->table} (name) VALUES (:name)"
        );
        $stmt->execute([':name' => $name]);
        return (int) $this->pdo->lastInsertId();
    }

    public function update(int $id, string $name): bool
    {
        $name = $this->validateName($name);
        $stmt = $this->pdo->prepare(
            "UPDATE {$this->table} SET name = :name WHERE id = :id"
        );
        $stmt->execute([':name' => $name, ':id' => $id]);
        return $stmt->rowCount() > 0;
    }

    public function delete(int $id): bool
    {
        $stmt = $this->pdo->prepare(
            "DELETE FROM {$this->table} WHERE id = :id"
        );
        $stmt->execute([':id' => $id]);
        return $stmt->rowCount() > 0;
    }

    protected function validateName(string $name): string
{
    $name = trim($name);
    if ($name === '') {
        throw new InvalidArgumentException("Názov nesmie byť prázdny.");
    }
    return $name;
}
}

throw new InvalidArgumentException("Názov nesmie byť prázdny.");
//    ↑           ↑                      ↑
// vyhoď    vytvor objekt           správa ktorú
// výnimku  tejto zabudovanej       dostaneme
//          PHP triedy              v catch bloku

// PDOException — hodí ju PDO keď nastane chyba databázy
try {
    $model->delete($id);
} catch (PDOException $e) {
    echo "Chyba databázy: " . $e->getMessage();
}

// InvalidArgumentException — hodíme ju MY keď dostaneme zlý vstup
try {
    $model->insert("   ");   // prázdny názov
} catch (InvalidArgumentException $e) {
    echo "Zlý vstup: " . $e->getMessage();  // "Názov nesmie byť prázdny."
}

$model = new BaseModel($pdo);
$model->getAll();
// ❌ Ktorú tabuľku? $table nie je nastavená — kód spadne

abstract class BaseModel
{
    // ...
}

$model = new BaseModel($pdo);
// ❌ Fatal error: Cannot instantiate abstract class BaseModel
// PHP to jednoducho nedovolí — to je presne čo chceme

$model = new DifficultyModel($pdo);
// ✅ DifficultyModel extends BaseModel — to je v poriadku

abstract class Tvar
{
    // Abstraktná metóda — len podpis, žiadne telo
    // Každý potomok ju MUSÍ implementovať
    abstract public function plocha(): float;

    // Bežná metóda — zdedená automaticky, nie je povinné prepísať
    public function popis(): string
    {
        return "Tvar s plochou: " . $this->plocha();
    }
}

class Kruh extends Tvar
{
    private float $polomer;        // 1. deklarujeme vlastnosť

    public function __construct(float $polomer)
    {
        $this->polomer = $polomer; // 2. konštruktor ju nastaví pri new Kruh()
    }


    // POVINNÉ — implementujeme abstraktnú metódu
    public function plocha(): float
    {
        return M_PI * $this->polomer ** 2;
    }
}

class Stvorec extends Tvar
{
   // Konštruktor uloží stranu do vlastnosti — použijeme ju v plocha()
    // private float $strana je skrátený zápis pre: private float $strana; + $this->strana = $strana;
    public function __construct(private float $strana) {}

    // POVINNÉ — každý potomok má vlastnú implementáciu
    public function plocha(): float
    {
        return $this->strana ** 2;
    }
}

$kruh    = new Kruh(5);
$stvorec = new Stvorec(4);

echo $kruh->popis();    // Tvar s plochou: 78.54
echo $stvorec->popis(); // Tvar s plochou: 16

<?php
abstract class BaseModel
{
    protected PDO    $pdo;
    protected string $table;

    public function __construct(PDO $pdo)
    {
        $this->pdo = $pdo;
    }

    // Abstraktná metóda — každý potomok ju MUSÍ implementovať
    abstract public function describe(): string;

    public function getAll(): array
    {
        $stmt = $this->pdo->query(
            "SELECT id, name FROM {$this->table} ORDER BY id"
        );
        return $stmt->fetchAll();
    }

    public function getById(int $id): array|false
    {
        $stmt = $this->pdo->prepare(
            "SELECT id, name FROM {$this->table} WHERE id = :id"
        );
        $stmt->execute([':id' => $id]);
        return $stmt->fetch();
    }

    public function getCount(): int
    {
        $stmt = $this->pdo->query(
            "SELECT COUNT(*) FROM {$this->table}"
        );
        return (int) $stmt->fetchColumn();
    }

    public function insert(string $name): int
    {
        $name = $this->validateName($name);
        $stmt = $this->pdo->prepare(
            "INSERT INTO {$this->table} (name) VALUES (:name)"
        );
        $stmt->execute([':name' => $name]);
        return (int) $this->pdo->lastInsertId();
    }

    public function update(int $id, string $name): bool
    {
        $name = $this->validateName($name);
        $stmt = $this->pdo->prepare(
            "UPDATE {$this->table} SET name = :name WHERE id = :id"
        );
        $stmt->execute([':name' => $name, ':id' => $id]);
        return $stmt->rowCount() > 0;
    }

    public function delete(int $id): bool
    {
        $stmt = $this->pdo->prepare(
            "DELETE FROM {$this->table} WHERE id = :id"
        );
        $stmt->execute([':id' => $id]);
        return $stmt->rowCount() > 0;
    }

    protected function validateName(string $name): string
    {
        $name = trim($name);
        if ($name === '') {
            throw new InvalidArgumentException("Názov nesmie byť prázdny.");
        }
        return $name;
    }
}

class DifficultyModel extends BaseModel
{
    protected string $table = 'difficulties';

    // Povinná implementácia abstraktnej metódy
    public function describe(): string
    {
        return "DifficultyModel | tabuľka: {$this->table} | záznamov: " . $this->getCount();
    }

    public function countRecipes(): array
    {
        $stmt = $this->pdo->query(
            "SELECT d.id, d.name, COUNT(r.id) AS recipe_count
             FROM difficulties d
             LEFT JOIN recipes r ON r.difficulty_id = d.id
             GROUP BY d.id, d.name
             ORDER BY d.id"
        );
        return $stmt->fetchAll();
    }
}

recipes
  id, title, description, instructions,
  prep_time, cook_time, servings,
  difficulty_id    → JOIN difficulties
  cooking_method_id → JOIN cooking_methods
  season_id        → JOIN seasons (môže byť NULL)

<?php
class RecipeModel extends BaseModel
{
    protected string $table = 'recipes';

    // Povinná implementácia abstraktnej metódy
    public function describe(): string
    {
        return "RecipeModel | tabuľka: {$this->table} | receptov: " . $this->getCount();
    }

    // Prepíšeme getAll() — BaseModel vráti len id, name — to nestačí
    public function getAll(): array
    {
        $stmt = $this->pdo->query(
            "SELECT r.id, r.title, r.prep_time, r.cook_time, r.servings,
                    d.name AS difficulty
             FROM recipes r
             LEFT JOIN difficulties d ON d.id = r.difficulty_id
             ORDER BY r.title"
        );
        return $stmt->fetchAll();
    }

    // Prepíšeme getById() — detail receptu so všetkými JOINmi
    public function getById(int $id): array|false
    {
        $stmt = $this->pdo->prepare(
            "SELECT r.*,
                    d.name  AS difficulty_name,
                    m.name  AS cooking_method_name,
                    s.name  AS season_name
             FROM recipes r
             LEFT JOIN difficulties     d ON d.id = r.difficulty_id
             LEFT JOIN cooking_methods  m ON m.id = r.cooking_method_id
             LEFT JOIN seasons          s ON s.id = r.season_id
             WHERE r.id = :id"
        );
        $stmt->execute([':id' => $id]);
        return $stmt->fetch();
    }

    // insert() a update() — vlastné lebo recipes má viac stĺpcov ako len name
    public function insert(array $data): int
    {
        $stmt = $this->pdo->prepare(
            "INSERT INTO recipes
                (title, description, instructions, prep_time, cook_time,
                 servings, difficulty_id, cooking_method_id, season_id)
             VALUES
                (:title, :description, :instructions, :prep_time, :cook_time,
                 :servings, :difficulty_id, :cooking_method_id, :season_id)"
        );
        $stmt->execute($data);
        return (int) $this->pdo->lastInsertId();
    }

    public function update(int $id, array $data): bool
    {
        $data[':id'] = $id;
        $stmt = $this->pdo->prepare(
            "UPDATE recipes SET
                title             = :title,
                description       = :description,
                instructions      = :instructions,
                prep_time         = :prep_time,
                cook_time         = :cook_time,
                servings          = :servings,
                difficulty_id     = :difficulty_id,
                cooking_method_id = :cooking_method_id,
                season_id         = :season_id
             WHERE id = :id"
        );
        $stmt->execute($data);
        return $stmt->rowCount() > 0;
    }

    // delete() zdedíme z BaseModel — funguje rovnako
}

<?php
require 'connect.php';
require 'models/BaseModel.php';
require 'models/RecipeModel.php';

$model   = new RecipeModel($pdo);
$recepty = $model->getAll();
?>

<!DOCTYPE html>
<html lang="sk">
<head>
    <meta charset="UTF-8">
    <title>Recepty</title>
</head>
<body>
    <h1>Zoznam receptov</h1>
    <p><?= $model->describe() ?></p>

    <table>
        <tr>
            <th>Názov</th>
            <th>Príprava</th>
            <th>Varenie</th>
            <th>Porcie</th>
            <th>Obtiažnosť</th>
        </tr>
        <?php foreach ($recepty as $recept): ?>
        <tr>
            <td><a href="detail.php?id=<?= $recept['id'] ?>">
                <?= htmlspecialchars($recept['title']) ?>
            </a></td>
            <td><?= $recept['prep_time'] ?> min</td>
            <td><?= $recept['cook_time'] ?> min</td>
            <td><?= $recept['servings'] ?></td>
            <td><?= htmlspecialchars($recept['difficulty']) ?></td>
        </tr>
        <?php endforeach; ?>
    </table>
</body>
</html>

abstract class BaseModel
{
    protected PDO    $pdo;
    protected string $table;

    public function __construct(PDO $pdo)
    {
        $this->pdo = $pdo;
    }

    // Povinná implementácia — každý číselník má iný JOIN
    abstract public function describe(): string;
    abstract public function countRelated(): array;

    // ... getAll, getById, getCount, insert, update, delete, validateName
}

class DifficultyModel extends BaseModel
{
    protected string $table = 'difficulties';

    public function describe(): string
    {
        return "DifficultyModel | záznamov: " . $this->getCount();
    }

    // Počíta recepty — číselník patrí receptom
    public function countRelated(): array
    {
        $stmt = $this->pdo->query(
            "SELECT d.id, d.name, COUNT(r.id) AS related_count
             FROM difficulties d
             LEFT JOIN recipes r ON r.difficulty_id = d.id
             GROUP BY d.id, d.name
             ORDER BY d.id"
        );
        return $stmt->fetchAll();
    }
}

// CookingMethodModel, RecipeCategoryModel — rovnaká štruktúra,
// len iný JOIN stĺpec

class IngredientCategoryModel extends BaseModel
{
    protected string $table = 'ingredient_categories';

    public function describe(): string
    {
        return "IngredientCategoryModel | záznamov: " . $this->getCount();
    }

    // Počíta ingrediencie — tento číselník patrí ingredienciám, nie receptom
    public function countRelated(): array
    {
        $stmt = $this->pdo->query(
            "SELECT c.id, c.name, COUNT(i.id) AS related_count
             FROM ingredient_categories c
             LEFT JOIN ingredients i ON i.category_id = c.id
             GROUP BY c.id, c.name
             ORDER BY c.id"
        );
        return $stmt->fetchAll();
    }
}

<?php
class RecipeModel
{
    private PDO $pdo;

    public function __construct(PDO $pdo)
    {
        $this->pdo = $pdo;
    }

    public function describe(): string
    {
        return "RecipeModel | receptov: " . $this->getCount();
    }

    public function getAll(): array
    {
        $stmt = $this->pdo->query(
            "SELECT r.id, r.title, r.prep_time, r.cook_time, r.servings,
                    d.name AS difficulty
             FROM recipes r
             LEFT JOIN difficulties d ON d.id = r.difficulty_id
             ORDER BY r.title"
        );
        return $stmt->fetchAll();
    }

    public function getById(int $id): array|false
    {
        $stmt = $this->pdo->prepare(
            "SELECT r.*,
                    d.name AS difficulty_name,
                    m.name AS cooking_method_name,
                    s.name AS season_name
             FROM recipes r
             LEFT JOIN difficulties    d ON d.id = r.difficulty_id
             LEFT JOIN cooking_methods m ON m.id = r.cooking_method_id
             LEFT JOIN seasons         s ON s.id = r.season_id
             WHERE r.id = :id"
        );
        $stmt->execute([':id' => $id]);
        return $stmt->fetch();
    }

    public function getCount(): int
    {
        $stmt = $this->pdo->query("SELECT COUNT(*) FROM recipes");
        return (int) $stmt->fetchColumn();
    }

    public function insert(array $data): int
    {
        $stmt = $this->pdo->prepare(
            "INSERT INTO recipes
                (title, description, instructions, prep_time, cook_time,
                 servings, difficulty_id, cooking_method_id, season_id)
             VALUES
                (:title, :description, :instructions, :prep_time, :cook_time,
                 :servings, :difficulty_id, :cooking_method_id, :season_id)"
        );
        $stmt->execute($data);
        return (int) $this->pdo->lastInsertId();
    }

    public function update(int $id, array $data): bool
    {
        $data[':id'] = $id;
        $stmt = $this->pdo->prepare(
            "UPDATE recipes SET
                title             = :title,
                description       = :description,
                instructions      = :instructions,
                prep_time         = :prep_time,
                cook_time         = :cook_time,
                servings          = :servings,
                difficulty_id     = :difficulty_id,
                cooking_method_id = :cooking_method_id,
                season_id         = :season_id
             WHERE id = :id"
        );
        $stmt->execute($data);
        return $stmt->rowCount() > 0;
    }

    public function delete(int $id): bool
    {
        $stmt = $this->pdo->prepare("DELETE FROM recipes WHERE id = :id");
        $stmt->execute([':id' => $id]);
        return $stmt->rowCount() > 0;
    }
}

// Interface — len zmluva, žiadny kód
interface Platba
{
    public function zaplat(float $suma): bool;
    public function vratPlatbu(float $suma): bool;
}

// Trieda musí implementovať VŠETKY metódy z interface
class KartaPlatba implements Platba
{
    public function zaplat(float $suma): bool
    {
        // platba kartou
        return true;
    }

    public function vratPlatbu(float $suma): bool
    {
        // vrátenie na kartu
        return true;
    }
}

class PayPalPlatba implements Platba
{
    public function zaplat(float $suma): bool
    {
        // platba cez PayPal
        return true;
    }

    public function vratPlatbu(float $suma): bool
    {
        // vrátenie cez PayPal
        return true;
    }
}

<?php
interface ModelInterface
{
    public function getAll(): array;
    public function getById(int $id): array|false;
    public function getCount(): int;
    public function delete(int $id): bool;
    public function describe(): string;
}

abstract class BaseModel implements ModelInterface
{
    // BaseModel implementuje ModelInterface
    // Všetky číselníkové modely ho zdedia automaticky
    // — DifficultyModel, CookingMethodModel...
}

class RecipeModel implements ModelInterface
{
    // RecipeModel nededí z BaseModel
    // ale implementuje rovnaký interface
    // — zaručuje rovnaké metódy ako číselníky
}

// Funkcia prijme AKÝKOĽVEK objekt ktorý implementuje ModelInterface
function vypisZoznam(ModelInterface $model): void
{
    echo "<p>" . $model->describe() . "</p>";
    echo "<ul>";
    foreach ($model->getAll() as $zaznam) {
        echo "<li>" . htmlspecialchars($zaznam['name'] ?? $zaznam['title']) . "</li>";
    }
    echo "</ul>";
}

// Funguje pre VŠETKY modely — lebo všetky implementujú ModelInterface
vypisZoznam(new DifficultyModel($pdo));       // číselník
vypisZoznam(new CookingMethodModel($pdo));    // číselník
vypisZoznam(new IngredientCategoryModel($pdo)); // číselník ingrediencií
vypisZoznam(new RecipeModel($pdo));           // hlavná entita

// Ak by sme poslali objekt bez ModelInterface — PHP vyhodí chybu
// vypisZoznam("nejaky retazec");  ❌ TypeError

<?php
require 'connect.php';
require 'interfaces/ModelInterface.php';
require 'models/BaseModel.php';
require 'models/DifficultyModel.php';
require 'models/CookingMethodModel.php';
require 'models/RecipeCategoryModel.php';
require 'models/IngredientCategoryModel.php';

// match() vyberie správny model — bezpečné spracovanie GET parametra
$model = match($_GET['model'] ?? 'difficulty') {
    'difficulty'           => new DifficultyModel($pdo),
    'cooking_method'       => new CookingMethodModel($pdo),
    'recipe_category'      => new RecipeCategoryModel($pdo),
    'ingredient_category'  => new IngredientCategoryModel($pdo),
    default                => new DifficultyModel($pdo),
};

// Rovnaký kód funguje pre VŠETKY modely — polymorfizmus v praxi
$zaznam  = $model->getAll();
$pocet   = $model->getCount();
$popis   = $model->describe();
$suvislo = $model->countRelated();

class Singleton
{
    // Statická vlastnosť — zdieľaná medzi všetkými volaniami
    private static ?Singleton $instancia = null;

    // Private konštruktor — nikto nemôže urobiť new Singleton()
    private function __construct() {}

    // Jediný spôsob ako získať inštanciu
    public static function getInstance(): static
    {
        if (static::$instancia === null) {
            static::$instancia = new static();
        }
        return static::$instancia;
    }
}

$a = Singleton::getInstance();
$b = Singleton::getInstance();
// $a === $b  → true — oba ukazujú na rovnaký objekt

<?php
class Database
{
    private static ?PDO $instancia = null;

    // Private konštruktor — zabraňuje new Database()
    private function __construct() {}

    public static function getInstance(): PDO
    {
        if (self::$instancia === null) {
            self::$instancia = new PDO(
                'mysql:host=db;dbname=vegan;charset=utf8mb4',
                'root',
                'root',
                [
                    PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
                    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
                    PDO::ATTR_EMULATE_PREPARES   => false,
                ]
            );
        }
        return self::$instancia;
    }
}

// Každý súbor musí načítať connect.php
require 'connect.php';
$model = new RecipeModel($pdo);

// Kedykoľvek potrebujeme PDO — zavoláme getInstance()
require 'Database.php';
$model = new RecipeModel(Database::getInstance());

// Druhý model — PDO sa NEVYTVORÍ znova, použije sa existujúce
$ciselnik = new DifficultyModel(Database::getInstance());

public function search(array $filters): array
{
    // Základ SQL — vždy rovnaký
    $sql    = "SELECT r.id, r.title, r.prep_time, r.cook_time, r.servings,
                      d.name AS difficulty
               FROM recipes r
               LEFT JOIN difficulties d ON d.id = r.difficulty_id
               WHERE 1=1";

    // Pole pre hodnoty — budeme ich pridávať dynamicky
    $params = [];

    // Pridáme podmienky len ak filter prišiel
    if (!empty($filters['difficulty_id'])) {
        $sql .= " AND r.difficulty_id = :difficulty_id";
        $params[':difficulty_id'] = $filters['difficulty_id'];
    }

    if (!empty($filters['cooking_method_id'])) {
        $sql .= " AND r.cooking_method_id = :cooking_method_id";
        $params[':cooking_method_id'] = $filters['cooking_method_id'];
    }

    if (!empty($filters['season_id'])) {
        $sql .= " AND r.season_id = :season_id";
        $params[':season_id'] = $filters['season_id'];
    }

    if (!empty($filters['hladaj'])) {
        $sql .= " AND r.title LIKE :hladaj";
        $params[':hladaj'] = '%' . $filters['hladaj'] . '%';
    }

    $sql .= " ORDER BY r.title";

    $stmt = $this->pdo->prepare($sql);
    $stmt->execute($params);
    return $stmt->fetchAll();
}

<?php
require 'Database.php';
require 'models/RecipeModel.php';
require 'models/DifficultyModel.php';

$pdo     = Database::getInstance();
$model   = new RecipeModel($pdo);
$difficulty = new DifficultyModel($pdo);

// Zozbierame filtre z GET parametrov
$filters = [
    'difficulty_id'      => $_GET['difficulty_id'] ?? '',
    'cooking_method_id'  => $_GET['cooking_method_id'] ?? '',
    'season_id'          => $_GET['season_id'] ?? '',
    'hladaj'             => $_GET['hladaj'] ?? '',
];

// Ak nie sú žiadne filtre — vráti všetky recepty
$recepty    = $model->search($filters);
$obtiaznosti = $difficulty->getAll();
?>

<!-- Filtrovací formulár -->
<form method="get">
    <select name="difficulty_id" class="form-select">
        <option value="">Všetky obtiažnosti</option>
        <?php foreach ($obtiaznosti as $o): ?>
        <option value="<?= $o['id'] ?>"
            <?= ($filters['difficulty_id'] == $o['id']) ? 'selected' : '' ?>>
            <?= htmlspecialchars($o['name']) ?>
        </option>
        <?php endforeach; ?>
    </select>
    <input type="text" name="hladaj" class="form-control"
           value="<?= htmlspecialchars($filters['hladaj']) ?>"
           placeholder="Hľadaj recept...">
    <button type="submit" class="btn btn-primary">Filtrovať</button>
</form>

class TvarovaFactory
{
    public static function vytvor(string $typ): Tvar
    {
        return match($typ) {
            'kruh'    => new Kruh(),
            'stvorec' => new Stvorec(),
            default   => throw new InvalidArgumentException("Neznámy tvar: $typ"),
        };
    }
}

// Volajúci kód nemusí vedieť ako Kruh vzniká
$tvar = TvarovaFactory::vytvor('kruh');

<?php
class ModelFactory
{
    public static function vytvor(string $typ, PDO $pdo): ModelInterface
    {
        return match($typ) {
            'difficulty'          => new DifficultyModel($pdo),
            'cooking_method'      => new CookingMethodModel($pdo),
            'recipe_category'     => new RecipeCategoryModel($pdo),
            'ingredient_category' => new IngredientCategoryModel($pdo),
            default               => throw new InvalidArgumentException(
                "Neznámy typ modelu: $typ"
            ),
        };
    }
}

// PRED — match() priamo v ciselniky.php
$model = match($_GET['model'] ?? 'difficulty') {
    'difficulty'          => new DifficultyModel($pdo),
    'cooking_method'      => new CookingMethodModel($pdo),
    'recipe_category'     => new RecipeCategoryModel($pdo),
    'ingredient_category' => new IngredientCategoryModel($pdo),
    default               => new DifficultyModel($pdo),
};

// PO — Factory trieda
$model = ModelFactory::vytvor($_GET['model'] ?? 'difficulty', $pdo);
// Kratšie, prehľadnejšie — logika je v ModelFactory

-- Hlavné tabuľky
recipes      (id, title, ...)
ingredients  (id, name, ...)

-- Pivot tabuľka — drží M:N väzbu
recipe_ingredients (
    recipe_id      → FK na recipes     ON DELETE CASCADE
    ingredient_id  → FK na ingredients ON DELETE RESTRICT
    amount         → množstvo
    unit_id        → jednotka
)

-- Jeden recept → viac riadkov v pivot tabuľke
-- Jedna ingrediencia → viac riadkov v pivot tabuľke

// Pridaj ingredienciu k receptu
public function attachIngredient(
    int $recipeId,
    int $ingredientId,
    float $amount,
    int $unitId,
    ?string $note = null
): void {
    $stmt = $this->pdo->prepare(
        "INSERT INTO recipe_ingredients
            (recipe_id, ingredient_id, amount, unit_id, note)
         VALUES
            (:recipe_id, :ingredient_id, :amount, :unit_id, :note)"
    );
    $stmt->execute([
        ':recipe_id'     => $recipeId,
        ':ingredient_id' => $ingredientId,
        ':amount'        => $amount,
        ':unit_id'       => $unitId,
        ':note'          => $note,
    ]);
}

// Odober ingredienciu z receptu
public function detachIngredient(int $recipeId, int $ingredientId): void
{
    $stmt = $this->pdo->prepare(
        "DELETE FROM recipe_ingredients
         WHERE recipe_id = :recipe_id
           AND ingredient_id = :ingredient_id"
    );
    $stmt->execute([
        ':recipe_id'     => $recipeId,
        ':ingredient_id' => $ingredientId,
    ]);
}

// Nastav presne tieto kategórie — ostatné odober
// Používa sa pri ukladaní formulára
public function syncCategories(int $recipeId, array $categoryIds): void
{
    // 1. Zmaž všetky existujúce prepojenia
    $stmt = $this->pdo->prepare(
        "DELETE FROM recipe_category_map WHERE recipe_id = :recipe_id"
    );
    $stmt->execute([':recipe_id' => $recipeId]);

    // 2. Vlož nové prepojenia
    $stmt = $this->pdo->prepare(
        "INSERT INTO recipe_category_map (recipe_id, category_id)
         VALUES (:recipe_id, :category_id)"
    );
    foreach ($categoryIds as $categoryId) {
        $stmt->execute([
            ':recipe_id'   => $recipeId,
            ':category_id' => (int) $categoryId,
        ]);
    }
}

// Pridanie ingrediencie k receptu
$model->attachIngredient(
    recipeId: 1,
    ingredientId: 5,
    amount: 200,
    unitId: 1,
    note: 'nakrájané'
);

// Odobranie ingrediencie z receptu
$model->detachIngredient(recipeId: 1, ingredientId: 5);

// Sync kategórií pri ukladaní formulára
// — checkboxy vrátia pole id-čiek
$model->syncCategories(
    recipeId: 1,
    categoryIds: [2, 3]   // len tieto dve kategórie zostanú
);

projekt/
├── index.php                         → dashboard — súhrn a štatistiky
│
├── [hlavna-entita].php               → zoznam s filtrom
├── [hlavna-entita]-detail.php        → detail záznamu
├── [hlavna-entita]-pridat.php        → formulár — pridanie
├── [hlavna-entita]-upravit.php       → formulár — úprava
│
│   (ak máš dve hlavné entity, opakuj pre druhú)
├── [druha-entita].php
├── [druha-entita]-detail.php
├── [druha-entita]-pridat.php
├── [druha-entita]-upravit.php
│
├── admin/
│   ├── index.php                     → admin dashboard
│   ├── ciselniky.php                 → správa číselníkov
│   └── reset-db.php                  → obnovenie databázy
│
├── includes/
│   ├── nav.php                       → hlavná navigácia
│   └── admin-nav.php                 → admin navigácia
│
├── models/
│   ├── BaseModel.php                 → abstraktná trieda pre číselníky
│   ├── ModelInterface.php            → rozhranie pre všetky modely
│   ├── Database.php                  → Singleton pre PDO
│   ├── ModelFactory.php              → Factory pre číselníky
│   ├── [HlavnaEntita]Model.php       → model hlavnej entity
│   ├── [DruhaEntita]Model.php        → model druhej entity (ak existuje)
│   └── [Ciselnik]Model.php           → jeden súbor pre každý číselník
│
├── sql/
│   └── databaza.sql                  → SQL skript — štruktúra a vzorové dáta
│
└── assets/
    ├── css/style.css
    └── js/script.js