-- | Check if a packet matches a certain event.
checkEvent :: Event -> Packet -> Bool
checkEvent evt pkt =
    let matches = M.fromList -- (event, main packet, packet body)
          [ (AnyEvent, (Anything, Anything))
          , recv Recv Anything
          , recv RecvJoin $ Cmd "join"
          , recv RecvPart $ Cmd "part"
          , recv RecvPrivchg $ Cmd "privchg"
          , recv RecvKicked $ Cmd "kicked"
          , recv RecvAdmin $ Cmd "admin"
          , recv RecvMsg $ Cmd "msg"
          , recv RecvAction $ Cmd "action"
          , recv AdminShow $ Head "admin" "show"
          , recv AdminShowPc $ HeadArgs "admin" "show" [("p", "privclass")]
          , recv AdminShowUsers $ HeadArgs "admin" "show" [("p", "users")]
          , recv AdminRename $ Head "admin" "rename"
          , recv AdminRemove $ Head "admin" "remove"
          , recv AdminMove $ Head "admin" "move"
          , recv AdminUpdate $ Head "admin" "update"
          , recv AdminCreate $ Head "admin" "create"
          , (Property, (Cmd "property", Anything))
          , prop PropertyPc "privclasses"
          , prop PropertyTitle "title"
          , prop PropertyTopic "topic"
          , prop PropertyMembers "members"
          , prop PropertyInfo "info"
          , (DAmnServer, (Cmd "dAmnServer", Anything))
          , (LoginError, (Cmd "login", Anything))
          , (JoinError, (Cmd "join", Anything))
          , (PartError, (Cmd "part", Anything))
          , (SendError, (Cmd "send", Anything))
          , (GetError, (Cmd "get", Anything))
          , (SetError, (Cmd "set", Anything))
          , (KickError, (Cmd "kick", Anything))
          , (Disconnect, (Cmd "disconnect", Anything))
          , (Ping, (Cmd "ping", Anything))
          , (Kicked, (Cmd "kicked", Anything)) ]
        recv :: Event -> EventMatch -> (Event, (EventMatch, EventMatch))
        recv e match = (e, (Cmd "recv", match))
        prop :: Event -> ByteString -> (Event, (EventMatch, EventMatch))
        prop e arg = (e, (CmdArgs "property" [("p", arg)], Anything))
        pktMatch = matches ! evt
        check pkt match =
            case match of
                 Anything -> True
                 Cmd c -> pktCmd pkt == c
                 Param p -> pktParam pkt == p
                 Head c p -> pktCmd pkt == c && pktParam pkt == p
                 Args a -> M.fromList a `M.isSubmapOf` pktArgs pkt
                 CmdArgs c a ->
                     pktCmd pkt == c
                  && M.fromList a `M.isSubmapOf` pktArgs pkt
                 ParamArgs p a ->
                     pktParam pkt == p
                  && M.fromList a `M.isSubmapOf` pktArgs pkt
                 HeadArgs c p a ->
                     pktCmd pkt == c
                  && pktParam pkt == c
                  && M.fromList a `M.isSubmapOf` pktArgs pkt
    in check pkt (fst pktMatch)
    && check (makePacket $ pktBody pkt) (snd pktMatch)

-- | Run all of the event hooks in the client that match the given packet.
runHooks :: Packet -> ClientIO Client
runHooks pkt =
    do hooks <- asks cEventHooks
       client <- ask
       ReaderT $ \_ -> fst $ M.mapAccumWithKey runHooks' (return client) hooks
       where runHooks' cli id hook =
                 if checkEvent (fst hook) pkt
                    -- run the hook with the accumulated client
                    then (cli >>= runReaderT ((snd hook) $ EventInfo pkt (fst hook)), ())
                    else (cli, ())

-- | Run the event hooks that match a list of packets.
runHooksList :: [Packet] -> ClientIO Client
runHooksList [] = ask
runHooksList (x:xs) =
    do cli <- runHooks x
       ReaderT $ \_ -> runReaderT (runHooksList xs) cli