import Data.Bifunctor (first)

import Data.Maybe

  putStr $ part2 content

    state = flip evalState (0, 1) . sequence . map instruction . parse

    state = catMaybes . flip evalState (0, 1) . sequence . map instruction . parse

    part2 = unlines . splitCRTLines . drawCRT . ((1,1):) . map (first (+1)) . state

drawCRT :: [(Cycle, RegX)] -> String
drawCRT [] = mempty
drawCRT ((c, x):[]) = foldr' (\a b -> (drawPixel a x) : b) [] [c..240]
drawCRT ((ac, ax):r@(bc, bx):xs) = (foldr' (\a b -> (drawPixel a ax) : b) [] [ac..bc-1]) ++ drawCRT (r:xs)
splitCRTLines :: String -> [String]
splitCRTLines = go
  where
    go :: String -> [String]
    go [] = [[]]
    go x = (fst $ crtLine x) : go (snd $ crtLine x)
    crtLine = splitAt 40
drawPixel :: Cycle -> RegX -> Char
drawPixel x y
  | index <= 1 = '#'
  | otherwise = '.'
  where
    index = abs (column - y)
    column = (x - 1) `mod` 40

instruction :: Instruction -> StateT (Cycle, RegX) Identity (Cycle, RegX)

instruction :: Instruction -> StateT (Cycle, RegX) Identity (Maybe (Cycle, RegX))

  let newRegX = regx + (case x of
                  Noop -> 0
                  (AddX a) -> a
                )

  case x of
    Noop -> do
      put (newCycle, regx)
      pure Nothing
    (AddX a) -> do
      let newSt = (newCycle, regx + a)
      put newSt
      pure $ Just newSt

  put (newCycle, newRegX)
  pure (newCycle, newRegX)