;;; useful functions for LISP natural language parsing program

;;; Set up the parse-obj and word-dict
(setf parse-obj (MAKE-HASH-TABLE))
(setf word-dict (MAKE-HASH-TABLE))
(setf table-ht  (MAKE-HASH-TABLE))


;;; processRequest
;;;    Parameters:
;;;       request - a list of words making a request
;;;    Purpose:
;;;       - Sets up necessary information (see below) and invokes the student's checkRequest
;;;         function.
;;;       - Since the student's checkRequest sets the parts of speech, processRequest prints
;;;         those parts of speech.
;;;       - Returns T if the request is a valid request.  Otherwise, NIL is returned.
;;;    Notes:
;;;       - Sets the parse-obj hash table to contain the request
;;;       - Sets the cursor position to zero.
;;;       - Uses resetPartsOfSpeech to reset the values of each part of speech.
;;;       - Prints the request
;;;       - Invokes checkRequest to check for valid syntax and prints
;;;         the result.
;;;       - Prints the value for each part of speech
;;;       - Invokes makeDBRequest to generate a database request from the parts of speech
;;;    Notes:
;;;       - Requests will not contain punctuation since
;;;             -- commas have a meaning in Common LISP associated with backquote
;;;             -- periods are used for dotted pairs
;;;
(defun processRequest(request)
    (PROG (result)
        ;;; Save the request in parse-obj.
        (putp 'request parse-obj request) ;; KEY=request; VAL=whatever the request was

        ;;; Set the cursor position to 0.
        (putp 'cursor parse-obj 0)

        ;;; reset the parts of speech to NIL
        (resetPartsOfSpeech parse-obj 'verb 'directObj 'prep 'indirectObj 'QualIndirectPrep 'QualIndirectObj) ;; CODE THIS - RESET THESE WORDS TO NIL in parse-obj HT
        (resetPartsOfSpeech parse-obj 'Comparator 'NotQual 'QualPrep 'QualValue) ;; CODE THIS - RESET THESE WORDS TO NILL in parse-obj HT

        (format T "~% ******************************************************************")
        (format T "~%  ~a" request) ;; our request. EX: COUNT THE NUMBER OF RENTALS
        (setf result (checkRequest parse-Obj)) ;; CODE THIS - sets result equal to whatever checkRequest returned
        (format T "~%    checkRequest returned ~a" result) ;; T if request was valid; NIL if it was not
        (format T "~%    verb= ~a" (getp 'verb parse-obj)) ;; returns the property value for 'verb from parse-obj ht
        (format T "~%    directObj= ~a" (getp 'directObj parse-obj)) ;; returns the property value for 'directObj from parse-obj ht
        (format T "~%    prep= ~a" (getp 'prep parse-obj)) ;; returns the property value for 'prep from parse-obj ht
        (format T "~%    indirectObj= ~a" (getp 'indirectObj parse-obj)) ;; returns the property value for 'indirectObj from parse-obj ht

        ;;; if we have a qual indirect, show it (SECOND FORM)
        (cond ((or  (getp 'QualIndirectPrep parse-obj) ;; QualIndirectPrep EX: WITH
                    (getp 'QualIndirectObj parse-obj)) ;; QualIndirectObj EX: RATING, DATE
                (format T "~%    QualIndirectPrep= ~a" (getp 'QualIndirectPrep parse-obj)) ;; get val associated with symbol QualIndirectPrep from parse-obj ht
                (format T "~%    QualIndirectObj= ~a" (getp 'QualIndirectObj parse-obj))   ;; get val associated with symbol QualIndirectObj from parse-obj ht
        ))
        ;;; if we have qual, show it
        (cond ((or  (getp 'Comparator parse-obj) ;; return value associated with key 'Comparator from parse-obj ht
                    (getp 'NotQual parse-obj)    ;; return value associated with key 'NotQual from parse-obj ht
                    (getp 'QualPrep parse-obj)   ;; return value associated with key 'QualPrep from parse-obj ht
                    (getp 'QualValue parse-obj)) ;; return value associated with key 'QualValue from parse-obj ht

                (if (getp 'NotQual parse-obj) ;; if NotQual does not return NIL, display it
                     (format T "~%    NotQual = ~a" (getp 'NotQual parse-obj)))

                (format T "~%    Comparator= ~a" (getp 'Comparator parse-obj)) ;; return val assoc with key 'Comparator from parse-obj ht
                (format T "~%    QualPrep= ~a" (getp 'QualPrep parse-obj))     ;; return val assoc with key 'QualPrep from parse-obj ht
                (format T "~%    QualValue= ~a" (getp 'QualValue parse-obj))   ;; return val assoc with key 'QualValue from parse-obj ht
        ))
        (if (not result) (return result)) ;; If request is not NIL; return it

        ;;; see if doing extra credit, return if not
        (if (NOT doingExtra)
            (return result))

        ;;; generate the SQL and show that SQL query
        (setf query (genSQL parse-Obj))
        (format T "~%    DBRequest= ~a" query)

        (return result) ) )

;;; putp
;;;    Parameters:
;;;       symbol   - symbol to be given the property value
;;;       ht       - hash table to store the symbol and its property value
;;;       value    - the property value
;;;    Purpose:
;;;       stores the property value for the symbol in the specified hash table
;;;    Notes:
;;;       If the symbol isn't an ATOM, putp breaks execution with an ERROR.
;;;    Example Usage:
;;;       (putp 'prep parse preposition)
;;;       (putp word word-dict partOfSpeech)
;;;          KEY       VALUE
(defun putp (symbol ht value)
    (if (ATOM symbol)
        (setf (gethash symbol ht) value)
        (ERROR "~s is not a valid symbol for putp" symbol)
    )
)

;;; getp
;;;    Parameters:
;;;       symbol   - symbol about which we want its property value
;;;       ht       - hash table which stores the symbol and its property value
;;;    Purpose:
;;;       Returns the property value for the symbol in the specified hash table
;;;       If not found, it returns NIL.
;;;    Example Usage:
;;;       (getp word word-dict)  would return the partOfSpeech for that word
;;;       (getp 'request parse-obj)  would return the original request from the parse-obj.
(defun getp (symbol ht)
     (gethash symbol ht) )


;;; getCursor
;;;    Parameters:
;;;       parse - the parse object containing a request, cursor position, and
;;;               value for each part of speech
;;;    Purpose:
;;;       returns the current cursor position (relative to zero)
(defun getCursor (parse)
    (getp 'cursor parse) ) ;; should be a number

;;; setCursor
;;;    Parameters:
;;;       parse - the parse object containing a request, cursor position, and
;;;               value for each part of speech
;;;       cursorPosition - new cursor position
;;;    Purpose:
;;;       Sets the value of the cursor position (relative to zero) in the
;;;       parse object
;;;    Notes:
;;;       If the cursorPosition isn't a numeric, setCursor breaks execution
;;;       with an ERROR.
(defun setCursor (parse cursorPosition)
    (if (numberp cursorPosition)
        (putp 'cursor parse cursorPosition)
        (ERROR "~s is not a numeric argument for setCursor" cursorPosition)
    )
)

;;; getToken
;;;    Parameters:
;;;       parse - the parse object containing a request, cursor position, and
;;;               value for each part of speech
;;;    Purpose:
;;;       returns the next token from the request.  If there are no more
;;;       tokens, it returns NIL.
;;;    Notes:
;;;       This modifies the cursor position after getting the current token
;;;       at the old position.
(defun getToken (parse)
    (prog (temp)
        (setf temp (nth (getp 'cursor parse) (getp 'request parse)))
        (setCursor parse (1+ (getp 'cursor parse)))
        (return temp) ) )


;;; checkRequest
;;; This function checks for a valid request according to the grammar above.
;;; Assume it is passed a parse-obj (which has already been populated with
;;; a request) and returns T if the request is valid; otherwise it returns NIL.
;;; Name the parameter parse to avoid conflicts. Additionally, checkRequest
;;; saves the identified parts of speech. checkRequest is invoked by Larry's
;;; processRequest(see the sample output).
(defun checkRequest (parse)
    (PROG (result)
        ;;VERB
        ;(setf saveCursor (getCursor parse))
        (setf gram (getToken parse))
        (do ()
            ((NULL gram))
            (print gram)

            (if (isa gram 'verb) (putp 'verb parse gram))

            (if (NOT(isa gram 'article)) (setCursor parse saveCursor) (putp 'article parse gram))

            (if (AND (isa gram 'noun) (EQL count 2))
                (prog ()
                    (putp 'indirectObj parse gram)
                    (setf count (+ 1 count)) ) )

            (if (AND (isa gram 'noun) (EQL count 1))
                (prog ()
                    (putp 'directObj parse gram)
                    (setf count (+ 1 count)) ) )

            (if (isa gram 'prep) (putp 'prep parse gram))

            (setf saveCursor (getCursor parse))
            (setf gram (getToken parse))
        )

    )

)



;;; ***************************** DONE ***************************************
;;; resetPartsOfSpeech
;;; This function resets the value for each of the specified parts of speech
;;; to NIL using putp. The first argument is a parse-obj. There are a variable
;;; number of parts of speech passed to resetPartsOfSpeech.
(defun resetPartsOfSpeech (parse &rest speech)
    (dolist (part speech) (putp part parse NIL))
)

;;; ***************************** DONE ***************************************
;;; partOfSpeech
;;; This macro defines each word in the list of words to be specified
;;; partOfSpeech in the dictionary (hard coded word-dict). Use (putp word
;;; word-dict partOfSpeech) to put each word in word-dict with the partOfSpeech.
;;; KEYS=a an the; VALUE=ARTICLE
(defmacro set_isa (word &rest partOfSpeech)
    (dolist (part partOfSpeech) (putp part word-dict word))
)

;;; ***************************** DONE ***************************************
;;; isa
;;; returns T if the specified word is that specified partOfSpeech; otherwise,
;;; NIL is returned.
(defun isa (word partOfSpeech)
    (COND ((EQL (getp word word-dict) partOfSpeech)) )
)


;(print (isa 'the (getp 'the word-dict) ))
;(print (getp 'elect word-dict))
;(setf x  '123)
;(print (NULL x))
;(print (NULL(isa 'select (getp 'select word-dict))))
;(print parse-obj)



 ;;; defaulting doingExtra to NIL
 (setf doingExtra NIL)

(set_isa article a n the)
(set_isa noun movies movie rental rentals customer customers)
(set_isa noun ID title genre rating custNr name state date number gender)
(set_isa verb count select show print)
(set_isa prep of with to in for)
(set_isa comparator  equal after before)
(set_isa adjective horror scifi romance comedy action male female g pg13 r x)
(processRequest '(count the number of rentals))
;(processRequest '(show id for movies with rating equal to sex))