#
#--
# Copyright (c) 2006-2008, John Mettraux, OpenWFE.org
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# . Redistributions of source code must retain the above copyright notice, this
#   list of conditions and the following disclaimer.
#
# . Redistributions in binary form must reproduce the above copyright notice,
#   this list of conditions and the following disclaimer in the documentation
#   and/or other materials provided with the distribution.
#
# . Neither the name of the "OpenWFE" nor the names of its contributors may be
#   used to endorse or promote products derived from this software without
#   specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#++
#

#
# "made in Japan"
#
# John Mettraux at openwfe.org
#

require 'openwfe/workitem'
require 'openwfe/flowexpressionid'
require 'openwfe/expressions/condition'
require 'openwfe/expressions/flowexpression'


#
# expressions like 'set' and 'unset' and their utility methods
#

module OpenWFE

  #
  # The 'if' expression.
  #
  #   <if>
  #     <equals field-value="f0" other-value="true" />
  #     <participant ref="alpha" />
  #   </if>
  #
  # It accepts an 'else' clause :
  #
  #   <if>
  #     <equals field-value="f0" other-value="true" />
  #     <participant ref="alpha" />
  #     <participant ref="bravo" />
  #   </if>
  #
  # The 'test' attribute can be used instead of a condition child :
  #
  #   <if test="${f:f0}">
  #     <participant ref="alpha" />
  #   </if>
  #
  # The 'rtest' attribute can be used to embed a condition expressed directly
  # in Ruby :
  #
  #   <if rtest="5 * 12 == 61">
  #     <participant ref="alpha" />
  #   </if>
  #
  # (Note that 'rtest' may only be used if the <tt>:ruby_eval_allowed</tt>
  # parameter has been set in the engine's application_context :
  #
  #   engine.application_context[:ruby_eval_allowed] = true
  #
  # but this is dangerous if the origin of the process defintions to run
  # are not trusted)
  #
  # Used alone with 'test' or 'rtest', the 'if' expression simply sets the
  # the __result__ field of its workitem to the result of its attribute
  # evaluation :
  #
  #   <if test="5 == 6"/>
  #
  # will set the __result__ field of the workitem to 'false'.
  #
  class IfExpression < FlowExpression
    include ConditionMixin

    names :if

    #
    # This boolean is set to true when the conditional claused has
    # been evaluated and the 'if' is waiting for the consequence's
    # reply.
    #
    attr_accessor :condition_replied


    def apply (workitem)

      #workitem.unset_result
        #
        # since OpenWFEru 0.9.16 previous __result__ values
        # are not erased before an 'if'.

      test = eval_condition :test, workitem, :not

      if @children.length < 1
        #workitem.set_result test if test
        workitem.set_result((test != nil and test != false))
        reply_to_parent workitem
        return
      end

      @condition_replied = (test != nil)
        #
        # if the "test" attribute is not used, test will be null

      store_itself

      # a warning

      maxchildren = (test == nil) ? 3 : 2

      lwarn {
        "apply() 'if' with more than #{maxchildren} children"
      } if @children.size > maxchildren

      # apply next step

      if test != nil
        #
        # apply then or else (condition result known)
        #
        apply_consequence test, workitem, 0
      else
        #
        # apply condition
        #
        get_expression_pool.apply @children.first, workitem
      end
    end

    def reply (workitem)

      return reply_to_parent(workitem) \
        if @condition_replied

      result = workitem.attributes[FIELD_RESULT]

      @condition_replied = true

      store_itself

      apply_consequence result, workitem
    end

    #
    # This reply_to_parent takes care of cleaning all the children
    # before replying to the parent expression, this is important
    # because only the 'then' or the 'else' child got evaluated, the
    # remaining one has to be cleaned out here.
    #
    def reply_to_parent (workitem)

      clean_children
      super workitem
    end

    protected

      def apply_consequence (index, workitem, offset=1)

        if index == true
          index = 0
        elsif index == false
          index = 1
        elsif index == nil
          index = 1
        elsif not index.integer?
          index = 0
        end

        index = index + offset

        if index >= @children.length
          reply_to_parent workitem
        else
          get_expression_pool.apply @children[index], workitem
        end
      end
  end

  #
  # The 'case' expression.
  #
  #   <case>
  #
  #     <equals field="f0" other-value="ready" />
  #     <participant ref="alpha" />
  #
  #     <if test="${supply_level} == ${field:supply_request}" />
  #     <participant ref="bravo" />
  #
  #     <participant ref="charly" />
  #
  #   </case>
  #
  # A generalized 'if'. Will evaluate its children, expecting the order :
  #
  #   - condition
  #   - consequence
  #   - condition
  #   - consequence
  #   ...
  #   - else consequence (optional)
  #
  # The 'switch' nickname can be used for 'case'.
  #
  class CaseExpression < FlowExpression

    names :case, :switch

    #
    # keeping track of where we are in the case iteration
    #
    attr_accessor :offset

    #
    # set to 'true' when the case expression is actually evaluating
    # a condition (ie not triggering a consequence).
    #
    attr_accessor :evaluating_condition


    def apply (workitem)

      #workitem.unset_result
        #
        # since OpenWFEru 0.9.16 previous __result__ values
        # are not erased before a 'case'.

      @offset = nil

      trigger_child workitem, true
    end

    def reply (workitem)

      if @evaluating_condition

        result = workitem.get_boolean_result

        #ldebug { "reply() result : '#{result.to_s}' (#{result.class})" }

        trigger_child workitem, !result
      else

        reply_to_parent workitem
      end
    end

    protected

      def trigger_child (workitem, is_condition)

        @offset = if !@offset
          0
        elsif is_condition
          @offset + 2
        else
          @offset + 1
        end

        #ldebug { "trigger_child() is_condition ? #{is_condition}" }
        #ldebug { "trigger_child() next offset is #{@offset}" }

        unless @children[@offset]
          reply_to_parent workitem
          return
        end

        @evaluating_condition = is_condition

        store_itself

        get_expression_pool.apply(@children[@offset], workitem)
      end
  end

end