(local { : view } (require :fennel))
(local { : merge : any } (require :lume))

(fn wrap-longitude [x]
  (if (<= x -180) (wrap-longitude (+ x 360))
      (< 180 x)   (wrap-longitude (- x 360))
      x))

(fn at-obstacle? [{: x : y : obstacles}]
  (any obstacles
       (fn [[ox oy]] (and (= ox x) (= oy y)))))

(fn lateral? [direction]
  (. {:w true :e true} direction))

(fn try-to-drive [{: x : y : direction} distance]
  (let [distance
        (if (lateral? direction)
            (/  distance (math.cos (/ (* math.pi y) 180)))
            distance)]
    (match direction
      :n {:y (+ y distance)}
      :s {:y (- y distance)}
      :w {:x (wrap-longitude (- x distance))}
      :e {:x (wrap-longitude (+ x distance))})))

(fn drive [r distance]
  (if r.stopped
      r
      (let [next-move (merge r (try-to-drive r distance))]
        (if (at-obstacle? next-move)
            (merge r {:stopped [next-move.x next-move.y]})
            next-move))))

(fn turn-left [{: x : y : direction}]
  (if (= y 90)
      {:x (wrap-longitude (- x 90))}
      {:direction
       (-> {
            :n :w
            :w :s
            :s :e
            :e :n
            }
           (. direction))}))

(fn turn-right [{: x : y : direction}]
  (if (= y 90)
      {:x (wrap-longitude (+ x 90))}
      {:direction
       (-> {
            :n :e
            :e :s
            :s :w
            :w :n
            }
           (. direction))}))

(fn command [rover string]
  (merge rover
         (match string
           :f (drive rover 1)
           :b (drive rover -1)
           :r (turn-right rover)
           :l (turn-left rover)
           _ (assert false (. "unrecognised command " string)))))

(fn fudge-for-pole [{: y &as r}]
  (if (= y 90)
      (merge r {:direction :s})
      (= y -90)
      (merge r {:direction :n})
      r))

(fn execute [rover cmds]
  (accumulate [rover rover
               _ c (ipairs cmds)]
    (merge rover (fudge-for-pole (command rover c)))))

(fn rover [x y direction ?obstacles]
  {: x
   : y
   : direction
   :obstacles (or ?obstacles [])
   })

;;;; TESTS

;; who needs a test framework when you have lisp macros?
(macro expect [text actual expected]
  `(let [actual# ,actual]
     (or (match actual#
           ,expected true)
         (assert false (view {
                              :text ,text
                              :expected ,(view expected)
                              :actual actual#
                              })))))

(let [r (rover 7 15 :n)]
  (expect
   "rover knows (x,y) and the direction (N,S,E,W) it is facing"
   r
   {:x 7 :y 15 :direction :n}))

(let [r (rover 0 0 :n)]
  (expect "The rover receives a character array of commands"
          (execute r [:f :f :f])
          {}))

(let [r (rover 0 0 :n)]
  (expect "Moves north when pointing north and asked to move forward"
          (execute r [:f]) {:x 0 :y 1 :direction :n}))

(let [r (rover 3 2 :s)]
  (expect "Moves south when pointing south and asked to move forward"
          (execute r [:f]) {:x 3 :y 1 :direction :s}))

(let [r (rover 0 0 :w)]
  (expect "Moves west when pointing west and asked to move forward"
          (execute r [:f]) {:x -1 :y 0 :direction :w}))

(let [r (rover 0 0 :e)]
  (expect "Moves east when pointing east and asked to move forward"
          (execute r [:f]) {:x 1 :y 0 :direction :e}))

(let [r (rover 1 1 :s)]
  (expect "The rover acts on multiple commands"
          (execute r [:f :f :f])
          {:x 1 :y -2 :direction :s}))

(let [r (rover 3 2 :s)]
  (expect "Moves north when pointing south and asked to move backward"
          (execute r [:b]) {:x 3 :y 3 :direction :s}))

(let [r (rover 3 0 :e)]
  (expect "Moves west when pointing east and asked to move backward"
          (execute r [:b]) {:x 2 :y 0 :direction :e}))

(let [r (rover 2 4 :e)]
  (expect "Rotates to south when pointing east and asked to turn right"
          (execute r [:r]) {:x 2 :y 4 :direction :s}))

(let [r (rover 2 4 :s)]
  (expect "Rotates to east when pointing south and asked to turn left"
          (execute r [:l]) {:x 2 :y 4 :direction :e}))

(let [r (rover 2 4 :w)]
  (expect "Rotates to north when pointing west and asked to turn right"
          (execute r [:r]) {:x 2 :y 4 :direction :n}))

(let [r (rover 1 1 :s)]
  (expect "Multiple commands are executed in the right order"
          (execute r [:l :l :f :f :f :r :f :b])
          {:x 1 :y 4 :direction :e}))

;; Circumference of mars is  3,376.2km (about half that of earth).
;; We choose the unit of distance to be equal to one  degree at the equator
;; (about 60km), so if we travel the same linear distance at a higher
;; latitude, we will move be a larger number of degrees

(expect "At 60 degrees latitude, one unit of drive is two degrees"
        (execute (rover 0 60 :e) [:f])
        (where {:x x :y 60 :direction :e}
               (< (math.abs (- x 2)) 0.000001)
               ))

(expect "At 45 degrees latitude, one unit of drive is (sqrt 2) degrees"
        (execute (rover 0 45 :e) [:f])
        (where {:x x } (< (math.abs (- x 1.4141)) 0.001)))

(expect "At 45 degrees latitude south, one unit of drive is (sqrt 2) degrees"
        (execute (rover 0 -45 :e) [:f])
        (where {:x x :y -45} (< (math.abs (- x 1.4141)) 0.001)))

;; valid longitudes are -180 .. 180

(expect "Longitude wraps from positive to  negative when travelling west"
        (execute (rover -179 0 :w) [:f :f :f])
        {:x 178 :y 0 :direction :w})

(expect "Longitude wraps from negative to positive when travelling east"
        (execute (rover 179 0 :e) [:f :f :f])
        {:x -178 :y 0 :direction :e})

(expect "At the North Pole we always point south"
        (execute (rover 0 89 :n) [:f])
        {:x 0 :y 90 :direction :s})

(expect "At the North Pole, turning left affects x not direction"
        (execute (rover 0 89 :n) [:f :l])
        {:x -90 :y 90 :direction :s})

(expect "At the North Pole, turning right affects x not direction"
        (execute (rover 0 89 :n) [:f :r])
        {:x 90 :y 90 :direction :s})

(expect "It does not move past obstacles"
        (let [obstacles [[5 5] [7 5]]]
          (execute (rover 5 3 :n obstacles) [:f :f :f :f :f :f]))
        {:x 5 :y 4 :direction :n :stopped [5 5]})


;; "TODO: deal with the south pole special casing"

(print "OK")