;----------Zadanie c. 23-----------



;----------spustacia funkcia + menu----------
;start :: nil -> string
(defun start ()
  (setq polia nil)
  (prog (menu)
    start
    (princ "##################################") (terpri)
    (princ "#Vytvor prazdne pole .......... 1#") (terpri)
    (princ "#Precitaj prvok ............... 2#") (terpri)
    (princ "#Zapisat prvok ................ 3#") (terpri)
    (princ "#Je pole prazdne? ............. 4#") (terpri)
    (princ "#Zobrazit pole ................ 5#") (terpri)
    (princ "#Zobrazenie vsetkych poli ..... 6#") (terpri)
    (princ "#Zobrazit reprezentaciu pola .. 7#") (terpri) 
    (princ "#--------------------------------#") (terpri)
    (princ "#Koniec ....................... 0#") (terpri)
    (princ "##################################") (terpri)
    (setq menu (read))
    choice
    (cond ((eq menu 1) (EMPTY (enter_name) (enter_size_x) (enter_size_y)))
          ((eq menu 2) (READP (enter_name) (enter_x) (enter_y)))
          ((eq menu 3) (WRITEP (enter_name) (enter_x) (enter_y) (enter_el)))
          ((eq menu 4) (ISEMPTY (enter_name)))
          ((eq menu 5) (SHOW (enter_name)))
          ((eq menu 6) (SHOW-ALL))
          ((eq menu 7) (SHOW-REP (enter_name)))         
          ((eq menu 0) (return "Koniec Programu"))
    )
    (go start)
  )
)




;-----------funkcie vyssej urovne---------------------
;vypisanie vsetkych poli
;SHOW-ALL :: nul -> nil
(defun SHOW-ALL ()
  (princ "Vypis vsetkych poli") (terpri) (showall polia)
)

;vypisanie pola
;SHOW :: alfa -> nil
(defun SHOW (meno)
  (cond ((NOT (ATOM meno)) (terpri) (princ "Neplatny nazov pola") (terpri) (terpri))
        ((NOT (member meno polia)) (princ "Zadane pole neexistuje") (terpri) (terpri))
        (T (showxx meno (eval meno)) (terpri))
   )
)

;zobrazenie reprezentacie pola
;SHOW-REP :: alfa -> nil
(defun SHOW-REP (meno)
  (cond ((NOT (ATOM meno)) (terpri) (princ "Neplatny nazov pola") (terpri) (terpri))
        ((NOT (member meno polia)) (princ "Zadane pole neexistuje") (terpri) (terpri))
        (T (showrepxx meno (eval meno)) (terpri))
   )
)


;vytovrenie prazdnej mnoziny so zadanymi rozmermy
;EMPTY :: alfa int int -> bool
(defun EMPTY (meno x y)
  (cond ((NOT (ATOM meno)) (terpri)(princ "Neplatny nazov pola") (terpri) nil)
        ((NOT (NUMBERP x)) (princ "Pocet stlpcov musi byt cislo") (terpri) nil)
        ((NOT (NUMBERP y)) (princ "Pocet riadkov musi byt cislo") (terpri) nil)
        (T (addpolexx meno x y) T)

   )
)

;zapise do zadaneho pola na zadanu poziciu element
;WRITEP :: alfa int int [alfa] -> bool
(defun WRITEP (meno x y el)
  (cond ((NOT (member meno polia)) (princ "Zadane pole neexistuje") (terpri) (terpri))
        ((NOT (NUMBERP x)) (princ "Cislo stlpca musi byt cislo") (terpri) nil)
        ((NOT (NUMBERP y)) (princ "Cislo riadku musi byt cislo") (terpri) nil)

        ((writexx (getpolexx meno) x y el) (princ "Hodnota bola zapisana") (terpri) T)
        (T (princ "Nepodarilo sa zapisat prvok. Nespravne suradnice") (terpri))
  )
)

;precitanie elementu na danej pozicii
;READP :: alfa int int -> bool
(defun READP (meno x y)
  (cond ((NOT (member meno polia)) (princ "Zadane pole neexistuje") (terpri) (terpri))
        ((NOT (NUMBERP x)) (princ "Cislo stlpca musi byt cislo") (terpri) nil)
        ((NOT (NUMBERP y)) (princ "Cislo riadku musi byt cislo") (terpri) nil)

        (T (princ "Prvok na zadanej pozicii: ") (princ (readxx (getpolexx meno) x y)) (terpri) (terpri) T)
  )
)


;zistenie, ci je pole prazdne
;ISEMPTY :: alfa -> bool
(defun ISEMPTY (meno)
  (cond ((NOT (member meno polia)) (princ "Zadane pole neexistuje") (terpri) (terpri))
        ((isemptyxx (eval meno)) (princ "Zadane pole je prazdne") (terpri) (terpri) T)
        (T (princ "Zadane pole nie je prazdne") (terpri) (terpri) nil)
  )
)


;----------praca s obsahom pola----------
;indexovane 0 - (n-1) vracia nil ak neplatne suradnice
;najde spravny riadok
;writexx [alfa] int int [alfa] -> nil
(defun writexx (pole x y el)
  (cond ((NULL pole) nil)
        ((= y 0) (writeline (first pole) x el))
        (T (writexx (rest pole) x (- y 1) el))
  )
)

;indexovane 0 - (n-1) vracia nil ak neplatne suradnice
;zapisanie na spravnu poziciu v riadku
;writeline :: [alfa] int [alfa] -> bool
(defun writeline (pole x el)
  (cond ((NULL pole) nil)
        ((= x 0) (setf (first pole) el) T)
        (T (writeline (rest pole) (- x 1) el))
  )
)

;indexovane 0 - (n-1) vracia nil ak neplatne suradnice
;najde spravny riadok
;readxx :: [alfa] int int -> [alfa]
(defun readxx (pole x y)
  (cond ((NULL pole) nil)
        ((= y 0) (readline (first pole) x))
        (T (readxx (rest pole) x (- y 1)))
  )
)

;indexovane 0 - (n-1) vracia nil ak neplatne suradnice
;vrati spravny prvok
;readline [alfa] int -> [alfa]
(defun readline (pole x)
  (cond ((NULL pole) nil)
        ((= x 0) (first pole))
        (T (readline (rest pole) (- x 1)))
  )
)
;vrati T ak je pole prazdne inak nil
;isemptyxx :: [alfa] -> bool
(defun isemptyxx (pole)
  (cond ((NULL pole) T)
        ((isemptyline (first pole)) (isemptyxx (rest pole)))
        (T nil)
  )
)

;pomocna funkcia pre isemptyxx (vrati pravdu ak riadok je prazdny
;isemptyline [alfa] -> bool
(defun isemptyline (line)
  (cond ((NULL line) T)
        ((EQ (first line) NIL) (isemptyline (rest line)))
        (T nil)
  )
)
;zobrazi pole a vypise aj meno ktore bolo na vstup pridane
;showxx :: alfa [alfa] -> nil
(defun showxx (meno pole)
  (cond ((NULL pole) (princ "Pole neexistuje alebo ma rozmer 0x0") (terpri))
        ((princ "Pole ") (princ meno) (princ ":") (terpri) (showpole pole))
  )
)

;zobrazi pole
;showpole :: [alfa] -> nil
(defun showpole (pole)
  (cond ((NULL pole) nil)
        (T (princ "[") (showline (first pole)) (princ "]") (terpri) (showpole (rest pole)))
  )
)

;zobrazi riadok pola
;showline :: [alfa] -> nil
(defun showline (line)
  (cond ((NULL line) nil)
        (T (princ " ") (princ (first line)) (princ " ") (showline (rest line)))
  )
)

;zobrazi pole ako je reprezentovane
;showrepxx :: alfa [alfa] -> nil
(defun showrepxx (meno pole)
  (cond ((NULL pole) (princ "Pole neexistuje alebo ma rozmer 0x0") (terpri))
        (T (princ "Pole ") (princ meno) (princ ":") (terpri) (princ pole) (terpri))
  )
)

;zobrazi vsetky polia
;showall :: [alfa] -> string
(defun showall (policka)
  (cond ((NULL policka) nil)
        (T (showxx (first policka) (eval (first policka))) (terpri) (showall (rest policka)))
  )
)

;------------------------pracuje s menami poli--------------------------------
;vrati pole ak existuje (ak nie tak nil)
;getpolexx :: alfa -> [alfa]
(defun getpolexx (nazov)
  (getpole nazov polia)
)
;prida pole nazvu a rozmerov
;addpolexx :: nazov int int -> nil
(defun addpolexx (nazov x y)
  (cond ((NOT (setpole nazov)) (princ "Pole so zadanym nazov uz existuje") (terpri) (terpri))
        (T (set nazov (clear x y)) (princ "Pole bolo uspesne vyvorene") (terpri) (terpri))
 )
)

;vrati pole ak existuje
;getpole :: alfa [alfa] -> [alfa]
(defun getpole (nazov nazvy)
  (cond ((null nazvy) nil)
        ((EQ nazov (first nazvy)) (eval nazov))
        (T (getpole nazov (rest nazvy)))
  )
)
;prida meno do pola nazvov polia
;setpole alfa -> bool
(defun setpole (nazov)
  (cond ((member nazov polia) nil)
        (T (setq polia (cons nazov polia)))
  )
)
;skonstruuje pole x y prazdne
;clear :: int int -> nil
(defun clear (x y)
  (cond ((> y 0) (cons (clearline x) (clear x (- y 1))))
        (T nil)
  )
)
;skonstruuje prazdny riadok
;clearline int -> nil
(defun clearline (x)
  (cond ((> x 0) (cons nil (clearline (- x 1))))
        (T nil)
  )
)

;----------funkcie na spracovanie vstupu----------
;vypisanie poziadavky na zadanie mena a nacitanie vstupu
;enter_name :: nil -> alfa
(defun enter_name () (princ "Zadaj meno pola: ") (read))

;vypisanie poziadavky na zadanie rozmerov a nacitanie vstupu
;enter_size_x :: nil -> alfa
(defun enter_size_x () (princ "Zadaj pocet stlpcov pola: ") (read))

;vypisanie poziadavky na zadanie rozmerov a nacitanie vstupu
;enter_size_y :: nil -> alfa
(defun enter_size_y () (princ "Zadaj pocet riadkov pola: ") (read))

;vypisanie poziadavky na zadanie umiestnenia prvku a nacitanie vstupu
;enter_x :: nil -> alfa
(defun enter_x () (princ "Zadaj stlpec pola: ") (read))

;vypisanie poziadavky na zadanie umiestnenia prvku a nacitanie vstupu
;enter_y :: nil -> alfa
(defun enter_y () (princ "Zadaj riadok pola: ") (read))

;vypisanie poziadavky na zadanie elementu a nacitanie vstupu
;enter_el :: nil -> alfa
(defun enter_el () (princ "Zadaj hodnotu, ktoru chces zapisat do pola: ") (read))