import System.Concurrency
import Control.Monad.Managed
import Data.IORef
import System.Clock

-- Here's the worker, of which we'll run several
-- concurrent instances. These workers will receive
-- work on the `jobs` channel and send the corresponding
-- results on `results`. We'll sleep a second per job to
-- simulate an expensive task.
worker : Int -> Channel Int -> Channel Int -> IO ()
worker id jobs results = do
  loop
  where
    loop : IO ()
    loop = do
      job <- readChannel jobs
      case job of
        Nothing -> pure ()
        Just j -> do
          putStrLn $ "worker " ++ show id ++ " started  job " ++ show j
          sleep 1
          putStrLn $ "worker " ++ show id ++ " finished job " ++ show j
          writeChannel results (j * 2)
          loop

main : IO ()
main = do
  -- In order to use our pool of workers we need to send
  -- them work and collect their results. We make 2
  -- channels for this.
  let numJobs = 5
  jobs <- makeChannel
  results <- makeChannel

  -- This starts up 3 workers, initially blocked
  -- because there are no jobs yet.
  for_ [1..3] $ \w -> 
    fork $ worker w jobs results

  -- Here we send 5 `jobs` and then `close` that
  -- channel to indicate that's all the work we have.
  for_ [1..numJobs] $ \j -> 
    writeChannel jobs j
  closeChannel jobs

  -- Finally we collect all the results of the work.
  -- This also ensures that the worker threads have
  -- finished. An alternative way to wait for multiple
  -- threads is to use a semaphore.
  for_ [1..numJobs] $ \_ -> 
    ignore $ readChannel results

  pure ()

-- To run the program:
-- :exec main