{-| Module     : INRules
    Maitainer  : jmvilaca@di.uminho.pt

    
-}

module INRules
    ( INRules
    , empty

    , updateRule
    , rulesNames
    , findRule
    , fromRule
    , addNewRule
    , addNewEmptyRule
    , removeRule

    , mapRules
    ) where

import INRule
import InfoKind

import Data.List

type INRules g n e = [INRule g n e] 

-- | Empty set of rules.
empty :: (InfoKind e g, InfoKind n g) => g -> n -> e -> INRules g n e
empty g n e = []


updateRule :: String -> (INRule g n e -> INRule g n e) 
               -> INRules g n e -> INRules g n e
updateRule ruleName ruleFunc rules = map f rules 
    where f rule | ruleName == getName rule = ruleFunc rule
                 | otherwise                    = rule

rulesNames :: INRules g n e -> [String]
rulesNames = map getName 

sameName :: String -> INRule g n e -> Bool
sameName ruleName rule = (getName rule) == ruleName

findRule :: String -> INRules g n e -> Maybe (INRule g n e)
findRule ruleName rules = find (sameName ruleName) rules

fromRule :: (INRule g n e -> x) -> String -> INRules g n e -> Maybe x
fromRule func ruleName rules = 
    case findRule ruleName rules of
       Just rule -> Just $ func rule
       Nothing   -> Nothing  

addNewRule :: INRule g n e -> INRules g n e -> INRules g n e
addNewRule newRule rules =  rules ++ [newRule]

addNewEmptyRule :: (InfoKind e g, InfoKind n g) => 
              String -> g -> n -> e -> INRules g n e -> INRules g n e 
addNewEmptyRule ruleName g n e rules = 
   let newRule = setName ruleName $ initial g n e
   in addNewRule newRule rules 

removeRule :: (InfoKind e g, InfoKind n g) => 
              String -> INRules g n e -> INRules g n e
removeRule ruleName rules = filter (not . sameName ruleName) rules

mapRules :: (INRule g n e -> x) -> INRules g n e -> [x]
mapRules = map