// ===== pom.xml (Maven) – Spring Boot Starter dependencies =====
/*
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.4</version>
    </parent>

    <groupId>hu.pelda</groupId>
    <artifactId>termek-api</artifactId>
    <version>1.0.0</version>

    <properties>
        <java.version>21</java.version>
    </properties>

<dependencies>
        <!-- Web (REST controller, embedded Tomcat) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

        <!-- Spring Data JPA + Hibernate -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

        <!-- MySQL / MariaDB driver -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!-- Validáció (jakarta validation) -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>

        <!-- Tesztelés -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>
*/

// ===== TermekApiApplication.java – belépési pont =====
package hu.pelda;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class TermekApiApplication {

    public static void main(String[] args) {
        SpringApplication.run(TermekApiApplication.class, args);
    }
}

// ===== Hasznos parancsok =====
/*
mvn spring-boot:run        # alkalmazás indítása fejlesztésre
mvn clean package          # JAR fájl építése a target/ mappába
java -jar target/termek-api-1.0.0.jar   # JAR futtatása

# Mappa szerkezet javasolt:
src/main/java/hu/pelda/
    TermekApiApplication.java
    controller/    – REST végpontok
    service/       – business logika
    repository/    – Spring Data interfészek
    entity/        – JPA entitások (adatbázis táblák)
    dto/           – DTO osztályok
    exception/     – egyedi kivételek + handler
src/main/resources/
    application.properties
*/

# application.properties – Spring Boot konfiguráció
# A src/main/resources/application.properties fájlba kerül.
# Itt állítható az adatbázis kapcsolat, port, log szintek, Hibernate viselkedés.
# YAML alternatíva is van (application.yml), ugyanazt teszi, csak más szintaxissal.

# ---------------- Szerver ----------------
server.port=8080
server.servlet.context-path=/api
# server.error.include-message=always   # hibaüzenet a JSON válaszban

# ---------------- Adatbázis kapcsolat ----------------
spring.datasource.url=jdbc:mysql://localhost:3306/termek_db?useSSL=false&serverTimezone=Europe/Budapest
spring.datasource.username=root
spring.datasource.password=
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# ---------------- Connection pool (HikariCP, ez az alapértelmezett) ----------------
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=2
spring.datasource.hikari.idle-timeout=30000
spring.datasource.hikari.connection-timeout=20000

# ---------------- JPA / Hibernate ----------------
# ddl-auto: none / validate / update / create / create-drop
#   update = a séma automatikusan szinkronban a entitásokkal (fejlesztéshez)
#   none   = semmit ne csináljon (production)
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect
spring.jpa.open-in-view=false

# ---------------- Log szintek ----------------
logging.level.root=INFO
logging.level.hu.pelda=DEBUG
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.orm.jdbc.bind=TRACE

# ---------------- Profilok (különböző environmentek) ----------------
# Indítás profilonként:
#   mvn spring-boot:run -Dspring-boot.run.profiles=dev
#   java -jar app.jar --spring.profiles.active=prod
spring.profiles.active=dev

# ---------------- Egyedi értékek (saját konfig) ----------------
app.felhasznalo.alapertelmezett-szerepkor=USER
app.cache.lejarat-perc=15
# Használat kódból:
#   @Value("${app.cache.lejarat-perc}") private int lejaratPerc;

package hu.pelda.controller;

import hu.pelda.entity.Termek;
import hu.pelda.service.TermekService;
import jakarta.validation.Valid;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/products")
public class TermekController {

    private final TermekService service;

    // Konstruktor injekció (preferált) – nem kell @Autowired Spring 4.3+ óta
    public TermekController(TermekService service) {
        this.service = service;
    }

    // GET /products – összes termék listázása
    @GetMapping
    public List<Termek> osszes() {
        return service.osszes();
    }

    // GET /products/5 – egy termék id alapján
    @GetMapping("/{id}")
    public Termek egy(@PathVariable Integer id) {
        return service.egy(id); // ha nincs, ResourceNotFoundException-t dob
    }

    // GET /products/search?nev=Alma
    @GetMapping("/search")
    public List<Termek> kereses(@RequestParam String nev) {
        return service.keresesNevAlapjan(nev);
    }

    // POST /products – új termék létrehozása
    @PostMapping
    public ResponseEntity<Termek> uj(@Valid @RequestBody Termek termek) {
        Termek mentett = service.ment(termek);
        return ResponseEntity.status(HttpStatus.CREATED).body(mentett);
    }

    // PUT /products/5 – meglévő termék módosítása
    @PutMapping("/{id}")
    public Termek modosit(@PathVariable Integer id,
                          @Valid @RequestBody Termek termek) {
        return service.modosit(id, termek);
    }

    // DELETE /products/5 – termék törlése
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> torles(@PathVariable Integer id) {
        service.torles(id);
        return ResponseEntity.noContent().build(); // 204 No Content
    }
}

package hu.pelda.service;

import hu.pelda.entity.Termek;
import hu.pelda.exception.ResourceNotFoundException;
import hu.pelda.repository.TermekRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.List;

@Service
@Transactional // alapból írható tranzakció minden public metódusra
public class TermekService {

    private final TermekRepository repo;

    public TermekService(TermekRepository repo) {
        this.repo = repo;
    }

    // Read-only optimalizáció – Hibernate gyorsabb dirty check nélkül
    @Transactional(readOnly = true)
    public List<Termek> osszes() {
        return repo.findAll();
    }

    @Transactional(readOnly = true)
    public Termek egy(Integer id) {
        return repo.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException(
                        "Nincs ilyen termék: id=" + id));
    }

    @Transactional(readOnly = true)
    public List<Termek> keresesNevAlapjan(String nev) {
        return repo.findByNevContainingIgnoreCase(nev);
    }

    public Termek ment(Termek termek) {
        // Itt lehet üzleti validáció: pl. "ne lehessen negatív ár"
        if (termek.getAr().compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("Az ár nem lehet negatív");
        }
        return repo.save(termek);
    }

    public Termek modosit(Integer id, Termek ujAdatok) {
        Termek meglevo = egy(id); // dob exception-t ha nincs
        meglevo.setNev(ujAdatok.getNev());
        meglevo.setAr(ujAdatok.getAr());
        return repo.save(meglevo);
    }

    public void torles(Integer id) {
        if (!repo.existsById(id)) {
            throw new ResourceNotFoundException("Nincs ilyen termék: id=" + id);
        }
        repo.deleteById(id);
    }
}

package hu.pelda.repository;

import hu.pelda.entity.Termek;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;

import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;

@Repository
public interface TermekRepository extends JpaRepository<Termek, Integer> {

    // ===== Metódusnév-alapú generálás =====
    // SELECT * FROM termek WHERE nev = ?
    List<Termek> findByNev(String nev);

    // ILIKE keresés – SELECT * FROM termek WHERE LOWER(nev) LIKE LOWER('%alma%')
    List<Termek> findByNevContainingIgnoreCase(String reszlet);

    // SELECT * FROM termek WHERE ar > ? ORDER BY ar DESC
    List<Termek> findByArGreaterThanOrderByArDesc(BigDecimal hatar);

    // SELECT * FROM termek WHERE ar BETWEEN ? AND ?
    List<Termek> findByArBetween(BigDecimal min, BigDecimal max);

    // Optional – ha lehet null
    Optional<Termek> findFirstByNevOrderByArAsc(String nev);

    // Számolás
    long countByArGreaterThan(BigDecimal hatar);

    // Létezik-e
    boolean existsByNev(String nev);

    // ===== Egyedi @Query (JPQL) =====
    @Query("SELECT t FROM Termek t WHERE t.ar < :max ORDER BY t.nev")
    List<Termek> olcsobbakAtNal(@Param("max") BigDecimal max);

    // Aggregáló lekérdezés
    @Query("SELECT AVG(t.ar) FROM Termek t")
    BigDecimal atlagAr();

    // ===== Natív SQL =====
    @Query(value = "SELECT * FROM termek WHERE keszlet > 0 AND aktiv = true",
           nativeQuery = true)
    List<Termek> aktivKeszleten();
}

/*
        ┌─────────────────────────────────────────┐
        │   HTTP kliens (Postman, frontend, stb.) │
        └─────────────────────────────────────────┘
                          │  JSON
                          ▼
        ┌─────────────────────────────────────────┐
        │   Controller (@RestController)          │   – HTTP-specifikus
        │   - @RequestBody, @PathVariable         │     - validáció
        │   - HTTP státusz kódok                  │     - JSON ↔ objektum
        └─────────────────────────────────────────┘
                          │  Termek objektum
                          ▼
        ┌─────────────────────────────────────────┐
        │   Service (@Service)                    │   – üzleti logika
        │   - validáció, számítás                 │     - tranzakciók
        │   - több repo összehangolása            │     - kivételdobás
        └─────────────────────────────────────────┘
                          │  Termek objektum
                          ▼
        ┌─────────────────────────────────────────┐
        │   Repository (extends JpaRepository)    │   – adatbázis hozzáférés
        │   - findByXxx, save, delete             │     - JPQL / SQL
        └─────────────────────────────────────────┘
                          │  SQL
                          ▼
        ┌─────────────────────────────────────────┐
        │   Adatbázis (MySQL / MariaDB)           │
        └─────────────────────────────────────────┘
*/

// ===== Rövid teljes példa az összes réteggel =====

// 1. Entity (entity/Termek.java)
@Entity
@Table(name = "termek")
public class Termek {
    @Id @GeneratedValue private Integer id;
    private String nev;
    private BigDecimal ar;
    // getterek / setterek
}

// 2. Repository (repository/TermekRepository.java)
@Repository
public interface TermekRepository extends JpaRepository<Termek, Integer> {
    List<Termek> findByNev(String nev);
}

// 3. Service (service/TermekService.java)
@Service
public class TermekService {
    private final TermekRepository repo;

    public TermekService(TermekRepository repo) { this.repo = repo; }

    public List<Termek> osszes() {
        return repo.findAll();
    }

    public Termek ment(Termek termek) {
        return repo.save(termek);
    }
}

// 4. Controller (controller/TermekController.java)
@RestController
@RequestMapping("/products")
public class TermekController {
    private final TermekService service;

    public TermekController(TermekService service) { this.service = service; }

    @GetMapping
    public List<Termek> osszes() {
        return service.osszes();
    }

    @PostMapping
    public Termek uj(@RequestBody Termek termek) {
        return service.ment(termek);
    }
}

// ===== Miért így? =====
// - Cserélhetőség: ha lecseréled a repository-t (pl. MongoDB-re), csak a repo változik
// - Tesztelhetőség: a service mockolt repo-val tesztelhető DB nélkül
// - Tisztaság: minden réteg csak egy dolgot csinál
// - Tranzakció kezelés: a @Transactional a service szinten van, NEM a controlleren

// ===== Entity (DB-orientált) =====
@Entity
@Table(name = "felhasznalo")
public class Felhasznalo {
    @Id @GeneratedValue private Integer id;
    private String nev;
    private String email;
    private String jelszo;        // EZT SOHA NE adjuk vissza JSON-ban!
    private LocalDateTime letrehozas;

    @ManyToOne private Csoport csoport;  // lazy kapcsolat
    // getterek / setterek
}

// ===== DTO – kimenő (response) =====
public class FelhasznaloDto {
    private Integer id;
    private String nev;
    private String email;
    private String csoportNev;    // lapított érték a kapcsolatból

    public FelhasznaloDto(Integer id, String nev, String email, String csoportNev) {
        this.id = id; this.nev = nev; this.email = email; this.csoportNev = csoportNev;
    }
    // getterek
}

// ===== DTO – bejövő (request) – csak amit a kliens küldhet =====
public class CreateFelhasznaloRequest {
    @NotBlank
    @Size(min = 3, max = 100)
    private String nev;

    @Email
    @NotBlank
    private String email;

    @NotBlank
    @Size(min = 6)
    private String jelszo;

    private Integer csoportId;
    // getterek / setterek
}

// ===== Mapper – konverzió Entity ↔ DTO =====
@Component
public class FelhasznaloMapper {

    public FelhasznaloDto toDto(Felhasznalo entity) {
        String csoportNev = entity.getCsoport() != null
                ? entity.getCsoport().getNev() : null;
        return new FelhasznaloDto(
                entity.getId(),
                entity.getNev(),
                entity.getEmail(),
                csoportNev
        );
    }

    public Felhasznalo toEntity(CreateFelhasznaloRequest req, Csoport csoport) {
        Felhasznalo f = new Felhasznalo();
        f.setNev(req.getNev());
        f.setEmail(req.getEmail());
        f.setJelszo(req.getJelszo()); // a service még be is hash-eli
        f.setCsoport(csoport);
        f.setLetrehozas(LocalDateTime.now());
        return f;
    }
}

// ===== Service – DTO-val dolgozik a kifelé, Entity-vel a DB felé =====
@Service
public class FelhasznaloService {

    private final FelhasznaloRepository repo;
    private final CsoportRepository csoportRepo;
    private final FelhasznaloMapper mapper;

    public FelhasznaloService(FelhasznaloRepository repo,
                              CsoportRepository csoportRepo,
                              FelhasznaloMapper mapper) {
        this.repo = repo; this.csoportRepo = csoportRepo; this.mapper = mapper;
    }

    public List<FelhasznaloDto> osszes() {
        return repo.findAll().stream()
                .map(mapper::toDto)
                .toList();
    }

    public FelhasznaloDto letrehoz(CreateFelhasznaloRequest req) {
        Csoport csoport = csoportRepo.findById(req.getCsoportId())
                .orElseThrow(() -> new ResourceNotFoundException("Csoport nincs"));
        Felhasznalo entity = mapper.toEntity(req, csoport);
        Felhasznalo mentett = repo.save(entity);
        return mapper.toDto(mentett);
    }
}

// ===== Controller – csak DTO-kat lát, soha nem entityt =====
@RestController
@RequestMapping("/users")
public class FelhasznaloController {
    private final FelhasznaloService service;
    public FelhasznaloController(FelhasznaloService service) { this.service = service; }

    @GetMapping
    public List<FelhasznaloDto> osszes() {
        return service.osszes();
    }

    @PostMapping
    public ResponseEntity<FelhasznaloDto> uj(@Valid @RequestBody CreateFelhasznaloRequest req) {
        return ResponseEntity.status(HttpStatus.CREATED).body(service.letrehoz(req));
    }
}

// ===== Custom exception – ha nincs entitás az adott ID-val =====
package hu.pelda.exception;

public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) {
        super(message);
    }
}

// ===== ApiError – egységes hibaválasz formátum (DTO) =====
package hu.pelda.exception;

import java.time.LocalDateTime;
import java.util.List;

public class ApiError {
    private LocalDateTime timestamp;
    private int status;
    private String error;
    private String message;
    private String path;
    private List<String> reszletek;

    public ApiError(int status, String error, String message, String path) {
        this.timestamp = LocalDateTime.now();
        this.status = status;
        this.error = error;
        this.message = message;
        this.path = path;
    }

    public ApiError(int status, String error, String message, String path,
                    List<String> reszletek) {
        this(status, error, message, path);
        this.reszletek = reszletek;
    }
    // getterek
}

// ===== GlobalExceptionHandler – minden hibát itt kezelünk =====
package hu.pelda.exception;

import jakarta.servlet.http.HttpServletRequest;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

import java.util.List;

@ControllerAdvice
public class GlobalExceptionHandler {

    // 404 – nincs ilyen erőforrás
    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<ApiError> notFound(ResourceNotFoundException ex,
                                             HttpServletRequest req) {
        ApiError hiba = new ApiError(
                HttpStatus.NOT_FOUND.value(),
                "Not Found",
                ex.getMessage(),
                req.getRequestURI()
        );
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(hiba);
    }

    // 400 – validációs hiba (@Valid + @RequestBody mezőkre)
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ApiError> validation(MethodArgumentNotValidException ex,
                                               HttpServletRequest req) {
        List<String> reszletek = ex.getBindingResult().getFieldErrors().stream()
                .map(fe -> fe.getField() + ": " + fe.getDefaultMessage())
                .toList();

        ApiError hiba = new ApiError(
                HttpStatus.BAD_REQUEST.value(),
                "Validation Failed",
                "Hibás bemenet",
                req.getRequestURI(),
                reszletek
        );
        return ResponseEntity.badRequest().body(hiba);
    }

    // 400 – üzleti szabály megsértése (saját dobás)
    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<ApiError> illegalArg(IllegalArgumentException ex,
                                               HttpServletRequest req) {
        ApiError hiba = new ApiError(
                HttpStatus.BAD_REQUEST.value(),
                "Bad Request",
                ex.getMessage(),
                req.getRequestURI()
        );
        return ResponseEntity.badRequest().body(hiba);
    }

    // 500 – minden más kezeletlen hiba (utolsó "catch-all")
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ApiError> general(Exception ex, HttpServletRequest req) {
        ApiError hiba = new ApiError(
                HttpStatus.INTERNAL_SERVER_ERROR.value(),
                "Internal Server Error",
                "Váratlan hiba történt",
                req.getRequestURI()
        );
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(hiba);
    }
}

// ===== Példa hibadobásra a service-ben =====
/*
public Termek egy(Integer id) {
    return repo.findById(id)
            .orElseThrow(() -> new ResourceNotFoundException("Termék nincs: " + id));
    }
*/

// ===== Mit ad vissza a kliensnek: =====
/*
HTTP/1.1 404 Not Found
{
    "timestamp": "2026-05-06T10:23:45",
    "status": 404,
    "error": "Not Found",
    "message": "Termék nincs: 9999",
    "path": "/products/9999"
}
*/

// ===== pom.xml – Hibernate dependencies =====
/*
<dependencies>
    <!-- Hibernate ORM – a jakarta API-val (Java EE 9+) -->
    <dependency>
        <groupId>org.hibernate.orm</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>6.5.2.Final</version>
    </dependency>

    <!-- MySQL JDBC driver -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <version>8.4.0</version>
    </dependency>
</dependencies>
*/

// ===== hibernate.cfg.xml – src/main/resources/ =====
/*
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <!-- Adatbázis kapcsolat -->
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/iskola</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password"></property>

        <!-- Dialektus – melyik DB nyelvét használja a Hibernate -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- Fejlesztési segédlet -->
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>

        <!-- Séma kezelés: validate / update / create / create-drop -->
        <property name="hibernate.hbm2ddl.auto">update</property>

        <!-- Pool méret -->
        <property name="hibernate.connection.pool_size">10</property>

        <!-- Mapped class-ok – minden entitást fel kell sorolni -->
        <mapping class="hu.pelda.entity.Tanulo"/>
        <mapping class="hu.pelda.entity.Osztaly"/>
    </session-factory>
</hibernate-configuration>
*/

// ===== HibernateUtil.java – singleton SessionFactory =====
package hu.pelda.util;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

    private static SessionFactory sessionFactory;

    static {
        try {
            sessionFactory = new Configuration()
                    .configure("hibernate.cfg.xml") // a resources/ alól
                    .buildSessionFactory();
        } catch (Throwable ex) {
            System.err.println("SessionFactory hiba: " + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public static void shutdown() {
        if (sessionFactory != null) {
            sessionFactory.close();
        }
    }

    private HibernateUtil() {} // ne lehessen példányosítani
}

// ===== Használat (bárhol) =====
/*
import org.hibernate.Session;

try (Session session = HibernateUtil.getSessionFactory().openSession()) {
    // ... DB műveletek ...
} // Session automatikusan zárul

// Alkalmazás végén:
HibernateUtil.shutdown();
*/

package hu.pelda.entity;

import jakarta.persistence.*;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;

@Entity
@Table(name = "tanulok")
public class Tanulo {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // MySQL AUTO_INCREMENT
    @Column(name = "id")
    private Integer id;

    @Column(name = "nev", nullable = false, length = 100)
    private String nev;

    // Ha az oszlop neve = mező neve, a @Column elhagyható
    @Column(nullable = false, length = 10)
    private String osztaly;

    @Column(name = "szuletesi_datum")
    private LocalDate szuletesi;

    @Column(name = "atlag", precision = 4, scale = 2) // DECIMAL(4,2)
    private BigDecimal atlag;

    @Column(nullable = false)
    private Boolean aktiv = true;

    // Enum tárolása stringként
    @Enumerated(EnumType.STRING)
    @Column(length = 20)
    private Statusz statusz = Statusz.AKTIV;

    @Column(name = "letrehozas")
    private LocalDateTime letrehozas;

    @Transient // EZT a mezőt NE mentsd DB-be (számolt érték, csak memóriában)
    private int eletkor;

    // Lifecycle callback – a persist előtt fut le
    @PrePersist
    public void preInsert() {
        if (letrehozas == null) {
            letrehozas = LocalDateTime.now();
        }
    }

    public Tanulo() { } // KÖTELEZŐ paraméter nélküli konstruktor

    public Tanulo(String nev, String osztaly, LocalDate szuletesi, BigDecimal atlag) {
        this.nev = nev;
        this.osztaly = osztaly;
        this.szuletesi = szuletesi;
        this.atlag = atlag;
    }

    // ===== Getterek / setterek (kötelezőek a Hibernate-hez) =====
    public Integer getId() { return id; }
    public void setId(Integer id) { this.id = id; }

    public String getNev() { return nev; }
    public void setNev(String nev) { this.nev = nev; }

    public String getOsztaly() { return osztaly; }
    public void setOsztaly(String osztaly) { this.osztaly = osztaly; }

    public LocalDate getSzuletesi() { return szuletesi; }
    public void setSzuletesi(LocalDate szuletesi) { this.szuletesi = szuletesi; }

    public BigDecimal getAtlag() { return atlag; }
    public void setAtlag(BigDecimal atlag) { this.atlag = atlag; }

    public Boolean getAktiv() { return aktiv; }
    public void setAktiv(Boolean aktiv) { this.aktiv = aktiv; }

    public Statusz getStatusz() { return statusz; }
    public void setStatusz(Statusz statusz) { this.statusz = statusz; }

    @Override
    public String toString() {
        return id + " - " + nev + " (" + osztaly + "): " + atlag;
    }
}

// ===== Enum külön fájlba =====
package hu.pelda.entity;

public enum Statusz {
    AKTIV, INAKTIV, FELFUGGESZTETT
}

package hu.pelda.dao;

import hu.pelda.entity.Tanulo;
import hu.pelda.util.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.Transaction;

import java.util.List;

public class TanuloDao {

    // ===== CREATE – új sor beszúrása =====
    public void mentes(Tanulo tanulo) {
        Transaction tx = null;
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            tx = session.beginTransaction();
            session.persist(tanulo); // INSERT INTO tanulok ...
    tx.commit();
        } catch (Exception e) {
            if (tx != null) tx.rollback();
            throw e;
        }
    }

    // ===== READ – id alapján egy rekord =====
    public Tanulo egy(Integer id) {
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            return session.get(Tanulo.class, id); // SELECT * FROM tanulok WHERE id = ?
            // ha nincs ilyen id: null-t ad vissza (a session.find ugyanaz)
        }
    }

    // ===== READ – összes =====
    public List<Tanulo> osszes() {
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            return session.createQuery("FROM Tanulo", Tanulo.class).getResultList();
        }
    }

    // ===== UPDATE – módosítás =====
    public void modositas(Tanulo tanulo) {
        Transaction tx = null;
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            tx = session.beginTransaction();
            session.merge(tanulo); // UPDATE ... WHERE id = ?
            tx.commit();
        } catch (Exception e) {
            if (tx != null) tx.rollback();
            throw e;
        }
    }

    // ===== DELETE – törlés =====
    public void torles(Integer id) {
        Transaction tx = null;
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            tx = session.beginTransaction();
            Tanulo t = session.get(Tanulo.class, id);
            if (t != null) {
                session.remove(t); // DELETE FROM tanulok WHERE id = ?
            }
            tx.commit();
        } catch (Exception e) {
            if (tx != null) tx.rollback();
            throw e;
        }
    }
}

// ===== Példa használat =====
/*
public class Main {
    public static void main(String[] args) {
        TanuloDao dao = new TanuloDao();

        // CREATE
        Tanulo uj = new Tanulo("Kovács Béla", "13D", LocalDate.of(2006, 3, 15), new BigDecimal("4.20"));
        dao.mentes(uj);
        System.out.println("Mentve, id = " + uj.getId());

        // READ
        Tanulo betoltott = dao.egy(uj.getId());
        System.out.println(betoltott);

        // UPDATE
        betoltott.setAtlag(new BigDecimal("4.50"));
        dao.modositas(betoltott);

        // READ ALL
        for (Tanulo t : dao.osszes()) {
            System.out.println(t);
        }

        // DELETE
        dao.torles(betoltott.getId());

        HibernateUtil.shutdown();
    }
}
*/

// ===== Entity állapotok (érdemes tudni) =====
/*
- transient: új objektum, még nincs DB-ben (new Tanulo())
- persistent: a Session ismeri, változások auto követve (persist után)
- detached: már nincs aktív Session (close után)
- removed: remove()-mal törlésre jelölve
*/

import jakarta.persistence.*;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

// ===== 1:N – Egy ország, sok város =====

@Entity
@Table(name = "country")
public class Country {

    @Id @GeneratedValue
    private Integer id;
    private String nev;

    // Egy országhoz több város tartozik – fordított oldal
    // mappedBy = a City osztály "country" mezője a tulajdonos
    @OneToMany(mappedBy = "country",
               cascade = CascadeType.ALL,    // ha mentem az országot, a városok is mentődnek
               orphanRemoval = true,          // ha kiveszek egy várost a listából, törlődik DB-ből
               fetch = FetchType.LAZY)
    private List<City> cities = new ArrayList<>();

    // Convenience metódusok – mindkét oldalt szinkronizálja
    public void addCity(City c) {
        cities.add(c);
        c.setCountry(this);
    }
    public void removeCity(City c) {
        cities.remove(c);
        c.setCountry(null);
    }
    // getterek / setterek
}

// ===== N:1 – Sok város egy országhoz tartozik =====

@Entity
@Table(name = "city")
public class City {

    @Id @GeneratedValue
    private Integer id;
    private String nev;
    private Integer lakossag;

    // Tulajdonos oldal – ez tartalmazza az idegen kulcsot (country_id oszlop)
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "country_id", nullable = false)
    private Country country;
    // getterek / setterek
}

// ===== 1:1 – Egy felhasznalo egy profilhoz tartozik =====

@Entity
@Table(name = "felhasznalo")
public class Felhasznalo {
    @Id @GeneratedValue private Integer id;
    private String email;

    // Tulajdonos oldal – itt van a profil_id
    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "profil_id", referencedColumnName = "id")
    private Profil profil;
}

@Entity
@Table(name = "profil")
public class Profil {
    @Id @GeneratedValue private Integer id;
    private String tlefonszam;

    @OneToOne(mappedBy = "profil")
    private Felhasznalo felhasznalo;
}

// ===== N:M – Sok diák, sok kurzus (köztes tábla automatikus) =====

@Entity
@Table(name = "diak")
public class Diak {
    @Id @GeneratedValue private Integer id;
    private String nev;

    @ManyToMany(cascade = { CascadeType.PERSIST, CascadeType.MERGE })
    @JoinTable(
        name = "diak_kurzus",                                  // köztes tábla neve
        joinColumns = @JoinColumn(name = "diak_id"),           // saját FK
        inverseJoinColumns = @JoinColumn(name = "kurzus_id")   // másik oldal FK
    )
    private Set<Kurzus> kurzusok = new HashSet<>();
}

@Entity
@Table(name = "kurzus")
public class Kurzus {
    @Id @GeneratedValue private Integer id;
    private String cim;

    @ManyToMany(mappedBy = "kurzusok")  // fordított oldal
    private Set<Diak> diakok = new HashSet<>();
}

// ===== Cascade típusok =====
/*
- PERSIST: ha persist-eled a szülőt, a gyerekek is persist-elődnek
- MERGE: ha merge-eled a szülőt, a gyerekek is
- REMOVE: ha törlöd a szülőt, a gyerekek is törlődnek
- REFRESH: szülő frissítésénél a gyerekek is
- DETACH: szülő detach-jánál a gyerekek is
- ALL: mind az összes
*/

// ===== Lazy loading – figyelmeztetés =====
/*
A lazy kapcsolatok csak nyitott Session-ön belül érhetők el!
Ha a Session már zárva van és próbálod elérni a kapcsolt entitást:
    LazyInitializationException

Megoldás: vagy nyitott Sessionön belül érd el, vagy használj JOIN FETCH-t a HQL-ben:
    SELECT c FROM Country c LEFT JOIN FETCH c.cities WHERE c.id = :id
*/

package hu.pelda.dao;

import hu.pelda.entity.Tanulo;
import hu.pelda.util.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.query.Query;

import java.math.BigDecimal;
import java.util.List;

public class TanuloHqlDao {

    // ===== Egyszerű SELECT – összes =====
    public List<Tanulo> osszes() {
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            Query<Tanulo> q = session.createQuery("FROM Tanulo", Tanulo.class);
            return q.getResultList();
        }
    }

    // ===== WHERE – nevezett paraméter (preferált) =====
    public List<Tanulo> osztalyAlapjan(String osztaly) {
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            return session.createQuery(
                    "FROM Tanulo t WHERE t.osztaly = :osztaly", Tanulo.class)
                    .setParameter("osztaly", osztaly)
                    .getResultList();
        }
    }

    // ===== Csak egy találat – uniqueResult / getSingleResult =====
    public Tanulo nevAlapjan(String nev) {
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            return session.createQuery(
                    "FROM Tanulo t WHERE t.nev = :nev", Tanulo.class)
                    .setParameter("nev", nev)
                    .uniqueResult(); // null, ha nincs; exception, ha több
        }
    }

    // ===== Több feltétel + ORDER BY =====
    public List<Tanulo> jokTanulok(BigDecimal hatar) {
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            return session.createQuery(
                    "FROM Tanulo t WHERE t.atlag >= :hatar AND t.aktiv = true " +
                    "ORDER BY t.atlag DESC, t.nev ASC", Tanulo.class)
                    .setParameter("hatar", hatar)
                    .getResultList();
        }
    }

    // ===== LIMIT + OFFSET (paginálás) =====
    public List<Tanulo> oldalankent(int oldal, int meret) {
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            return session.createQuery("FROM Tanulo ORDER BY id", Tanulo.class)
                    .setFirstResult(oldal * meret) // OFFSET
                    .setMaxResults(meret)          // LIMIT
                    .getResultList();
        }
    }

    // ===== Csak bizonyos mezők (projection – Object[] tömb) =====
    public List<Object[]> nevEsAtlag() {
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            return session.createQuery(
                    "SELECT t.nev, t.atlag FROM Tanulo t", Object[].class)
                    .getResultList();
            // for (Object[] sor : eredmeny) { String nev = (String) sor[0]; ... }
        }
    }

    // ===== Aggregáló függvények =====
    public Long darab() {
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            return session.createQuery("SELECT COUNT(t) FROM Tanulo t", Long.class)
                    .uniqueResult();
        }
    }

    public BigDecimal atlagAtlaga() {
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            return session.createQuery(
                    "SELECT AVG(t.atlag) FROM Tanulo t", BigDecimal.class)
                    .uniqueResult();
        }
    }

    // ===== GROUP BY – osztályonkénti létszám =====
    public List<Object[]> osztalyonkentiLetszam() {
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            return session.createQuery(
                    "SELECT t.osztaly, COUNT(t) FROM Tanulo t " +
                    "GROUP BY t.osztaly ORDER BY COUNT(t) DESC", Object[].class)
                    .getResultList();
        }
    }

    // ===== JOIN – kapcsolt entitásokkal (egy ország városai) =====
    /*
    "SELECT c FROM Country c JOIN c.cities ct WHERE ct.lakossag > 100000"
    */

    // ===== JOIN FETCH – N+1 probléma elkerülése =====
    /*
    Probléma: a country listához ha lazy a cities, minden country lekérdezésnél
    újabb külön query fut le a cities-re. JOIN FETCH-csel egy query-vel betölti.

    "SELECT DISTINCT c FROM Country c LEFT JOIN FETCH c.cities"
    */

    // ===== UPDATE / DELETE bulk =====
    public int inaktiv(BigDecimal hatar) {
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            session.beginTransaction();
            int erintett = session.createMutationQuery(
                    "UPDATE Tanulo t SET t.aktiv = false WHERE t.atlag < :h")
                    .setParameter("h", hatar)
                    .executeUpdate();
            session.getTransaction().commit();
            return erintett;
        }
    }

    // ===== Natív SQL – ha tényleg kell tábla-szintű query =====
    public List<Tanulo> nativeQuery() {
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            return session.createNativeQuery(
                    "SELECT * FROM tanulok WHERE atlag > 4.0", Tanulo.class)
                    .getResultList();
        }
    }
}

package hu.pelda.jdbc;

import java.math.BigDecimal;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class JdbcPelda {

    private static final String URL  = "jdbc:mysql://localhost:3306/iskola";
    private static final String USER = "root";
    private static final String PASS = "";

    // ===== Kapcsolódás =====
    public static Connection kapcsolat() throws SQLException {
        return DriverManager.getConnection(URL, USER, PASS);
    }

    // ===== INSERT – új sor + visszaadott auto-increment ID =====
    public int beszuras(String nev, String osztaly, BigDecimal atlag) throws SQLException {
        String sql = "INSERT INTO tanulok (nev, osztaly, atlag) VALUES (?, ?, ?)";

        try (Connection conn = kapcsolat();
             PreparedStatement ps = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {

            ps.setString(1, nev);
            ps.setString(2, osztaly);
            ps.setBigDecimal(3, atlag);

            ps.executeUpdate();

            try (ResultSet keys = ps.getGeneratedKeys()) {
                if (keys.next()) {
                    return keys.getInt(1); // a generált id
                }
            }
        }
        return -1;
    }

    // ===== SELECT – egy sor =====
    public Tanulo egyAlapjanId(int id) throws SQLException {
        String sql = "SELECT id, nev, osztaly, atlag FROM tanulok WHERE id = ?";

        try (Connection conn = kapcsolat();
             PreparedStatement ps = conn.prepareStatement(sql)) {

            ps.setInt(1, id);

            try (ResultSet rs = ps.executeQuery()) {
                if (rs.next()) {
                    Tanulo t = new Tanulo();
                    t.id      = rs.getInt("id");
                    t.nev     = rs.getString("nev");
                    t.osztaly = rs.getString("osztaly");
                    t.atlag   = rs.getBigDecimal("atlag");
                    return t;
                }
            }
        }
        return null;
    }

    // ===== SELECT – több sor =====
    public List<Tanulo> osztalyAlapjan(String osztaly) throws SQLException {
        String sql = "SELECT id, nev, osztaly, atlag FROM tanulok " +
                     "WHERE osztaly = ? ORDER BY atlag DESC";

        List<Tanulo> eredmeny = new ArrayList<>();

        try (Connection conn = kapcsolat();
             PreparedStatement ps = conn.prepareStatement(sql)) {

            ps.setString(1, osztaly);

            try (ResultSet rs = ps.executeQuery()) {
                while (rs.next()) {
                    Tanulo t = new Tanulo();
                    t.id      = rs.getInt("id");
                    t.nev     = rs.getString("nev");
                    t.osztaly = rs.getString("osztaly");
                    t.atlag   = rs.getBigDecimal("atlag");
                    eredmeny.add(t);
                }
            }
        }
        return eredmeny;
    }

    // ===== UPDATE =====
    public int modositas(int id, BigDecimal ujAtlag) throws SQLException {
        String sql = "UPDATE tanulok SET atlag = ? WHERE id = ?";

        try (Connection conn = kapcsolat();
             PreparedStatement ps = conn.prepareStatement(sql)) {

            ps.setBigDecimal(1, ujAtlag);
            ps.setInt(2, id);

            return ps.executeUpdate(); // érintett sorok száma
        }
    }

    // ===== DELETE =====
    public int torles(int id) throws SQLException {
        String sql = "DELETE FROM tanulok WHERE id = ?";

        try (Connection conn = kapcsolat();
             PreparedStatement ps = conn.prepareStatement(sql)) {

            ps.setInt(1, id);
            return ps.executeUpdate();
        }
    }

    // ===== Tranzakció – több művelet egy egységként =====
    public void atutalas(int kuldoId, int fogadoId, BigDecimal osszeg) throws SQLException {
        try (Connection conn = kapcsolat()) {
            conn.setAutoCommit(false); // KÉZI tranzakció kezelés

            try (PreparedStatement ki = conn.prepareStatement(
                    "UPDATE szamla SET egyenleg = egyenleg - ? WHERE id = ?");
                 PreparedStatement be = conn.prepareStatement(
                    "UPDATE szamla SET egyenleg = egyenleg + ? WHERE id = ?")) {

                ki.setBigDecimal(1, osszeg);
                ki.setInt(2, kuldoId);
                ki.executeUpdate();

                be.setBigDecimal(1, osszeg);
                be.setInt(2, fogadoId);
                be.executeUpdate();

                conn.commit(); // mindkettő sikerült
            } catch (SQLException e) {
                conn.rollback(); // hibánál semmi nem maradjon meg
                throw e;
            }
        }
    }

    // POJO – belső használatra
    static class Tanulo {
        int id;
        String nev;
        String osztaly;
        BigDecimal atlag;
    }
}

# Spring Boot DataSource konfiguráció + HikariCP connection pool
# A Spring Boot a HikariCP-t használja alapértelmezett connection pool-nak (a leggyorsabb).
# Az application.properties-be írt értékekből automatikusan példányosítja a DataSource-t,
# nem kell külön @Bean-t írni hozzá. Több adatbázishoz kell @ConfigurationProperties-zel egyedi config.

# ===== application.properties – egy adatbázis (tipikus) =====

# Adatbázis URL és driver
spring.datasource.url=jdbc:mysql://localhost:3306/termek_db?useSSL=false&serverTimezone=Europe/Budapest
spring.datasource.username=root
spring.datasource.password=
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# HikariCP connection pool finomhangolás
spring.datasource.hikari.pool-name=TermekHikariPool
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=2
spring.datasource.hikari.idle-timeout=30000
spring.datasource.hikari.max-lifetime=1800000
spring.datasource.hikari.connection-timeout=20000
spring.datasource.hikari.validation-timeout=5000

# JPA / Hibernate beállítások
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect

# ===== Egyedi DataSource kód (ha kézzel kell létrehozni, pl. több DB) =====
# Ehhez a fájlhoz Java részlet:

/*
package hu.pelda.config;

import com.zaxxer.hikari.HikariDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;

@Configuration
public class DataSourceConfig {

    // Elsődleges DB
    @Bean
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource fooDataSource() {
        return new HikariDataSource();
    }

    // Másodlagos DB (pl. egy archiv DB)
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.archiv")
    public DataSource archivDataSource() {
        return new HikariDataSource();
    }
}

# Hozzá tartozó application.properties:
#   spring.datasource.archiv.url=jdbc:mysql://...
#   spring.datasource.archiv.username=...
#   spring.datasource.archiv.password=...
*/

# ===== Profilonkénti DB beállítás =====
# application-dev.properties:
#   spring.datasource.url=jdbc:mysql://localhost:3306/dev_db
#   spring.jpa.hibernate.ddl-auto=update

# application-prod.properties:
#   spring.datasource.url=jdbc:mysql://prod-szerver:3306/prod_db
#   spring.jpa.hibernate.ddl-auto=validate
#   spring.jpa.show-sql=false

# Indítás profilra:
#   mvn spring-boot:run -Dspring-boot.run.profiles=prod
#   java -jar app.jar --spring.profiles.active=prod

# ===== Health check végpont =====
# Spring Boot Actuator-ral:
#   pom.xml: spring-boot-starter-actuator
#   GET /actuator/health  -> { "status": "UP", "components": { "db": ... } }

// ===== pom.xml dependencies =====
/*
<dependencies>
    <!-- Jakarta Persistence API -->
    <dependency>
        <groupId>jakarta.persistence</groupId>
        <artifactId>jakarta.persistence-api</artifactId>
        <version>3.2.0</version>
    </dependency>

    <!-- Hibernate mint JPA implementáció -->
    <dependency>
        <groupId>org.hibernate.orm</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>6.5.2.Final</version>
    </dependency>

    <!-- MySQL driver -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <version>8.4.0</version>
    </dependency>
</dependencies>
*/

// ===== src/main/resources/META-INF/persistence.xml =====
/*
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="https://jakarta.ee/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="https://jakarta.ee/xml/ns/persistence
                 https://jakarta.ee/xml/ns/persistence/persistence_3_2.xsd"
             version="3.2">

    <persistence-unit name="iskolaPU" transaction-type="RESOURCE_LOCAL">

        <!-- JPA implementáció (Hibernate) -->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

        <!-- Mapped osztályok – minden entitást fel kell sorolni -->
        <class>hu.pelda.entity.Tanulo</class>
        <class>hu.pelda.entity.Osztaly</class>

        <properties>
            <!-- DB kapcsolat -->
            <property name="jakarta.persistence.jdbc.driver"   value="com.mysql.cj.jdbc.Driver"/>
            <property name="jakarta.persistence.jdbc.url"      value="jdbc:mysql://localhost:3306/iskola"/>
            <property name="jakarta.persistence.jdbc.user"     value="root"/>
            <property name="jakarta.persistence.jdbc.password" value=""/>

            <!-- Hibernate-specifikus tulajdonságok -->
            <property name="hibernate.dialect"        value="org.hibernate.dialect.MySQLDialect"/>
            <property name="hibernate.show_sql"       value="true"/>
            <property name="hibernate.format_sql"     value="true"/>
            <property name="hibernate.hbm2ddl.auto"   value="update"/>
            <property name="hibernate.connection.pool_size" value="10"/>
        </properties>
    </persistence-unit>
</persistence>
*/

// ===== JpaUtil.java – EntityManagerFactory singleton =====
package hu.pelda.util;

import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.Persistence;

public class JpaUtil {

    private static final EntityManagerFactory emf =
            Persistence.createEntityManagerFactory("iskolaPU");

    public static EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public static void close() {
        emf.close();
    }

    private JpaUtil() {}
}

// ===== EntityManager használata – CRUD =====
package hu.pelda.dao;

import hu.pelda.entity.Tanulo;
import hu.pelda.util.JpaUtil;
import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityTransaction;

import java.util.List;

public class TanuloJpaDao {

    public void mentes(Tanulo tanulo) {
        EntityManager em = JpaUtil.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        try {
            tx.begin();
            em.persist(tanulo); // INSERT
            tx.commit();
        } catch (Exception e) {
            if (tx.isActive()) tx.rollback();
            throw e;
        } finally {
            em.close();
        }
    }

    public Tanulo egy(Integer id) {
        EntityManager em = JpaUtil.getEntityManager();
        try {
            return em.find(Tanulo.class, id); // SELECT id alapján
        } finally {
            em.close();
        }
    }

    public List<Tanulo> osszes() {
        EntityManager em = JpaUtil.getEntityManager();
        try {
            return em.createQuery("FROM Tanulo", Tanulo.class).getResultList();
        } finally {
            em.close();
        }
    }

    public Tanulo modositas(Tanulo tanulo) {
        EntityManager em = JpaUtil.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        try {
            tx.begin();
            Tanulo merged = em.merge(tanulo); // UPDATE (vagy INSERT detached objektumnál)
            tx.commit();
            return merged;
        } finally {
            em.close();
        }
    }

    public void torles(Integer id) {
        EntityManager em = JpaUtil.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        try {
            tx.begin();
            Tanulo t = em.find(Tanulo.class, id);
            if (t != null) em.remove(t); // DELETE
            tx.commit();
        } finally {
            em.close();
        }
    }
}

// ===== JPA vs Hibernate API – fő különbségek =====
/*
- jakarta.persistence.* (JPA, szabvány)  vs  org.hibernate.* (Hibernate-specifikus)
- EntityManager                          vs  Session
- EntityManagerFactory                   vs  SessionFactory
- em.persist(), em.find(), em.merge()    vs  session.persist(), session.get(), session.merge()
- em.createQuery(JPQL)                   vs  session.createQuery(HQL)
- persistence.xml                        vs  hibernate.cfg.xml

A Hibernate megvalósítja a JPA-t, de van extra funkciója is.
JPA = szabvány, Hibernate = implementáció.
*/

import java.util.*;
import java.util.stream.*;

public class StreamPelda {

    public static void main(String[] args) {

        // ===== filter – szűrés feltétel alapján =====
        List<Integer> szamok = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        List<Integer> parosak = szamok.stream()
                .filter(n -> n % 2 == 0)
                .toList(); // [2, 4, 6, 8, 10]

        // ===== map – minden elem transzformálása =====
        List<Integer> negyzetek = szamok.stream()
                .map(n -> n * n)
                .toList(); // [1, 4, 9, 16, ...]

        List<String> szovegek = szamok.stream()
                .map(n -> "Szám: " + n)
                .toList();

        // ===== filter + map láncolva =====
        List<Integer> parosNegyzet = szamok.stream()
                .filter(n -> n % 2 == 0)
                .map(n -> n * n)
                .toList(); // [4, 16, 36, 64, 100]

        // ===== sorted, distinct, limit, skip =====
        List<Integer> rendezett = szamok.stream()
                .distinct()                     // ismétlődések kiszűrése
                .sorted(Comparator.reverseOrder())
                .limit(3)                       // első N elem
                .skip(1)                        // első elem átugrása
                .toList();

        // ===== count, sum, average – aggregáció =====
        long parosakSzama = szamok.stream()
                .filter(n -> n % 2 == 0)
                .count(); // 5

        int osszeg = szamok.stream()
                .mapToInt(Integer::intValue)
                .sum(); // 55

        OptionalDouble atlag = szamok.stream()
                .mapToInt(Integer::intValue)
                .average();

        // ===== reduce – egyedi aggregáció =====
        int szorzat = szamok.stream()
                .reduce(1, (a, b) -> a * b); // 1*2*3*...*10 = 3628800

        Optional<Integer> max = szamok.stream().max(Comparator.naturalOrder());
        Optional<Integer> min = szamok.stream().min(Comparator.naturalOrder());

        // ===== anyMatch, allMatch, noneMatch =====
        boolean vanParos     = szamok.stream().anyMatch(n -> n % 2 == 0); // true
        boolean mindPozitiv  = szamok.stream().allMatch(n -> n > 0);       // true
        boolean nincsNegativ = szamok.stream().noneMatch(n -> n < 0);      // true

        // ===== forEach – terminál művelet =====
        szamok.stream()
                .filter(n -> n > 5)
                .forEach(System.out::println);

        // ===== Object Stream – User példa =====
        record User(String nev, int kor, String varos) { }

        List<User> users = List.of(
                new User("Anna", 25, "Budapest"),
                new User("Béla", 30, "Debrecen"),
                new User("Cili", 22, "Budapest"),
                new User("Dóra", 40, "Szeged")
        );

        // 25 év fölöttiek nevei nagybetűsen
        List<String> idosebbek = users.stream()
                .filter(u -> u.kor() > 25)
                .map(User::nev)
                .map(String::toUpperCase)
                .sorted()
                .toList(); // [BÉLA, DÓRA]

        // ===== Collectors.joining – stringgé összefűzés =====
        String nevek = users.stream()
                .map(User::nev)
                .collect(Collectors.joining(", ", "[", "]"));
        // [Anna, Béla, Cili, Dóra]

        // ===== Collectors.groupingBy – csoportosítás =====
        Map<String, List<User>> varosonkent = users.stream()
                .collect(Collectors.groupingBy(User::varos));
        // { "Budapest" = [Anna, Cili], "Debrecen" = [Béla], "Szeged" = [Dóra] }

        // ===== groupingBy + counting =====
        Map<String, Long> varosonkentiSzam = users.stream()
                .collect(Collectors.groupingBy(User::varos, Collectors.counting()));
        // { "Budapest" = 2, "Debrecen" = 1, "Szeged" = 1 }

        // ===== groupingBy + averaging =====
        Map<String, Double> varosonkentiAtlagKor = users.stream()
                .collect(Collectors.groupingBy(
                        User::varos,
                        Collectors.averagingInt(User::kor)
                ));

        // ===== partitioningBy – kettéosztás boolean alapján =====
        Map<Boolean, List<User>> felosztva = users.stream()
                .collect(Collectors.partitioningBy(u -> u.kor() >= 30));
        // { false = [Anna, Cili], true = [Béla, Dóra] }

        // ===== Collectors.toMap =====
        Map<String, Integer> nevKor = users.stream()
                .collect(Collectors.toMap(User::nev, User::kor));

        // ===== flatMap – beágyazott lista lapítása =====
        List<List<Integer>> beagyazott = List.of(
                List.of(1, 2, 3),
                List.of(4, 5),
                List.of(6, 7, 8, 9)
        );
        List<Integer> lapitott = beagyazott.stream()
                .flatMap(List::stream)
                .toList(); // [1, 2, 3, 4, 5, 6, 7, 8, 9]

        // ===== peek – debugging eszköz (közbenső, NEM terminal) =====
        List<Integer> peekPelda = szamok.stream()
                .filter(n -> n > 5)
                .peek(n -> System.out.println("átengedve: " + n))
                .map(n -> n * 10)
                .peek(n -> System.out.println("transzformálva: " + n))
                .toList();

        // ===== IntStream.range – számtartomány =====
        int sum1to100 = IntStream.rangeClosed(1, 100).sum(); // 5050

        IntStream.range(0, 10)
                .filter(i -> i % 2 == 0)
                .forEach(System.out::println); // 0, 2, 4, 6, 8

        // ===== Stream.of, Stream.generate, Stream.iterate =====
        Stream.of("a", "b", "c").forEach(System.out::println);

        Stream.iterate(1, n -> n * 2)
                .limit(10)
                .forEach(System.out::println); // 1, 2, 4, 8, ..., 512
    }
}