#lang racket
(require "opcodes.rkt")
(provide make-stack-machine)
(provide run-stack-machine)
(provide get-stack)
(provide get-varnames)
(provide get-consts)
(provide get-names)
(provide get-code)
(provide get-IC)
(provide empty-stack)
(provide make-stack)
(provide push)
(provide pop)
(provide top)


;; TODO 1:
;; Alegeți metoda de reprezentarea a unei stive.
;; Implementați:
(define empty-stack '())
(define (make-stack) empty-stack)

(define (push element stack) (cons element stack))
(define (top stack) (car stack))
(define (pop stack) (cdr stack))

;; TODO 2:
;; Alegeți metoda de reprezentare a unei mașini stivă.
;; Definiți make-stack-machine, acesta trebuie sa primeasca cele 4 segmente de date
;; Veți avea nevoie de o stivă pentru execuție și un counter ca să stiți
;; la ce instrucțiune sunteți.
(define (make-stack-machine stack co-varnames co-consts co-names co-code IC)
  (list stack co-varnames co-consts co-names co-code IC))

;; Definiți funcțiile `get-varnames`, `get-consts`, `get-names`,
;; `get-code`, `get-stack`, `get-IC` care primesc o mașina stivă și întorc
;; componenta respectivă

;; ex:
;; > (get-varnames (make-stack-machine empty-stack 'dummy-co-varnames (hash) (hash) (list) 0))
;; 'dummy-co-varnames
(define (get-varnames stack-machine) (list-ref stack-machine 1))

;; ex:
;; > (get-consts (make-stack-machine empty-stack (hash) 'dummy-co-consts (hash) (list) 0))
;; 'dummy-co-consts
(define (get-consts stack-machine) (list-ref stack-machine 2))

;; ex:
;; > (get-names (make-stack-machine empty-stack (hash) (hash) 'dummy-co-names (list) 0))
;; 'dummy-co-names
(define (get-names stack-machine) (list-ref stack-machine 3))

;; ex:
;; > (get-code (make-stack-machine empty-stack (hash) (hash) (hash) 'dummy-co-code 0))
;; dummy-co-code
(define (get-code stack-machine) (list-ref stack-machine 4))

;; Întoarce stiva de execuție.
;; ex:
;; > (get-code (make-stack-machine 'dummy-exec-stack (hash) (hash) (hash) (list) 0))
;; dummy-exec-stack
(define (get-stack stack-machine) (list-ref stack-machine 0))

;; Întoarce instruction counterul.
;; ex:
;; > (get-code (make-stack-machine empty-stack (hash) (hash) (hash) (list) 0))
;; 0
(define (get-IC stack-machine) (list-ref stack-machine 5))



(define symbols (list 'STACK 'CO-VARNAMES 'CO-CONSTS 'CO-NAMES 'CO-CODE 'INSTRUCTION-COUNTER))

;; TODO 3:
;; Definiți funcția get-symbol-index care gasește index-ul simbolului in listă.
(define (get-symbol-index symbol)
  (let iter ((list symbols)
             (index 0))
    (cond ([empty? symbols] #f)
          ([equal? (car list) symbol] index)
          (else (iter (cdr list) (+ index 1))))))

;; Definiți funcția update-stack-machine care intoarce o noua mașina stivă
;; înlocuind componenta corespondentă simbolului cu item-ul dat în paremetri.
;; > (get-varnames (update-stack-machine "new-varnames" 'CO-VARNAMES stack-machine))
;; "new-varnames"
;; > (get-varnames (update-stack-machine "new-names" 'CO-NAMES stack-machine))
;; "new-names"
(define (update-stack-machine item symbol stack-machine)
  (let ((index (get-symbol-index symbol)))
    (append (append (take stack-machine index) (list item)) (drop stack-machine (+ index 1)))))

;; Definiți funcția push-exec-stack care primește o masină stivă și o valoare
;; și intoarce o noua mașina unde valoarea este pusă pe stiva de execuție
;;(define (push-exec-stack value stack-machine)
  ;;(push value (car stack-machine)))

;;  Definiți funcția pop-exec-stack care primește o masină stivă
;;  și intoarce o noua mașina aplicând pop pe stiva de execuție.
;;(define (pop-exec-stack stack-machine)
  ;;(pop (car stack-machine)))

;; TODO 4:
;; Definiți funcția run-stack-machine care execută operații pană epuizează co-code.
(define (run-stack-machine stack-machine)
  (cond ([(equal? (list-ref (get-code stack-machine) (get-IC stack-machine)) (get-opname 100))]
         (run-stack-machine (load-const (cdr (car (get-code stack-machine))) stack-machine)))
        ([(equal? (list-ref (get-code stack-machine) (get-IC stack-machine)) (get-opname 124))]
         (run-stack-machine (load-fast (cdr (car (get-code stack-machine))) stack-machine)))
        ([(equal? (list-ref (get-code stack-machine) (get-IC stack-machine)) (get-opname 125))]
         (run-stack-machine (store-fast (cdr (car (get-code stack-machine))) stack-machine)))
        (else stack-machine)))

(define (load-const position stack-machine)
  (update-stack-machine (+ get-IC stack-machine 1) (get-IC stack-machine)
                        (update-stack-machine (push (hash-ref (get-consts stack-machine) position) (get-stack stack-machine)) stack-machine)))

(define (load-fast position stack-machine)
  (update-stack-machine (+ get-IC stack-machine 1) (get-IC stack-machine)
                        (update-stack-machine (push (hash-ref (get-varnames stack-machine) position) (get-stack stack-machine)) stack-machine)))

(define (store-fast position stack-machine)
  (let ((TOS (top (get-stack stack-machine))))
    (update-stack-machine (+ get-IC stack-machine 1) (get-IC stack-machine)
                          (update-stack-machine (hash-set (get-varnames stack-machine) position TOS) (pop stack-machine)))))