#lang typed/racket

(require "../include/cs151-core.rkt")
(require typed/test-engine/racket-tests)


(: exclaim (-> String String))
;; add an exclamation point to the end of the given string
(define (exclaim str)
  (string-append str "!"))
   

(check-expect (exclaim "hi") "hi!")

(: longer-name? (-> String String String String Boolean))
;; given a last name and first name, then another last name and first name,
;; test if the first full name is strictly longer than the second
(define (longer-name? first1 last1 first2 last2)
  
  (define fullname1 (+ (string-length first1) (string-length last1)))
  (define fullname2 (+ (string-length first2) (string-length last2)))
  
  (cond
    [(<  fullname1 fullname2) #t]

     [else #f]))

(check-expect (longer-name? "hi" "hi!"  "hii" "hii") #t)

(: longer-string (-> String String String))
;; return the longer string
;; if the strings are of equal length, return either one
(define (longer-string str1 str2)
  (cond
    [(> (string-length str1) (string-length str1)) str1]
    [(= (string-length str1) (string-length str2)) str1]
  [else str2]))

(check-expect (longer-string "cat" "cat") "cat")

(: median (-> Integer Integer Integer Integer))
;; return the median integer
  (define (median Int1 Int2 Int3)
    (round (/ (+ Int1 Int2 Int3) 3)))

(check-expect (median 3 3 7) 4)

(: leap? (-> Integer Boolean))
;; is it a leap year? (note: a leap year is not simply every fourth year)
 (define (leap? Y1)
   (cond
     [(and (= (modulo Y1 100) 0)
           (not(= (modulo Y1 400) 0))) #f]
     [(= (modulo Y1 4) 0) #t]
     [else #f]))

(check-expect (leap? 2300) #f)

(: days-in-month (-> Integer Integer Integer))
;; how many days are there in the given month, year?
;; ex: (days-in-month 2 2020) -> 29
;; ex: (days-in-month 10 2021) -> 31
  (define (days-in-month M1 Y2)
    (cond
      [(or (= M1 1)
                (= M1 3)
                (= M1 5)
                (= M1 7)
                (= M1 8)
                (= M1 10)
                (= M1 12)) 31]
      [(or (= M1 4)
                (= M1 6)
                (= M1 9)
                (= M1 11)) 30]
      [(and (not(leap? Y2))
            (= M1 2)
                ) 28]
     [else 29]))

(check-expect (days-in-month 2 2000) 29)


(: time24 (-> Integer Integer String String))
;; consume an hour, minute, and am/pm, and return
;; a 24-hour time string like "13:00"
;; - the given String must be either "am" or "pm"
;; - the resulting string should have length exactly five
;; - for example, (time24 4 5 'pm) returns "16:05"
;; you *do not* need to anticipate bad input; just let the function fail for bad input (GIGO)
  (define (time24 HR MN AP)
    (cond
      [(and (string=? AP "AM")
            (< HR 10)
            (< MN 10))
            (string-append "0" (number->string HR) ":0" (number->string MN))]
      [(and (string=? AP "AM")
            (< HR 10)
            (>= MN 10))
            (string-append "0" (number->string HR) ":" (number->string MN))]
       [(and (string=? AP "AM")
            (>= HR 10)
            (< HR 12)
            (<= 10 MN 59))
            (string-append (number->string HR) ":" (number->string MN))]
       [(and (string=? AP "AM")
            (= HR 12)
            (<= 10 MN 59))
            (string-append (number->string (+ HR 12)) ":" (number->string MN))]
       [(and (string=? AP "PM")
            (= HR 12)
            (<= 10 MN 59))
            (string-append (number->string HR) ":" (number->string MN))]
       [(and (string=? AP "PM")
            (< HR 10)
            (< MN 10))
            (string-append (number->string (+ HR 12)) ":0" (number->string MN))]
      [else (string-append (number->string (+ HR 12)) ":" (number->string MN))]))
      
(check-expect (time24 8 00 "PM" ) "20:00")