#lang racket
(struct int (n) #:transparent)
(struct true () #:transparent)
(struct false () #:transparent)

(struct complex (a b) #:transparent)
(struct empty () #:transparent)

(struct :: (e1 e2) #:transparent)
(struct if-then-else (condition e1 e2) #:transparent)

(struct is-int (e1) #:transparent)
(struct is-bool (e1) #:transparent)
(struct is-complex (e1) #:transparent)
(struct is-list (e1) #:transparent)
(struct add (e1 e2) #:transparent)
(struct mul (e1 e2) #:transparent)
(struct gt (e1 e2) #:transparent)

(struct both (e1 e2) #:transparent)
(struct any (e1 e2) #:transparent)
(struct ! (e1) #:transparent)

(struct hd (x) #:transparent)
(struct tl (x) #:transparent)
(struct is-empty (x) #:transparent)
(struct @ (a b) #:transparent)

(struct real (e1) #:transparent)
(struct imaginary (e1) #:transparent)

(struct var (s e1 e2) #:transparent)
(struct valof (s) #:transparent)

(struct fun (name fargs body) #:transparent)
(struct proc (name body) #:transparent)
(struct envelope (env f) #:transparent)
(struct call (e args) #:transparent)
;

(define (mi e okolje)
  (letrec ([mi2 (lambda (e okolje)
                  (cond
                    #|Podatkovni tipi |#
                    [(int? e) e]
                    [(true? e) e]
                    [(false? e) e]
                    [(complex? e) (let
                                      ([v1 (mi2 (complex-a e) okolje)]
                                       [v2 (mi2 (complex-b e) okolje)])
                                    (complex v1 v2))]
                    [(::? e) (let
                                 ([v1 (mi2(::-e1 e) okolje)]
                                  [v2 (mi2(::-e2 e) okolje)])
                               (:: v1 v2)
                               )]
                    [(empty? e) e]
                    #|Nadzor toka|#
                    [(if-then-else? e) (let ([c (mi2(if-then-else-condition e) okolje)]
                                             [e1 (if-then-else-e1 e)]
                                             [e2 (if-then-else-e2 e)])
                                         (if(true? c) (mi2 e1 okolje) (mi2 e2 okolje)))]
                    [(is-int? e) (if(int? (mi2 (is-int-e1 e) okolje)) (true) (false))]

                    [(is-bool? e) (cond [(true? (mi2 (is-bool-e1 e) okolje)) (true)]
                                        [(false? (mi2 (is-bool-e1 e) okolje)) (true)]
                                        [else (false)])]

                    [(is-complex? e) (if(complex? (mi2 (is-complex-e1 e) okolje)) (true) (false))]

                    [(is-list? e) (cond [(empty? (mi2 (is-list-e1 e) okolje)) (true)]
                                        [(::? (mi2 (is-list-e1 e) okolje)) (true)]
                                        [else (false)])]

                    [(add? e) (cond
                                [(and (int? (mi2 (add-e1 e) okolje )) (int? (mi2 (add-e1 e) okolje)) ) (int (+ (int-n (mi2 (add-e1 e) okolje)) (int-n (mi2 (add-e2 e) okolje))))]
                                [(and (complex? (mi2 (add-e1 e) okolje)) (complex? (mi2 (add-e1 e) okolje))) (complex (+ (int-n (complex-a (mi2 (add-e1 e) okolje))) (int-n (complex-a (mi2 (add-e2 e) okolje))))  (+ (int-n (complex-b (mi2 (add-e1 e) okolje))) (int-n (complex-b (mi2 (add-e2 e) okolje)))))])]

                    [(mul? e) (cond
                                [(and (int? (mi2 (mul-e1 e) okolje)) (int? (mi2 (mul-e1 e) okolje))) (int(* (int-n (mi2 (mul-e1 e) okolje)) (int-n (mi2 (mul-e2 e) okolje))))]
                                [(and (complex? (mi2 (mul-e1 e) okolje)) (complex? (mi2 (mul-e1 e) okolje))) (complex (* (int-n (complex-a (mi2 (mul-e1 e) okolje))) (int-n (complex-a (mi2 (mul-e2 e) okolje))))  (* (int-n (complex-b (mi2 (mul-e1 e) okolje))) (int-n (complex-b (mi2 (mul-e2 e) okolje)))))])]

                    [(gt? e) (let ([v1 (mi2 (gt-e1 e) okolje)]
                                   [v2 (mi2 (gt-e2 e) okolje)])
                               (if(> (int-n v1) (int-n v2)) (true) (false)))]

                    [(both? e) (let ([v1 (mi2 (both-e1 e) okolje)]
                                     [v2 (mi2 (both-e2 e) okolje)])
                                 (cond [(and (true? (mi2 (is-bool v1) okolje)) (true? (mi2 (is-bool v2) okolje))) (if(and (true? v1) (true? v2)) (true) (false))]
                                       [else (false)]))]

                    [(any? e) (let ([v1 (mi2 (any-e1 e) okolje)]
                                    [v2 (mi2 (any-e2 e) okolje)])
                                (cond [(and (true? (mi2(is-bool v1) okolje)) (true? (mi2(is-bool v2) okolje))) (if(or (true? v1) (true? v2)) (true) (false))]
                                      [else (false)]))]

                    [(!? e) (cond [(true? (mi2(is-bool (mi (!-e1 e) okolje))okolje )) (if(true? (mi2(!-e1 e) okolje)) (false) (true))]
                                  [else (false)])]

                    [(hd? e) (let ([x (mi2 (hd-x e) okolje)])
                               (::-e1 x))]

                    [(tl? e) (let ([x (mi2 (tl-x e) okolje)])
                               (::-e2 x))]

                    [(is-empty? e) (if(empty? (mi2(is-empty-x e)okolje)) (true) (false))]

                    [(@? e) (let([v1 (mi2 (@-a e) okolje)]
                                 [v2 (mi2 (@-b e) okolje)])

                              (define (preglej sez)
                                (if(::? sez) (append (list(mi2(hd sez)okolje)) (preglej (mi2 (tl sez) okolje))) (list(mi2 sez okolje))))

                              (define (kreiraj list1 v2)
                                (if(not(null? list1))  (mi2(:: (car list1) (kreiraj (cdr list1) v2)) okolje) v2))

                              (kreiraj (preglej v1) v2))]

                    [(real? e) (let([v1 (mi2 (real-e1 e) okolje)])
                                 (complex-a v1))]

                    [(imaginary? e) (let([v1 (mi2 (imaginary-e1 e) okolje)])
                                      (complex-b v1))]

                    [(var? e) (let ([s (var-s e)]
                                    [e1 (mi2 (var-e1 e) okolje)]
                                    [e2 (var-e2 e)])
                                (mi2 e2 (append (list(cons s e1)) okolje)))]

                    [(valof? e) (let ([s (valof-s e)])
                                   (cdr(assoc s okolje)))]

                    [(fun? e) (envelope okolje e)]

                    [(proc? e) e]

                    [(call? e) (let([o (mi2 (call-e e) okolje) ])
                                 (cond [(envelope? o) (mi2 (fun-body (envelope-f o)) (let ([fargs (fun-fargs(call-e e))]
                                                                                           [args (map (lambda(x) (mi2 x okolje)) (call-args e))])
                                                                                       (map cons fargs args)))]
                                       [(proc? o) (mi2 (proc-body o) okolje)]
                                       [else (error "klic funkcije nima ustreznih argumentov")]))]
                    ))])
    (mi2 e okolje)))

#| V jeziku Racket lahko implementiramo funkcije, ki delujejo kot makri v jeziku mega,
ter na ta način olepšajo sintakso ter razširijo jezik z novimi konstrukti.
Makri naj podane izraze evalvirajo le enkrat! Definiramo naslednje makre: |#

;(to-complex e1) iz rezultat izraza e1, ki je številska konstanta naredi kompleksno število
(define-syntax to-complex
  (syntax-rules()
    [(to-complex e1)
    (complex (mi e1) (int 0))]))

;(conj e1) predstavlja konjugirano kompleksno število, ki je rezultat izraza e1
(define-syntax conj
  (syntax-rules()
    [(conj e1)
    (let ([a (mi (complex-a e1))]
          [b (mi(complex-b e1))])
      (complex a (int (-(int-n b))))
      )]))

;(~ e1) predstavlja unarni minus. Definiran je za številske konstante.
(define-syntax ~
  (syntax-rules()
    [(~ e1)
    (int (-(int-n (mi e1))))]))

;(lt e1 e2), ki preveri, ali velja urejenost med parametroma. Definiran je za vse vrednosti, na katerih deluje gt.
(define-syntax lt
  (syntax-rules()
    [(lt e1 e2)
    (cond [(true) (gt e2 e1)]
          [else "napacna cifra"])]))

;(same e1 e2), ki preveri, ali sta vrednosti enaki. Definiran je za vse vrednosti, na katerih deluje gt.
(define-syntax same
  (syntax-rules()
    [(same e1 e2)
    (cond [(true) (if(= (int-n (mi e1)) (int-n (mi e2))) (true) (false))]
          [else "napacna cifra"])]))

;(envelope (list (cons "f" (int 3))) (fun "sestej" '("f" "a") (add (int 3) (int 5))))
;(mi (var "f" (int 3) (fun "sestej" (list "f" "a") (add (int 3) (int 5)))))

;(mi (var "f" (int 11) (var "a" (int 1) (call (proc "sestej" (call (proc "sestej" (add (int 3) (int 8))) null) ) null ))))

;(mi (call (fun "sestej" (list "a" "b") (add (int 3) (int 5))) (list (int 3) (int 7))))

;(map cons (list 3 3 3) (list 4 4 4))

;(mi (var "i" (int 777) (call (fun "sestej" (list "i" "f") (add (valof "i") (valof "f"))) (list (int 7) (int 1)) ) ))