module Wayland.CodeGen.Types
  ( ProtocolT(..)
  , Protocol
  , TypedProtocol
  , TypedInterfaceDesc
  , InterfaceDesc(..)
  , EnumDesc(..)
  , EntryDesc(..)
  , MessageDesc(..)
  , MessageType(..)
  , ArgumentDesc(..)
  , ArgumentType(..)
  , ArgumentName(..)
  , EnumName(..)
  , Description(..)
  , TypeInfo(..)
  , emptyTypeInfo
  , isTypeFree
  ) where
import qualified Data.Map as M

data ProtocolT i
  = Protocol { protName        :: !String
             , protCopyright   :: !(Maybe String)
             , protDescription :: !(Maybe Description)
             , protInterfaces  :: ![i]
             }
  deriving Show

type Protocol = ProtocolT InterfaceDesc

-- Protocol with type names resolved (avoiding possible name clashes within an interface).
type TypedProtocol = ProtocolT TypedInterfaceDesc

type TypedInterfaceDesc = (InterfaceDesc, TypeInfo)

data InterfaceDesc
  = InterfaceDesc { ifName        :: !String
                  , ifVersion     :: !Int
                  , ifDescription :: !(Maybe Description)
                  , ifEnums       :: ![EnumDesc]
                  , ifRequests    :: ![MessageDesc]
                  , ifEvents      :: ![MessageDesc]
                  }
  deriving Show

data EnumDesc
  = EnumDesc { enumName        :: !String
             , enumDescription :: !(Maybe Description)
             , enumSince       :: !Int
             , enumBitfield    :: !Bool
             , enumEntries     :: ![EntryDesc]
             }
  deriving Show

data EntryDesc
  = EntryDesc { entryName            :: !String
              , entryValue           :: !Int
              , entryDescription     :: !(Maybe Description)
              , entrySince           :: !Int
              , entryDeprecatedSince :: !(Maybe Int)
              }
  deriving Show

data MessageDesc
  = MessageDesc { msgName            :: !String
                , msgOpCode          :: !Int
                , msgDescription     :: !(Maybe Description)
                , msgType            :: !MessageType
                , msgSince           :: !Int
                , msgDeprecatedSince :: !(Maybe Int)
                , msgArguments       :: ![ArgumentDesc]
                }
  deriving Show

data MessageType
  = MessageNormal
  | MessageDestructor
  deriving (Show, Eq)

data ArgumentDesc
  = ArgumentDesc { argName        :: !String
                 , argType        :: !ArgumentType
                 , argDescription :: !(Maybe Description)
                 , argInterface   :: !(Maybe String)
                 , argEnum        :: !(Maybe String)
                 , argAllowNull   :: !Bool
                 }
  deriving Show

data ArgumentType
  = ArgumentInt
  | ArgumentUInt
  | ArgumentFixed
  | ArgumentString
  | ArgumentArray
  | ArgumentFD
  | ArgumentNewID
  | ArgumentObject
  deriving (Show, Eq)

data Description
  = Description { descSummary :: !String
                , descBody    :: !String
                }
  deriving Show

data ArgumentName
  = ArgumentNameNone
  | ArgumentNameSingle ArgumentDesc
  | ArgumentNameRecord [ArgumentDesc] String
  deriving Show

data EnumName
  = EnumName EnumDesc String
  deriving Show

data TypeInfo
  = TypeInfo { typeRequestArgs :: !(M.Map String ArgumentName)
             , typeEventArgs   :: !(M.Map String ArgumentName)
             , typeEnums       :: !(M.Map String EnumName)
             }
  deriving Show

emptyTypeInfo :: TypeInfo
emptyTypeInfo = TypeInfo { typeRequestArgs = M.empty
                         , typeEventArgs   = M.empty
                         , typeEnums       = M.empty
                         }

isTypeFree :: String -> TypeInfo -> Bool
isTypeFree name types = not $ any (argMatches name) (typeRequestArgs types)
                           || any (argMatches name) (typeEventArgs   types)
                           || any (enumMatches name) (typeEnums types)
  where argMatches n (ArgumentNameRecord _ n') = n == n'
        argMatches _ _                         = False
        enumMatches n (EnumName _ n') = n == n'