#lang racket

(require racket/unix-socket)

(define (write-to entries out)
  (displayln entries out))

(define (log pid entries)
  (match (thread-receive)
    [(cons 'read out)
     (write-to entries out)
     (log pid entries)]

    [entry
     (log pid (cons entry entries))]))


(define (logger-send loggers pid message)
  (cond
    [(hash-has-key? loggers pid)
      (thread-send (hash-ref loggers pid) message)]
    [else '()]))

(define (spawn-logger loggers)
  (match (thread-receive)
    [(list 'log pid entry)
     (logger-send loggers pid entry)
     (spawn-logger loggers)]

    [(cons 'spawn pid)
     (spawn-logger (hash-set loggers
                             pid
                             (thread (lambda () (log pid '[])))))]

    [(cons 'kill pid)
     (kill-thread (hash-ref loggers pid))
     (spawn-logger
      (hash-remove loggers pid))]

    [(list 'read pid out)
     (displayln "got read message")
     ; Reads all the logs for a given pid
     (logger-send loggers pid (cons 'read out))
     (spawn-logger loggers)]))

; acts as ambient authority for program
(define
  control-socket
  (unix-socket-listen "/tmp/shelltalk.sock"))

(define log-spawner
  (thread (lambda ()
            (spawn-logger
             (make-immutable-hash '[])))))

(define (close-socket in out)
  (close-output-port out)
  (close-input-port in))

(define (handle-connection in out)
  (define input-string (read-line in 'linefeed))
  (cond
    [(eof-object? input-string)
     (close-socket in out)]
    [else
     (match (string-split input-string)
       [(list "spawn" pid)
        (displayln "got spawn")
        (thread-send log-spawner (cons 'spawn pid))
        (handle-connection in out)]

       [(list "read" pid)
        (displayln "got read")
        (thread-send log-spawner (list 'read pid out))
        (handle-connection in out)]

       [(list "write" pid message)
        (displayln "got write")
        (thread-send log-spawner (list 'log pid message))
        (handle-connection in out)]

       [(list "close" pid)
        (thread-send log-spawner (cons 'kill pid))
        (close-socket in out)]

       [other
        (displayln other)
        (handle-connection in out)])]))

(define (accept-logs)
  (let-values
      ([(in out) (unix-socket-accept control-socket)])
    (thread
     ; hands the read capability over for this shell instance
     (lambda ()
       (file-stream-buffer-mode out 'none)
       (handle-connection in out))))
  (accept-logs))

(accept-logs)