(import :std/srfi/1)
(import :std/srfi/43)
(import :std/iter)
(import :gerbil/gambit/hvectors)

(export main)

(def (hundreds-digit n)
  (remainder (quotient n 100) 10))

(def (power serial-number x y)
  (def rack-id (+ x 10))
  (- (hundreds-digit (* rack-id (+ (* rack-id y) serial-number))) 5))

(def (build-grid serial-number grid-size)
  (def grid (make-vector grid-size #f))
  (for ((i (in-range grid-size)))
    (vector-set! grid i (make-s32vector grid-size 0)))
  (for* ((i (in-range grid-size))
	 (j (in-range grid-size)))
    (s32vector-set! (vector-ref grid i)
		    j
		    (power serial-number i j)))
  (for* ((i (in-range grid-size))
	 (j (in-range grid-size)))
    (if (> i 0)
      (let ((cur-row (vector-ref grid i))
	    (prev-row (vector-ref grid (- i 1))))
	(s32vector-set! cur-row j
			(+ (s32vector-ref cur-row j)
			   (if (> j 0) (s32vector-ref cur-row (- j 1)) 0)
			   (s32vector-ref prev-row j)
			   (if (> j 0) (- (s32vector-ref prev-row (- j 1))) 0))))
      (let ((cur-row (vector-ref grid i)))
	(s32vector-set! cur-row j
			(+ (s32vector-ref cur-row j)
			   (if (> j 0) (s32vector-ref cur-row (- j 1)) 0))))))
  grid)

(def (largest-power-cell grid cell-size)
  (def grid-size (vector-length grid))
  (def max -10000)
  (def max-idx [0 0])
  (for* ((i (in-range (- grid-size cell-size)))
	 (j (in-range (- grid-size cell-size))))
    (let* ((top-row (vector-ref grid i))
	   (bottom-row (vector-ref grid (+ i cell-size)))
	   (sum (- (+ (s32vector-ref bottom-row (+ j cell-size))
		      (s32vector-ref top-row j))
		   (+ (s32vector-ref bottom-row j)
		      (s32vector-ref top-row (+ j cell-size))))))
      (when (> sum max)
	(begin
	  (set! max sum)
	  (set! max-idx [(1+ i) (1+ j)])))))
  (cons max max-idx))

(def (largest-power-cell-size grid)
  (def grid-size (vector-length grid))
  (def max-size 0)
  (def max -1000)
  (def res #f)
  (for ((size (in-range grid-size)))
    (let ((x (largest-power-cell grid size)))
      (when (> (car x) max)
	(begin
	  (set! max (car x))
	  (set! max-size size)
	  (set! res (cons size x))))))
  res)

(def (main (serial-number "9005") . args)
  (def grid (build-grid (string->number serial-number) 300))
  (displayln (largest-power-cell grid 3))
  (displayln (largest-power-cell-size grid)))