#lang curly-fn racket

(require "scripts/aoc.rkt")

;; solution for day 10

(define (pt+ a b)
  (cons (+ (car a) (car b))
        (+ (cdr a) (cdr b))))

(define (part1 input)
  (define ccs (cc (second input)))
  (for/first ([cc-cand (in-list ccs)] #:when (member (first input) cc-cand))
    (/ (length cc-cand) 2)))

(define (part2 input [size 140])
  (define lines (list->vector (file->lines "inputs/10")))

  (define ccs (cc (second input)))
  (define loop
    (~>
      (for/first ([cc-cand (in-list ccs)] #:when (member (first input) cc-cand))
        cc-cand)
      list->set))

  (define (count-crossings pt)
    (cond
      [(< (car pt) 0) 0]
      [(< (cdr pt) 0) 0]
      [else
       (+ (cond
            [(not (set-member? loop pt)) 0]
            [(eq? (string-ref (vector-ref lines (cdr pt)) (car pt)) #\7) 2]
            [(eq? (string-ref (vector-ref lines (cdr pt)) (car pt)) #\L) 2]
            [else 1])
          (count-crossings (pt+ pt '(-1 . -1))))]))

  ; (displayln loop)

  (for*/sum ([y (in-range size)] [x (in-range size)])
    (cond
      [(set-member? loop (cons x y)) 0]
      [(even? (count-crossings (cons x y))) 0]
      [else
        ; (displayln (cons x y))
        1])))

; (part2 (parse "inputs/10-test2") 10)
; (error)


(define (parse fname)
  (define lines (list->vector (file->lines fname)))
  (define-values [N E S W] (values '(0 . -1) '(1 . 0) '(0 . 1) '(-1 . 0)))

  (define start #f)

  (define (get-conns x y)
    (match (string-ref (vector-ref lines y) x)
      [#\. '()]
      [#\| `(,N ,S)]
      [#\- `(,E ,W)]
      [#\L `(,N ,E)]
      [#\J `(,N ,W)]
      [#\7 `(,S ,W)]
      [#\F `(,S ,E)]
      [#\S
       (set! start (cons x y))
       `(,N ,E ,S ,W)]))

  (define edges-raw
    (for/fold ([out (set)])
              ([y (in-range (vector-length lines))]
               #:do []
               [x (in-range (string-length (vector-ref lines 0)))])
      (define this-pt (cons x y))
      (define conns (get-conns x y))
      (set-union out (list->set (map #{list this-pt (pt+ this-pt %)} conns)))))

  (define edges
    (for/set ([x (in-set edges-raw)]
              #:when (set-member? edges-raw (list (second x) (first x))))
      x))

  (list start (unweighted-graph/undirected (set->list edges))))

(module+ main
  (define input (parse "inputs/10"))
  (answer 10 1 (time (part1 input)))
  (answer 10 2 (time (part2 input)))
  (displayln "meow"))