{-# LANGUAGE OverloadedStrings #-}
module EventUtil where

import Control.Monad
import Data.XML.Types as XML
import qualified Data.List as List
import Data.Text (Text)

-- getStreamName (EventBeginElement name _) = name

isEventBeginElement :: Event -> Bool
isEventBeginElement (EventBeginElement {}) = True
isEventBeginElement _ = False

isEventEndElement :: Event -> Bool
isEventEndElement (EventEndElement {}) = True
isEventEndElement _ = False

-- Note: This function ignores name space qualification
elementAttrs ::
  MonadPlus m =>
  Text -> Event -> m [(Name, [Content])]
elementAttrs expected (EventBeginElement name attrs)
    | nameLocalName name==expected 
    = return attrs
elementAttrs _ _ = mzero

streamP :: Text -> Name
streamP name = Name name (Just "http://etherx.jabber.org/streams") (Just "stream")

attr :: Name -> Text -> (Name,[Content])
attr   name value = (name,[ContentText value])

isServerIQOf :: Event -> Text -> Bool
isServerIQOf (EventBeginElement name attrs) testType 
    | name=="{jabber:server}iq" 
    && matchAttrib "type" testType attrs
    = True
isServerIQOf _ _ = False

isClientIQOf :: Event -> Text -> Bool
isClientIQOf (EventBeginElement name attrs) testType 
    | name=="{jabber:client}iq" 
    && matchAttrib "type" testType attrs
    = True
isClientIQOf _ _ = False

matchAttrib :: Name -> Text -> [(Name, [Content])] -> Bool
matchAttrib name value attrs = 
    case List.find ( (==name) . fst) attrs of
        Just (_,[ContentText x])   | x==value -> True
        Just (_,[ContentEntity x]) | x==value -> True
        _                                     -> False

lookupAttrib :: Name -> [(Name, [Content])] -> Maybe Text
lookupAttrib name attrs =
    case List.find ( (==name) . fst) attrs of
        Just (_,[ContentText x])   -> Just x
        Just (_,[ContentEntity x]) -> Just x
        _                          -> Nothing

tagAttrs :: Event -> [(Name, [Content])]
tagAttrs (EventBeginElement _ xs) = xs
tagAttrs _                        = []

    
{-
iqTypeSet    = "set"
iqTypeGet    = "get"
iqTypeResult = "result"
iqTypeError  = "error"
-}


tagName :: Event -> Name
tagName (EventBeginElement n _) = n
tagName _                       = ""

closerFor :: Event -> Event
closerFor (EventBeginElement n _) = EventEndElement n
closerFor _ = error "closerFor: unsupported event"