###
Rule System
===========

This file handles the parsing and executing of rules. 

What's a rule
------------
A rule is a string that has the format: "when _this_ then _that_". The _this_ part will be called 
the condition of the rule and the _that_ the actions of the rule.

__Examples:__

  * when its 10pm then turn the tv off
  * when its friday and its 8am then turn the light on
  * when [music is playing or the light is on] and somebody is present then turn the speaker on
  * when temperature of living room is below 15°C for 5 minutes then log "its getting cold"

__The condition and predicates__

The condition of a rule consists of one or more predicates. The predicates can be combined with
"and", "or" and can be grouped by parentheses ('[' and ']'). A predicate is either true or false at 
a given time. There are special predicates, called event-predicates, that represent events. 
These predicate are just true in the moment a special event happen.

Each predicate is handled by a Predicate Provider. Take a look at the 
[predicates file](predicates.html) for more details.

__for-suffix__

A predicate can have a "for" as a suffix like in "music is playing for 5 seconds" or 
"tv is on for 2 hours". If the predicate has a for-suffix then the rule action is only triggered,
when the predicate stays true the given time. Predicates that represent one time events like "10pm"
can't have a for-suffix because the condition can never hold.

__The actions__

The actions of a rule can consists of one or more actions. Each action describes a command that 
should be executed when the condition of the rule is true. Take a look at the 
[actions.coffee](actions.html) for more details.
###

 
assert = require 'cassert'
util = require 'util'
Promise = require 'bluebird'
_ = require 'lodash'
S = require 'string'
M = require './matcher'
require "date-format-lite"
milliseconds = require './milliseconds'
rulesAst = require './rules-ast-builder'

module.exports = (env) ->


  class Rule
    id: null
    name: null
    string: null

    active: null
    valid: null
    logging: null

    # Condition as string
    conditionToken: null
    # Actions as string
    actionsToken: null

    # PredicateHandler
    predicates: null
    # Rule as tokens
    tokens: null
    # ActionHandler
    actions: null

    # Error message if not valid
    error: null
    # Time the rule was last executed
    lastExecuteTime: null

    conditionExprTree: null
      
    constructor: (@id, @name, @string) ->
      assert typeof @id is "string"
      assert typeof @name is "string"
      assert typeof @string is "string"

    update: (fromRule) ->
      assert @id is fromRule.id
      @name = fromRule.name
      @string = fromRule.string
      @active = fromRule.active
      @valid = fromRule.valid
      @logging = fromRule.logging
      @conditionToken = fromRule.conditionToken
      @actionsToken = fromRule.actionsToken
      @predicates = fromRule.predicates
      @tokens = fromRule.tokens
      @actions = fromRule.actions
      @error = fromRule.error
      @lastExecuteTime = fromRule.lastExecuteTime
      @conditionExprTree = fromRule.conditionExprTree

    toJson: -> {
      id: @id
      name: @name
      string: @string
      active: @active
      valid: @valid
      logging: @logging
      conditionToken: @conditionToken
      actionsToken: @actionsToken
      error: @error
    }

  ###
  The Rule Manager
  ----------------
  The Rule Manager holds a collection of rules. Rules can be added to this collection. When a rule
  is added, the rule is parsed by the Rule Manager and for each predicate a Predicate Provider will
  be searched. Predicate Provider that should be considered can be added to the Rule Manager.

  If all predicates of the added rule can be handled by a Predicate Provider, for each action of a
  rule's action an Action Handler is searched. Action Handler can be added to the
  Rule Manager, too.

  ###
  class RuleManager extends require('events').EventEmitter
    # Array of the added rules
    # If a rule was successfully added, the rule has the form:
    #  
    #     id: 'some-id'
    #     name: 'some name'
    #     string: 'if its 10pm and light is on then turn the light off'
    #     conditionToken: 'its 10pm and light is on'
    #     predicates: [
    #       { id: 'some-id0'
    #         provider: the corresponding provider },
    #       { id: 'some-id1'
    #         provider: the corresponding provider }
    #     ]
    #     tokens: ['predicate', '(', 0, ')', 'and', 
    #              'predicate', '(', 1, ')' ] 
    #     action: 'turn the light off'
    #     active: false or true
    #  
    # If the rule had an error:
    #  
    #     id: id
    #     string: 'if bla then blub'
    #     error: 'Could not find a provider that decides bla'
    #     active: false 
    #  
    rules: {}
    # Array of ActionHandlers: see [actions.coffee](actions.html)
    actionProviders: []
    # Array of predicateProviders: see [actions.coffee](actions.html)
    predicateProviders: []

    constructor: (@framework) ->

    addActionProvider: (ah) -> @actionProviders.push ah
    addPredicateProvider: (pv) -> @predicateProviders.push pv

    # ###_parseRuleString()
    # This function parses a rule given by a string and returns a rule object.
    # A rule string is for example 'if its 10pm and light is on then turn the light off'
    # it get parsed to the follwoing rule object:
    #  
    #     id: 'some-id'
    #     string: 'when its 10pm and light is on then turn the light off'
    #     conditionToken: 'its 10pm and light is on'
    #     predicates: [
    #       { id: 'some-id0'
    #         provider: the corresponding provider },
    #       { id: 'some-id1'
    #         provider: the corresponding provider }
    #     ]
    #     tokens: ['predicate', '(', 0, ')', 'and', 
    #              'predicate', '(', 1, ')' ] 
    #     action: 'turn the light off'
    #     active: false or true
    #  
    # The function returns a promise!
    _parseRuleString: (id, name, ruleString, context) ->
      assert id? and typeof id is "string" and id.length isnt 0
      assert name? and typeof name is "string"
      assert ruleString? and typeof ruleString is "string"

      rule = new Rule(id, name, ruleString)
      # Always return a promise
      return Promise.try( =>
        
        ###
        First take the string apart, so that
         
            parts = ["", "its 10pm and light is on", "turn the light off"].
        
        ###
        parts = ruleString.split /^when\s|\sthen\s/
        # Check for the right parts count. Note the empty string at the beginning.
        switch
          when parts.length < 3
            throw new Error('The rule must start with "when" and contain a "then" part!')
          when parts.length > 3 
            throw new Error('The rule must exactly contain one "when" and one "then" part!')
        ###
        Then extract the condition and actions from the rule 
         
            rule.conditionToken = "its 10pm and light is on"
            rule.actions = "turn the light off"
         
        ###
        rule.conditionToken = parts[1].trim()
        rule.actionsToken = parts[2].trim()

        if rule.conditionToken.length is 0
          throw new Error("Condition part of rule #{id} is empty.")
        if rule.actionsToken.length is 0
          throw new Error("Actions part of rule #{id} is empty.")

        result = @_parseRuleCondition(id, rule.conditionToken, context)
        rule.predicates = result.predicates
        rule.tokens = result.tokens

        unless context.hasErrors()
          result = @_parseRuleActions(id, rule.actionsToken, context)
          rule.actions = result.actions
          rule.actionToken = result.tokens
          rule.conditionExprTree = (new rulesAst.BoolExpressionTreeBuilder())
            .build(rule.tokens, rule.predicates)
        return rule
      )

    _parseRuleCondition: (id, conditionString, context) ->
      assert typeof id is "string" and id.length isnt 0
      assert typeof conditionString is "string"
      assert context?
      ###
      Split the condition in a token stream.
      For example: 
        
          "12:30 and temperature > 10"
       
      becomes 
       
          ['12:30', 'and', 'temperature > 30 C']
       
      Then we replace all predicates with tokens of the following form
       
          tokens = ['predicate', '(', 0, ')', 'and', 'predicate', '(', 1, ')']
       
      and remember the predicates:
       
          predicates = [ {token: '12:30'}, {token: 'temperature > 10'}]
       
      ### 
      predicates = []
      tokens = []
      # For each token

      nextInput = conditionString

      success = yes
      openedParentheseCount = 0
      justCondition = false

      while (not context.hasErrors()) and nextInput.length isnt 0
        M(nextInput, context).matchOpenParenthese('[', (next, ptokens) =>
          tokens = tokens.concat ptokens
          openedParentheseCount += ptokens.length
          nextInput = next.getRemainingInput()
        )

        i = predicates.length
        predId = "prd-#{id}-#{i}"

        { predicate, token, nextInput } = @_parsePredicate(
          predId, nextInput, context, null, justCondition
        )
        unless context.hasErrors()
          predicates.push(predicate)
          tokens = tokens.concat ["predicate", "(", i, ")"]

          M(nextInput, context).matchCloseParenthese(']', openedParentheseCount, (next, ptokens) =>
            tokens = tokens.concat ptokens
            openedParentheseCount -= ptokens.length
            nextInput = next.getRemainingInput()
          )

          # Try to match " and ", " or ", ...
          possibleTokens = [' and if ', ' and ', ' or when ', ' or ']
          onMatch = (m, s) => 
            token = s.trim()
            if token is 'and if' then justCondition = true
            else if token is 'or when' then justCondition = false
            tokens.push token
          m = M(nextInput, context).match(possibleTokens, onMatch)
          unless nextInput.length is 0
            if m.hadNoMatch()
              context.addError("""Expected one of: "and", "or", "]".""")
            else
              token = m.getFullMatch()
              assert S(nextInput.toLowerCase()).startsWith(token.toLowerCase())
              nextInput = nextInput.substring(token.length)
      if tokens.length > 0
        lastToken = tokens[tokens.length-1]
        if lastToken in ["and", "or", "and if", "or when"]
          context.addError("""Expected a new predicate after last "#{lastToken}".""")
      if openedParentheseCount > 0
        context.addError("""Expected closing parenthese ("]") at end.""")
      return {
        predicates: predicates
        tokens: tokens
      }

    _parsePredicate: (predId, nextInput, context, predicateProviderClass, justCondition) =>
      assert typeof predId is "string" and predId.length isnt 0
      assert typeof nextInput is "string"
      assert context?

      predicate =
        id: predId
        token: null
        handler: null
        for: null
        justTrigger: false
        justCondition: justCondition

      token = ''

      # trigger keyword?
      m = M(nextInput, context).match(["trigger: "])
      if m.hadMatch()
        match = m.getFullMatch()
        token += match
        nextInput = nextInput.substring(match.length)
        predicate.justTrigger = match is "trigger: "

      # find a predicate provider for that can parse and decide the predicate:
      parseResults = []
      for predProvider in @predicateProviders
        if predicateProviderClass?
          continue if predProvider.constructor.name isnt predicateProviderClass
        context.elements = {}
        parseResult = predProvider.parsePredicate(nextInput, context)
        if parseResult?
          assert parseResult.token? and parseResult.token.length > 0
          assert parseResult.nextInput? and typeof parseResult.nextInput is "string"
          assert parseResult.predicateHandler?
          assert parseResult.predicateHandler instanceof env.predicates.PredicateHandler
          parseResult.elements = context.elements[parseResult.token]
          parseResults.push parseResult

      switch parseResults.length
        when 0
          context.addError(
            """Could not find an provider that decides next predicate of "#{nextInput}"."""
          )
        when 1
          # get part of nextInput that is related to the found provider
          parseResult = parseResults[0]
          token += parseResult.token
          assert parseResult.token?
          #assert S(nextInput.toLowerCase()).startsWith(parseResult.token.toLowerCase())
          predicate.token = parseResult.token
          nextInput = parseResult.nextInput
          predicate.handler = parseResult.predicateHandler
          context.elements = {}
          timeParseResult = @_parseTimePart(nextInput, " for ", context)
          if timeParseResult?
            token += timeParseResult.token
            nextInput = timeParseResult.nextInput
            predicate.for = {
              token: timeParseResult.timeToken
              exprTokens: timeParseResult.timeExprTokens
              unit: timeParseResult.unit
            }

          if predicate.justTrigger and predicate.for?
            context.addError(
              "\"#{token}\" is marked as trigger, it can't be true for \"#{predicate.token}\"."
            )

          if predicate.handler.getType() is 'event' and predicate.for?
            context.addError(
              "\"#{token}\" is an event it can't be true for \"#{predicate.for.token}\"."
            )

          if predicate.handler.getType() is 'event' and predicate.justCondition
            context.addError(
              "\"#{token}\" is an event it can't be used with \"... and if ...\"."
            )

        else
          context.addError(
            """Next predicate of "#{nextInput}" is ambiguous."""
          )
      return { 
        predicate, token, nextInput, 
        elements: parseResult?.elements 
        forElements: timeParseResult?.elements
      }

    _parseTimePart: (nextInput, prefixToken, context, options = null) ->
      # Parse the for-Suffix:
      timeExprTokens = null
      unit = null
      onTimeduration = (m, tp) => 
        timeExprTokens = tp.tokens
        unit = tp.unit

      varsAndFuns = @framework.variableManager.getVariablesAndFunctions()
      m = M(nextInput, context)
        .match(prefixToken, options)
        .matchTimeDurationExpression(varsAndFuns, onTimeduration)

      unless m.hadNoMatch()
        token = m.getFullMatch()
        assert S(nextInput).startsWith(token)
        timeToken = S(token).chompLeft(prefixToken).s
        nextInput = nextInput.substring(token.length)
        elements = m.elements
        return {token, nextInput, timeToken, timeExprTokens, unit, elements}
      else
        return null

    _parseRuleActions: (id, nextInput, context) ->
      assert typeof id is "string" and id.length isnt 0
      assert typeof nextInput is "string"
      assert context?

      actions = []
      tokens = []
      # For each token

      success = yes
      openedParentheseCount = 0

      while (not context.hasErrors()) and nextInput.length isnt 0
        i = actions.length
        actionId = "act-#{id}-#{i}"
        { action, token, nextInput } = @_parseAction(actionId, nextInput, context)
        unless context.hasErrors()
          actions.push action
          tokens = tokens.concat ['action', '(', i, ')']
          # actions.push {
          #   token: token
          #   handler: 
          # }
          onMatch = (m, s) => tokens.push s.trim()
          m = M(nextInput, context).match([' and '], onMatch)
          unless nextInput.length is 0
            if m.hadNoMatch()
              context.addError("Expected: \"and\", got \"#{nextInput}\"")
            else
              token = m.getFullMatch()
              assert S(nextInput.toLowerCase()).startsWith(token.toLowerCase())
              nextInput = nextInput.substring(token.length)
      return {
        actions: actions
        tokens: tokens
      }

    _parseAction: (actionId, nextInput, context) =>
      assert typeof nextInput is "string"
      assert context?

      token = null

      action =
        id: actionId
        token: null
        handler: null
        after: null
        for: null

      parseAfter = (type) =>
        prefixToken =  (if type is "prefix" then "after " else " after ")
        timeParseResult = @_parseTimePart(nextInput, prefixToken, context)
        if timeParseResult?
          nextInput = timeParseResult.nextInput
          if type is 'prefix'
            if nextInput.length > 0 and nextInput[0] is ' '
              nextInput = nextInput.substring(1)
          action.after = {
            token: timeParseResult.timeToken
            exprTokens: timeParseResult.timeExprTokens
            unit: timeParseResult.unit
          }
      # Try to match after as prefix: after 10 seconds log "42" 
      parseAfter('prefix')

      # find a predicate provider for that can parse and decide the predicate:
      parseResults = []
      for actProvider in @actionProviders
        parseResult = actProvider.parseAction(nextInput, context)
        if parseResult?
          assert parseResult.token? and parseResult.token.length > 0
          assert parseResult.nextInput? and typeof parseResult.nextInput is "string"
          assert parseResult.actionHandler?
          assert parseResult.actionHandler instanceof env.actions.ActionHandler
          parseResults.push parseResult

      switch parseResults.length
        when 0
          context.addError(
            """Could not find an provider that provides the next action of "#{nextInput}"."""
          )
        when 1
          # Get part of nextInput that is related to the found provider
          parseResult = parseResults[0]
          token = parseResult.token
          assert token?
          assert S(nextInput.toLowerCase()).startsWith(parseResult.token.toLowerCase())
          action.token = token
          nextInput = parseResult.nextInput
          action.handler = parseResult.actionHandler

          # Try to match after as suffix: log "42" after 10 seconds
          unless action.after?
            parseAfter('suffix')

          # Try to parse "for 10 seconds"
          forSuffixAllowed = action.handler.hasRestoreAction()
          timeParseResult = @_parseTimePart(nextInput, " for ", context, {
            acFilter: () => forSuffixAllowed
          })
          if timeParseResult?
            nextInput = timeParseResult.nextInput
            action.for = {
              token: timeParseResult.timeToken
              exprTokens: timeParseResult.timeExprTokens
              unit: timeParseResult.unit
            }

          if action.for? and forSuffixAllowed is no
            context.addError(
              """Action "#{action.token}" can't have a "for"-Suffix."""
            )
          
        else
          context.addError(
            """Next action of "#{nextInput}" is ambiguous."""
          )

      return { action, token, nextInput }

    # This function should be called by a provider if a predicate becomes true.
    whenPredicateIsTrue: (rule, predicateId, state) =>
      assert rule?
      assert predicateId? and typeof predicateId is "string" and predicateId.length isnt 0
      assert state is 'event' or state is true

      # If not active, then nothing to do
      unless rule.active then return

      # Then mark the given predicate as true
      knownPredicates = {}
      knownPredicates[predicateId] = true

      # And check if the rule is now true.
      @_evaluateConditionOfRule(rule, knownPredicates).then( (isTrue) =>
        # If the rule is now true, then execute its action
        if isTrue 
          return @_executeRuleActionsAndLogResult(rule)
      ).catch( (error) => 
        env.logger.error """
          Error on evaluation of rule condition of rule #{rule.id}: #{error.message}
        """ 
        env.logger.debug error
      )
      return

    # ###_addPredicateChangeListener()
    # Register for every predicate the callback function that should be called
    # when the predicate becomes true.
    _addPredicateChangeListener: (rule) ->
      assert rule?
      assert rule.predicates?

      setupTime = (new Date()).getTime()
      # For all predicate providers
      for p in rule.predicates
        do (p) =>
          assert(not p.changeListener?)
          p.lastChange = setupTime
          p.handler.setup()
          if p.for
            p.timeAchived = false
          # Let us be notified when the predicate state changes.
          p.handler.on 'change', changeListener = (state) =>
            assert state is 'event' or state is true or state is false
            p.lastChange = (new Date()).getTime()
            # If the state is true then call the `whenPredicateIsTrue` function.
            unless p.justCondition
              if p.for?
                if state is false
                  clearTimeout(p.forTimeout)
                  p.forTimeout = undefined
                  p.timeAchived = false
                if state is true
                  # If timeout already set, -> return
                  if p.forTimeout? then return
                  @_evaluateTimeExpr(
                    p.for.exprTokens,
                    p.for.unit
                  ).then( (ms) =>
                    # If timeout already set, -> return
                    if p.forTimeout? then return
                    p.forTimeout = setTimeout( ( () =>
                      p.timeAchived = true
                      @whenPredicateIsTrue rule, p.id, state
                    ), ms)
                  ).catch( (err) =>
                    env.logger.error "Error evaluating time expr for predicate: #{err.message}"
                    env.logger.debug error
                  )
              else
                if state is true or state is 'event'
                  @whenPredicateIsTrue rule, p.id, state
          p.changeListener = changeListener
          if p.for?
            # bootstrap timeout
            p.handler.getValue().then( (val) =>
              if val is true
                if p.forTimeout? then return
                @_evaluateTimeExpr(
                  p.for.exprTokens,
                  p.for.unit
                ).then( (ms) =>
                  # If timeout already set, -> return
                  if p.forTimeout? then return
                  p.forTimeout = setTimeout( ( () =>
                    p.timeAchived = true
                  ), ms)
                )
            )

          p.handler.on 'recreate', recreateListener = =>
            @recreateRule(rule)
          p.ready = true

    _removePredicateChangeListener: (rule) ->
      assert rule?
      # Then cancel the notifier for all predicates
      if rule.valid
        for p in rule.predicates
          do (p) =>
            if p.ready
              assert typeof p.changeListener is "function"
              p.handler.removeListener 'change', p.changeListener
              delete p.changeListener
              p.handler.removeAllListeners 'recreate'
              p.handler.destroy()
              clearTimeout(p.forTimeout)
              p.ready = false

    _setupActions: (rule) ->
      for action in rule.actions
        action.handler.setup()
        action.handler.on 'recreate', recreateListener = =>
          @recreateRule(rule)
        action.ready = true


    _destroyActionsAndCancelSheduledActions: (rule) ->
      assert rule?
      # Then cancel the notifier for all predicates
      if rule.valid
        for action in rule.actions
          do (action) =>
            if action.ready
              action.handler.destroy()
              action.handler.removeAllListeners 'recreate'
              action.ready = false
              if action.scheduled?
                action.scheduled.cancel(
                  "canceling schedule of action #{action.token}"
                )

    # ###addRuleByString()
    addRuleByString: (id, {name, ruleString, active, logging}, force = false) ->
      assert id? and typeof id is "string" and id.length isnt 0
      assert name? and typeof name is "string"
      assert ruleString? and typeof ruleString is "string"
      assert (if active? then typeof active is "boolean" else true)
      assert (if logging? then typeof logging is "boolean" else true)
      assert (if force? then typeof force is "boolean" else true)
      unless active? then active = yes
      unless logging? then logging = yes


      unless id.match /^[a-z0-9\-_]+$/i then throw new Error "Rule ID must only contain " +
        "alpha numerical symbols, \"-\" and  \"_\""
      if @rules[id]? then throw new Error "There is already a rule with the ID \"#{id}\""

      context = @_createParseContext()
      # First parse the rule.
      return @_parseRuleString(id, name, ruleString, context).then( (rule) =>
        rule.logging = logging
        # If we have a parse error we don't need to continue here
        if context.hasErrors()
          error = new Error context.getErrorsAsString()
          error.rule = rule
          error.context = context
          throw error

        @_addPredicateChangeListener rule
        @_setupActions rule
        # If the rules was successful parsed add it to the rule array.
        rule.active = active
        rule.valid = yes
        @rules[id] = rule
        @emit "ruleAdded", rule
        return
      ).catch( (error) =>
        # If there was an error parsing the rule, but the rule is forced to be added, then add
        # the rule with an error.
        if force
          if error.rule?
            rule = error.rule
            rule.error = error.message
            rule.active = false
            rule.valid = no
            @rules[id] = rule
            @emit 'ruleAdded', rule
          else
            env.logger.error 'Could not force add rule, because error has no rule attribute.'
            env.logger.debug error.stack
        throw error
      )

    # ###removeRule()
    # Removes a rule from the Rule Manager.
    removeRule: (id) ->
      assert id? and typeof id is "string" and id.length isnt 0
      throw new Error("Invalid ruleId: \"#{id}\"") unless @rules[id]?

      # First get the rule from the rule array.
      rule = @rules[id]
      # Then cancel all notifications
      @_removePredicateChangeListener(rule)
      @_destroyActionsAndCancelSheduledActions(rule)
      # and delete the rule from the array
      delete @rules[id]
      # and emit the event.
      @emit "ruleRemoved", rule
      return

    # ###updateRuleByString()
    updateRuleByString: (id, {name, ruleString, active, logging}) ->
      assert id? and typeof id is "string" and id.length isnt 0
      assert (if name? then typeof name is "string" else true)
      assert (if ruleString? then typeof ruleString is "string" else true)
      assert (if active? then typeof active is "boolean" else true)
      assert (if logging? then typeof logging is "boolean" else true)
      throw new Error("Invalid ruleId: \"#{id}\"") unless @rules[id]?
      rule = @rules[id]
      unless name? then name = rule.name
      unless ruleString? then ruleString = rule.string
      context = @_createParseContext()
      # First try to parse the updated ruleString.
      return @_parseRuleString(id, name, ruleString, context).then( (newRule) =>
        if context.hasErrors()
          error = new Error context.getErrorsAsString()
          error.rule = newRule
          error.context = context
          throw error

        # Set the properties for the new rule
        newRule.valid = yes
        newRule.active = if active? then active else rule.active
        newRule.logging = if logging? then logging else rule.logging

        # If the rule was successfully parsed then update the rule
        if rule isnt @rules[id]
          throw new Error("Rule #{rule.id} was removed while updating")

        # and cancel the notifier for the old predicates.
        @_removePredicateChangeListener(rule)
        @_destroyActionsAndCancelSheduledActions(rule)

        # We do that to keep the old rule object and don't use the new one
        rule.update(newRule)

        # and register the new ones,
        @_addPredicateChangeListener(rule)
        @_setupActions(rule)
        # and emit the event.
        @emit "ruleChanged", rule
      )

    recreateRule: (rule) ->
      if rule.recreating
        return
      rule.recreating = true
      @updateRuleByString(rule.id, {})
        .then( => rule.recreating = false )
        .catch( (error) =>
          @_removePredicateChangeListener(rule)
          @_destroyActionsAndCancelSheduledActions(rule)
          rule.active = false
          rule.valid = false
          rule.recreating = false 
          env.logger.error("Error in rule #{rule.id}: #{error.message}")
          env.logger.debug(error.stack)
          # and emit the event.
          @emit "ruleChanged", rule
        ).done()


    # ###_evaluateConditionOfRule()
    # This function returns a promise that will be fulfilled with true if the condition of the 
    # rule is true. This function ignores all the "for"-suffixes of predicates. 
    # The `knownPredicates` is an object containing a value for
    # each predicate for that the state is already known.
    _evaluateConditionOfRule: (rule, knownPredicates = {}) ->
      assert rule? and rule instanceof Object
      assert knownPredicates? and knownPredicates instanceof Object
      return rule.conditionExprTree.evaluate(knownPredicates)

    # ###_executeRuleActionsAndLogResult()
    # Executes the actions of the string using `executeAction` and logs the result to 
    # the env.logger.    
    _executeRuleActionsAndLogResult: (rule) ->
      currentTime = (new Date).getTime()
      if rule.lastExecuteTime?
        delta = currentTime - rule.lastExecuteTime
        if delta <= 500
          env.logger.debug "Suppressing rule #{rule.id} execute because it was executed recently."
          return Promise.resolve()
      rule.lastExecuteTime = currentTime

      actionResults = @_executeRuleActions(rule, false)

      logMessageForResult = (actionResult) =>
        return actionResult.then( (result) =>
          [message, next] = (
            if typeof result is "string" then [result, null]
            else 
              assert Array.isArray result
              assert result.length is 2
              result
          )
          if rule.logging
            env.logger.info "rule #{rule.id}: #{message}"
          if next?
            assert next.then?
            next = logMessageForResult(next)
          return [message, next]
        ).catch( (error) =>
          env.logger.error "rule #{rule.id} error executing an action: #{error.message ? error}"
          env.logger.debug error.stack if error.stack?
        )

      for actionResult in actionResults
        actionResult = logMessageForResult(actionResult)
      return Promise.all(actionResults)

    # ###executeAction()
    # Executes the actions in the given actionString
    _executeRuleActions: (rule, simulate) ->
      assert rule?
      assert rule.actions?
      assert simulate? and typeof simulate is "boolean"

      actionResults = []
      for action in rule.actions
        do (action) =>
          promise = null
          if action.after?
            unless simulate 
              # Cancel schedule for pending executes
              if action.scheduled?
                action.scheduled.cancel(
                  "reschedule action #{action.token} in #{action.after.token}"
                ) 
              # Schedule new action
              promise = @_evaluateTimeExpr(
                action.after.exprTokens, 
                action.after.unit
              ).then( (ms) => @_scheduleAction(action, ms) )
            else
              promise = @_executeAction(action, simulate).then( (message) => 
                "#{message} after #{action.after.token}"
              )
          else
            promise = @_executeAction(action)
          assert promise.then?
          actionResults.push promise
      return actionResults

    _evaluateTimeExpr: (exprTokens, unit) =>
      @framework.variableManager.evaluateNumericExpression(exprTokens).then( (time) =>
        return milliseconds.parse "#{time} #{unit}"
      )

    _executeAction: (action, simulate) =>
      # wrap into an fcall to convert thrown erros to a rejected promise
      return Promise.try( => 
        promise = action.handler.executeAction(simulate)
        if action.for?
          promise = promise.then( (message) =>
            restoreActionPromise = @_evaluateTimeExpr(
              action.for.exprTokens, 
              action.for.unit
            ).then( (ms) => @_scheduleAction(action, ms, yes) )
            return [message, restoreActionPromise]
          )
        return promise
      )

    _executeRestoreAction: (action, simulate) =>
      # Wrap into an fcall to convert thrown erros to a rejected promise
      return Promise.try( => action.handler.executeRestoreAction(simulate) )

    _scheduleAction: (action, ms, isRestore = no) =>
      assert action?
      if action.scheduled?
        action.scheduled.cancel("clearing scheduled action")

      return new Promise( (resolve, reject) =>
        timeoutHandle = setTimeout((=> 
          promise = (
            unless isRestore then @_executeAction(action, no)
            else @_executeRestoreAction(action, no)
          )
          resolve(promise)
          delete action.scheduled
        ), ms)
        action.scheduled = {
          startDate: new Date()
          cancel: (reason) =>
            clearTimeout(timeoutHandle)
            delete action.scheduled
            resolve(reason)
        }
      )

    _createParseContext: ->
      {variables, functions} = @framework.variableManager.getVariablesAndFunctions()
      return M.createParseContext(variables, functions)

  
    # ###getRules()
    getRules: () -> 
      rules = (r for id, r of @rules)
      # sort in config order
      rulesInConfig = _.map(@framework.config.rules, (r) => r.id )
      return _.sortBy(rules, (r) => rulesInConfig.indexOf r.id )

    getRuleById: (ruleId) -> @rules[ruleId]

    getRuleActionsHints: (actionsInput) ->
      context =  null
      result = null

      context = @_createParseContext()
      result = @_parseRuleActions("id", actionsInput, context)
      context.finalize()

      for a in result.actions
        delete a.handler

      return {
        tokens: result.tokens
        actions: result.actions
        autocomplete: context.autocomplete
        errors: context.errors
        format: context.format
        warnings: context.warnings
      }

    getRuleConditionHints: (conditionInput) ->
      context =  null
      result = null

      context = @_createParseContext()
      result = @_parseRuleCondition("id", conditionInput, context)
      context.finalize()

      for p in result.predicates
        delete p.handler

      tree = null
      if context.errors.length is 0
        tree = (new rulesAst.BoolExpressionTreeBuilder())
          .build(result.tokens, result.predicates)

      return {
        tokens: result.tokens
        predicates: result.predicates
        tree: tree
        autocomplete: context.autocomplete
        errors: context.errors
        format: context.format
        warnings: context.warnings
      }

    getPredicatePresets: () ->
      presets = []
      for p in @predicateProviders
        if p.presets?
          for d in p.presets
            d.predicateProviderClass = p.constructor.name
            presets.push d
      return presets


    getPredicateInfo: (input, predicateProviderClass) ->
      context = @_createParseContext()
      result = @_parsePredicate("id", input, context, predicateProviderClass, false)
      if result?.predicate?
        unless result.predicate.justTrigger or result.predicate.handler?.getType() is "event"
          unless result.forElements?
            timeParseResult = @_parseTimePart(" for 5 minutes", " for ", context)
            result.forElements = timeParseResult.elements
        delete result.predicate.handler
      context.finalize()
      result.errors = context.errors
      return result

    executeAction: (actionString, simulate = false, logging = yes) =>
      context = @_createParseContext()
      parseResult = @_parseAction('custom-action', actionString, context)
      context.finalize()
      if context.hasErrors()
        return Promise.reject new Error(context.errors)
      return @_executeAction(parseResult.action, simulate).then( (message) =>
        env.logger.info "execute action: #{message}" if logging
        return message
      )

    updateRuleOrder: (ruleOrder) ->
      assert ruleOrder? and Array.isArray ruleOrder
      @framework.config.rules = _.sortBy(@framework.config.rules,  (rule) => 
        index = ruleOrder.indexOf rule.id 
        return if index is -1 then 99999 else index # push it to the end if not found
      )
      @framework.saveConfig()
      @framework._emitRuleOrderChanged(ruleOrder)
      return ruleOrder

  return exports = { RuleManager }