;; Final version

(load "search-for-primes-common.ss")
(load "search-for-primes-lazy.ss")

;;;
;; timed-result interface

(define (make-timed-result fun-args fun-result elapsed-time)
  (cons fun-args (cons fun-result elapsed-time)))

(define (get-fun-args timed-result)
  (car timed-result))

(define (get-fun-result timed-result)
  (cadr timed-result))

(define (get-elapsed-time timed-result)
  (cddr timed-result))

(define (timed-function-test fun args)
  (let ((start-time (runtime))
        (result (apply fun args))
        (end-time (runtime)))
    (make-timed-result args result (- end-time start-time))))

;;;
;; results display code

(define (cut-precision inexact digits)
  (define factor (expt 10 digits))
  (/ (round (* inexact factor)) factor))

(define (replace-all dictionary string)
  (if (null? dictionary)
      string
      (letrec ((rule (car dictionary))
               (from (car rule))
               (to (cdr rule)))
        (replace-all (cdr dictionary)
                     (regexp-replace* from string to)))))

(define (report-timed-result output-string timed-result)
  (let ((fun-args (format "~a" (get-fun-args timed-result)))
        (fun-result (format "~a" (get-fun-result timed-result)))
        (elapsed-time (number->string
                       (cut-precision (get-elapsed-time timed-result)
                                      4))))
    (begin
      (display (replace-all (list (cons "%a" fun-args)
                              (cons "%r" fun-result)
                              (cons "%t" elapsed-time))
                            output-string))
      (newline))))

(define (display-timed-results output-string timed-results)
  (if (not (null? timed-results))
      (let ((first-result (car timed-results)))
        (begin
          (report-timed-result output-string first-result)
          (display-timed-results output-string (cdr timed-results))))))

;;;
;; generate-statistics
;;     function: function to generate statistics for.
;;     feed: generator of arguments to function (use lazy interface).
;;     decide-fun: function returning #f if a given function result should be discarded.
;;     how-many: how many results you want to see.
;;     output-string: output string describing prefered output,
;;                    three format strings can be used:
;;                    %a -> arguments, %r -> results, %t -> time elapsed
(define-opt (generate-statistics function feed decide-fun how-many [output-string "%a->%r: %t"])
  (display-timed-results output-string (lazy->list (lazy-filter decide-fun
                                                                (lazy-map (lambda args (timed-function-test function args)) feed)
                                                                how-many))))

;;;

(define (search-for-primes how-many start)
  (define odd-numbers
    (lazy-filter odd? (infinity-starting-at start)))
  (define (decide timed-result)
    (get-fun-result timed-result))
  (generate-statistics prime? odd-numbers decide how-many "%a: %t"))