(Common Lisp)

; V Lispu je VŽDY: (funkce arg1 arg2 ...)
; To je vše – žádná jiná syntaxe neexistuje!

(+ 1 2)             ; → 3  (sčítání)
(* 3 4 5)           ; → 60 (násobení více čísel)
(+ 1 (* 2 3))       ; → 7  (vnořené výrazy)

; Porovnání s "infix" zápisem:
;  Python:  1 + 2 * 3
;  CL:      (+ 1 (* 2 3))  — jednoznačné, bez priorit!

(print "Ahoj světe!")  ; vypíše řetězec

; Quote (') zabrání vyhodnocení – vrátí symbol/seznam doslova
(print 'ahoj)         ; → AHOJ (symbol, ne volání funkce)
(print '(1 2 3))    ; → (1 2 3) (seznam, ne výpočet)
(print  (+ 1 2))    ; → 3 (vyhodnotí se)

; Backquote (`) a comma (,) – pro makra a šablony
(let ((x 42))
  (print `(hodnota je ,x)))  ; → (HODNOTA JE 42)

; Typ hodnoty zjistíme funkcí TYPE-OF
(type-of 42)      ; → (INTEGER 0 4611686018427387903)
(type-of "ahoj")  ; → (SIMPLE-ARRAY CHARACTER (4))
(type-of 'x)      ; → SYMBOL
(type-of nil)     ; → NULL

; Základní funkce – sčítání dvou čísel
(defun secti (a b)
  "Vrátí součet čísel a a b."   ; docstring (volitelný)
  (+ a b))                     ; poslední výraz je návratová hodnota

(secti 3 4)   ; → 7

; Volitelné parametry – &optional
(defun pozdrav (jmeno &optional (titul "pane"))
  (format nil "Dobrý den, ~a ~a!" titul jmeno))

(pozdrav "Novák")            ; → "Dobrý den, pane Novák!"
(pozdrav "Nováková" "paní")  ; → "Dobrý den, paní Nováková!"

; Zbývající argumenty – &rest
(defun secti-vse (&rest cisla)
  (apply #'+ cisla))

(secti-vse 1 2 3 4 5)   ; → 15

; Klíčové parametry – &key (pojmenované argumenty)
(defun vytvor-uzivatel (&key jmeno
                                (vek 0)
                                (role :uzivatel))
  (list :jmeno jmeno :vek vek :role role))

(vytvor-uzivatel :jmeno "Karel" :vek 30 :role :admin)
; → (:JMENO "Karel" :VEK 30 :ROLE :ADMIN)

; Lambda – anonymní funkce
(funcall (lambda (x) (* x x)) 5)   ; → 25

; Uzávěr – funkce, která si pamatuje prostředí
(defun vytvor-scitac (n)
  (lambda (x) (+ x n)))   ; zachytí n z vnějšího prostředí

(defvar *pricti-10* (vytvor-scitac 10))
(funcall *pricti-10* 5)    ; → 15
(funcall *pricti-10* 100)  ; → 110

; Funkce vyššího řádu – MAPCAR, FUNCALL, APPLY
(mapcar #'sqrt '(4 9 16 25))
; → (2.0 3.0 4.0 5.0)

(mapcar (lambda (x) (* x 2)) '(1 2 3 4 5))
; → (2 4 6 8 10)

(remove-if #'oddp '(1 2 3 4 5 6))
; → (2 4 6)  – odstraní lichá čísla

(reduce #'+ '(1 2 3 4 5))
; → 15  – sečte všechny prvky

; Jednoduchý nekonečný cyklus
(loop
  (print "stále")
  (return))   ; RETURN ukončí smyčku

; FOR iterace přes čísla
(loop for i from 1 to 5
      do (format t "~a~%" i))

; Sběr výsledků do seznamu
(loop for i from 1 to 5
      collect (* i i))
; → (1 4 9 16 25)

; Filtrování a součet
(loop for x in '(1 2 3 4 5 6 7 8)
      when (evenp x)
      sum x)
; → 20  (2+4+6+8)

; Více proměnných, podmínka ukončení
(loop for i from 0
      for j in '(a b c d)
      collect (list i j))
; → ((0 A) (1 B) (2 C) (3 D))

; Maximize, minimize, count
(loop for x in '(3 1 4 1 5 9 2 6)
      maximize x)   ; → 9

; Vytvoření seznamu
(list 1 2 3)           ; → (1 2 3)
'(a b c)               ; → (A B C) – zkratka přes quote
(cons 1 (cons 2 nil))   ; → (1 2) – ruční stavba

; Přístup k prvkům
(car '(1 2 3))         ; → 1   (první prvek)
(cdr '(1 2 3))         ; → (2 3)  (zbytek)
(cadr '(1 2 3))        ; → 2   (car z cdr = druhý)
(caddr '(1 2 3))       ; → 3   (třetí)
(first '(a b c))       ; → A   (čitelnější alias)
(second '(a b c))      ; → B
(last '(1 2 3))        ; → (3) – seznam s posledním!
(nth 2 '(a b c d))    ; → C   (0-indexed)

; Délka a vlastnosti
(length '(a b c))      ; → 3
(null nil)             ; → T   (prázdný?)
(member 3 '(1 2 3 4)) ; → (3 4)  (je prvek v seznamu?)

; Spojování a manipulace
(append '(1 2) '(3 4) '(5))   ; → (1 2 3 4 5)
(reverse '(1 2 3))             ; → (3 2 1)
(sort '(3 1 4 1 5) #'<)        ; → (1 1 3 4 5)
(remove-duplicates '(1 2 2 3 3 3)) ; → (1 2 3)

; Funkcionální transformace
(mapcar #'1+ '(1 2 3))         ; → (2 3 4)
(remove-if #'evenp '(1 2 3 4 5)) ; → (1 3 5)
(find-if #'evenp '(1 3 4 5))    ; → 4
(count-if #'oddp '(1 2 3 4 5))  ; → 3
(reduce #'+ '(1 2 3 4 5))       ; → 15

; Asociativní seznam (alist) – klíč/hodnota
(defvar *konfig*
  '((:host . "localhost") (:port . 5432) (:db . "mydb")))
(cdr (assoc :port *konfig*))   ; → 5432

; Přesné zlomky – žádná ztráta přesnosti!
(+ 1/3 1/6)           ; → 1/2   (ne 0.5000001)
(* 3/7 7/3)           ; → 1     (přesně)
(/ 10 3)             ; → 10/3  (ne 3.333...)

; Bignums – celá čísla libovolné velikosti
(expt 2 100)
; → 1267650600228229401496703205376 (přesně!)

(faktorial 50)
; → 30414093201713378043612608166979581188299763898377856000000000000

; Komplexní čísla
(sqrt -1)             ; → #C(0.0 1.0)  (= i)
(+ #C(3 4) #C(1 -2)) ; → #C(4 2)

; Definice třídy
(defclass zvire ()
  ((jmeno
    :initarg :jmeno
    :accessor zvire-jmeno
    :initform "Neznámé")
   (hlas
    :initarg :hlas
    :accessor zvire-hlas
    :initform "..."))
  (:documentation "Základní třída pro všechna zvířata."))

; Podtřída – dědí od zvire
(defclass pes (zvire)
  ((plemeno
    :initarg :plemeno
    :accessor pes-plemeno)))

(defclass kocka (zvire)
  ((indoor
    :initarg :indoor
    :accessor kocka-indoor
    :initform t)))

; Generická funkce + metody
(defgeneric predstav-se (z)
  (:documentation "Zvíře se představí."))

(defmethod predstav-se ((z zvire))
  (format t "Jsem ~a a říkám '~a'~%"
          (zvire-jmeno z) (zvire-hlas z)))

(defmethod predstav-se ((p pes))
  (call-next-method)       ; zavolá metodu z předka
  (format t "Jsem ~a!~%" (pes-plemeno p)))

; Vytvoření instancí
(defvar *rex*
  (make-instance 'pes
    :jmeno   "Rex"
    :hlas    "Haf!"
    :plemeno "Ovčák"))

(defvar *micka*
  (make-instance 'kocka
    :jmeno "Míčka"
    :hlas  "Mňau"))

(predstav-se *rex*)    ; Jsem Rex a říkám 'Haf!' + Jsem Ovčák!
(predstav-se *micka*)  ; Jsem Míčka a říkám 'Mňau'

; Before/after metody – AOP v Lispu
(defmethod predstav-se :before ((z zvire))
  (format t "--- Začátek představení ---~%"))

(defmethod predstav-se :after ((z zvire))
  (format t "--- Konec ---~%"))

; Kontrola instance
(typep *rex* 'pes)     ; → T
(typep *rex* 'zvire)  ; → T (dědičnost)

; Jednoduché makro – swap! (prohození dvou proměnných)
(defmacro swap! (a b)
  (let ((tmp (gensym "TMP")))  ; gensym = unikátní symbol
    `(let ((,tmp ,a))
       (setf ,a ,b)
       (setf ,b ,tmp))))

(defvar x 1)
(defvar y 2)
(swap! x y)  ; x=2, y=1

; Makro – "while" smyčka (CL ji nemá nativně)
(defmacro while (podminka &body telo)
  `(loop while ,podminka do ,@telo))

(defvar n 0)
(while (< n 5)
  (print n)
  (incf n))

; Makro pro logování
(defmacro with-logging (nazev &body telo)
  `(progn
     (format t ">>> Začátek: ~a~%" ,nazev)
     (let ((vysledek (progn ,@telo)))
       (format t "<<< Konec: ~a, výsledek: ~a~%" ,nazev vysledek)
       vysledek))))

(with-logging "výpočet"
  (+ 2 3))
; >>> Začátek: výpočet
; <<< Konec: výpočet, výsledek: 5

; MACROEXPAND – zobrazí expandovaný kód (pro ladění)
(macroexpand-1 '(while (< n 5) (print n)))

; HANDLER-CASE – zachytí podmínku (jako try/catch)
(handler-case
  (/ 10 0)                         ; chybný výraz
  (division-by-zero (e)
    (format t "Dělení nulou: ~a~%" e))
  (error (e)
    (format t "Jiná chyba: ~a~%" e)))

; IGNORE-ERRORS – ignoruj chybu, vrať NIL
(ignore-errors
  (/ 10 0))      ; → NIL (bez crash)

; Definice vlastní podmínky
(define-condition moje-chyba (error)
  ((zprava :initarg :zprava :accessor chyba-zprava))
  (:report
    (lambda (c stream)
      (format stream "Moje chyba: ~a" (chyba-zprava c)))))

; Vyvolání a zachycení vlastní podmínky
(handler-case
  (error 'moje-chyba :zprava "Něco se pokazilo!")
  (moje-chyba (e)
    (format t "Zachyceno: ~a~%" (chyba-zprava e))))

; UNWIND-PROTECT – garantuje provedení cleanup (jako finally)
(unwind-protect
  (format t "Pracuji...~%")
  (format t "Cleanup – vždy se provede~%"))

; WITH-OPEN-FILE – doporučený způsob (automaticky zavře soubor)

; ── ZÁPIS ─────────────────────────────────────────
(with-open-file (stream "data.txt"
                  :direction :output
                  :if-exists :supersede)
  (format stream "Karel Novák~%")
  (format stream "30~%")
  (format stream "Praha~%"))

; ── ČTENÍ ŘÁDEK PO ŘÁDKU ──────────────────────────
(with-open-file (stream "data.txt"
                  :direction :input)
  (loop for radek = (read-line stream nil nil)
        while radek
        do (format t "~a~%" radek)))

; ── ČTENÍ S-VÝRAZŮ ────────────────────────────────
; Uložíme Lispová data
(with-open-file (s "config.lisp" :direction :output
                   :if-exists :supersede)
  (print '(:verze "1.0" :debug t :port 8080) s))

; Načteme zpět
(with-open-file (s "config.lisp")
  (defvar *konfig* (read s)))

; Zjistit zda soubor existuje
(probe-file "data.txt")   ; → pathname nebo NIL

; Smazat soubor
(delete-file "data.txt")

;;;; ================================================
;;;; DATABÁZE KONTAKTŮ – Common Lisp
;;;; Demonstruje: CLOS, soubory, funkcionální styl
;;;; ================================================

;; ── Datový model ──────────────────────────────────
(defclass kontakt ()
  ((id      :initarg :id      :accessor kontakt-id)
   (jmeno   :initarg :jmeno   :accessor kontakt-jmeno)
   (telefon :initarg :telefon :accessor kontakt-telefon)
   (email   :initarg :email   :accessor kontakt-email))
  (:documentation "Jeden záznam kontaktu."))

(defparameter *databaze* '()
  "Seznam všech kontaktů.")

(defparameter *posledni-id* 0)

;; ── Pomocné funkce ────────────────────────────────
(defun nove-id ()
  (incf *posledni-id*))

(defmethod print-object ((k kontakt) stream)
  (format stream
    "[~3d] ~20a ~15a ~a"
    (kontakt-id k)
    (kontakt-jmeno k)
    (kontakt-telefon k)
    (kontakt-email k)))

;; ── CRUD operace ──────────────────────────────────
(defun pridat-kontakt (jmeno telefon email)
  "Přidá nový kontakt do databáze."
  (let ((k (make-instance 'kontakt
              :id      (nove-id)
              :jmeno   jmeno
              :telefon telefon
              :email   email)))
    (push k *databaze*)
    k))

(defun najdi-kontakt (hledani)
  "Najde kontakty dle jména (case-insensitive)."
  (remove-if-not
    (lambda (k)
      (search (string-upcase hledani)
              (string-upcase (kontakt-jmeno k))))
    *databaze*))

(defun smazat-kontakt (id)
  "Smaže kontakt dle ID."
  (setf *databaze*
    (remove-if
      (lambda (k) (= (kontakt-id k) id))
      *databaze*)))

(defun vypis-vsechny ()
  (if (null *databaze*)
    (format t "Databáze je prázdná.~%")
    (dolist (k (reverse *databaze*))
      (format t "~a~%" k))))

;; ── Persistence ───────────────────────────────────
(defun uloz-databazi (soubor)
  (with-open-file (s soubor
                    :direction :output
                    :if-exists :supersede)
    (format s "~s~%"
      (mapcar
        (lambda (k)
          (list (kontakt-id k)
                (kontakt-jmeno k)
                (kontakt-telefon k)
                (kontakt-email k)))
        *databaze*))))
  (format t "Uloženo do ~a~%" soubor))

;; ── Spuštění – ukázková data ──────────────────────
(pridat-kontakt "Karel Novák"    "602 111 222" "karel@example.cz")
(pridat-kontakt "Jana Nováková"  "603 333 444" "jana@example.cz")
(pridat-kontakt "Petr Kratochvíl" "604 555 666" "petr@work.cz")

(format t "~%=== Všechny kontakty ===~%")
(vypis-vsechny)

(format t "~%=== Hledám 'novák' ===~%")
(dolist (k (najdi-kontakt "novák"))
  (format t "~a~%" k))

(format t "~%Celkem: ~a kontaktů~%" (length *databaze*))
(uloz-databazi "kontakty.lisp")