;; The first three lines of this file were inserted by DrRacket. They record metadata
;; about the language level of this file in a form that our tools can easily process.
#reader(lib "htdp-beginner-abbr-reader.ss" "lang")((modname week4_w_full) (read-case-sensitive #t) (teachpacks ((lib "image.ss" "teachpack" "2htdp"))) (htdp-settings #(#t constructor repeating-decimal #f #t none #f ((lib "image.ss" "teachpack" "2htdp")))))
; a person is
;   - (make-person number symbol)
(define-struct person (ssn name))

;; example people:
(define Adam (make-person 1 'adam))
(define George (make-person 2 'george))
(define Jon (make-person 3 'jon))
(define Steve (make-person 4 'steve))

; Simple version:
; a database is
;   - empty
;   - (make-db-node person 
;                   database
;                   database)

; Better version:
; a database is
;   - empty
;   - (make-db-node person 
;                   database[left]
;                   database[right])
;   INVARIANT:
;   where everyone in left has a smaller ssn than person
;     and everyone in right has a larger ssn than person
(define-struct db-node (person left right))

(define mydb (make-db-node George 
                           (make-db-node Adam empty empty)
                           (make-db-node Steve 
                                         (make-db-node Jon empty empty)
                                         empty)))

; template:
;  (cond [(empty? db) ...]
;       [(db-node? db)
;                  ... (db-node-person db) ... 
;                  ... (fun-for-db (db-node-left db)) ...
;                  ... (fun-for-db (db-node-right db)) ... ])

; lookup2 : number database -> person or false
; returns person if ssn in database, false otherwise
(define (lookup2 n db)
  (cond [(empty? db) false]
       [(db-node? db)
        (cond [(person-matches? (db-node-person db) n) 
               (db-node-person db)]
              [(smaller? n (db-node-person db)) 
               (lookup2 n (db-node-left db))]
              [else (lookup2 n (db-node-right db))]
)]))

(check-expect (lookup2 1 mydb) Adam)
(check-expect (lookup2 6 mydb) false)
               
; helper functions:
; person-matches? : person number -> boolean
; returns whether person matches ssn
(define (person-matches? per n)
  (= n (person-ssn per)))

(check-expect (person-matches? Adam 1) true)
(check-expect (person-matches? Adam 2) false)

; smaller? : number person -> boolean
; returns whether number is smaller than person's ssn
(define (smaller? n per) 
  (< n (person-ssn per)))

(check-expect (smaller? 1 Adam) false)
(check-expect (smaller? 2 Steve) true)


(check-expect (lookup2 1 mydb) Adam)
(check-expect (lookup2 2 mydb) George)
(check-expect (lookup2 3 mydb) Jon)
(check-expect (lookup2 4 mydb) Steve)
(check-expect (lookup2 6 mydb) false)
(check-expect (lookup2 2 empty) false)


; A sorted-list is either:
; - empty
; - (cons number[n] sorted-list[l])
; INVARIANT: each number in 'l' is larger than 'n'

; insert : number sorted-list -> sorted-list
; inserts number into correct position in sorted list
(define (insert n slon) 
  (cond [(empty? slon) (list n)]
        [else (cond [(< n (first slon)) (cons n slon)]
                    [else (cons (first slon) (insert n (rest slon)))]
                    )]
  ))

(check-expect (insert 4 (list 1 2 93)) (list 1 2 4 93))
(check-expect (insert 4 empty) (list 4))