#
#--
# Copyright (c) 2006-2007, 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.
#++
#
# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
#

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

#require 'openwfe/rudefinitions'
require 'openwfe/utils'
require 'openwfe/util/otime'
require 'openwfe/util/scheduler'
require 'openwfe/expressions/timeout'
require 'openwfe/expressions/condition'
require 'openwfe/expressions/fe_sleep'


#
# expressions like 'sleep' and 'cron'
#

module OpenWFE

    #
    # The 'when' expression will trigger a consequence when a condition
    # is met, like in
    #
    #     <when test="${variable:over} == true">
    #         <participant ref="toto" />
    #     </when>
    #
    # where the participant "toto" will receive a workitem when the (local)
    # variable "over" has the value true.
    #
    class WhenExpression < TimeExpression
        include ConditionMixin, TimeoutMixin

        names :when

        attr_accessor \
            :frequency,
            :consequence_triggered

        DEFAULT_FREQUENCY = "10s"

        def apply (workitem)

            remove_timedout_flag(workitem)

            if @children.size < 1
                reply_to_parent(workitem)
                return
            end

            @applied_workitem = workitem.dup

            @frequency = 
                lookup_attribute(:frequency, workitem, DEFAULT_FREQUENCY)
            @frequency = 
                OpenWFE::parse_time_string(@frequency)

            determine_timeout()

            @consequence_triggered = false

            store_itself()

            trigger(nil)
        end

        def reply (workitem)

            ldebug do 
                "reply() @consequence_triggered is '#{@consequence_triggered}'"
            end

            if @consequence_triggered
                reply_to_parent(workitem)
                return
            end

            result = OpenWFE::get_result(workitem)

            if result
                apply_consequence(workitem)
            else
                reschedule(get_scheduler)
            end
        end

        def cancel ()
            to_unschedule()
            super()
        end

        def trigger (params)

            ldebug { "trigger() #{@fei.to_debug_s} params is #{params}" }

            if params == :do_timeout!
                #
                # do timeout...
                #
                set_timedout_flag(@applied_workitem)
                reply_to_parent(@applied_workitem)
                return
            end

            @scheduler_job_id = nil

            evaluate_condition()
        end

        def reschedule (scheduler)

            #return unless @applied_workitem

            @scheduler_job_id = 
                scheduler.schedule_in(@frequency, self, nil)

            ldebug { "reschedule() @scheduler_job_id is #{@scheduler_job_id}" }

            to_reschedule(scheduler)
        end

        def reply_to_parent (workitem)

            unschedule()
            unschedule_timeout()

            super(workitem)
        end

        protected

            def evaluate_condition

                if @children.size > 1
                    #
                    # trigger the evaluation of the first (condition) child

                    store_itself()

                    get_expression_pool.launch_template(
                        self, @children[0], @applied_workitem)
                else
                    #
                    # eval the attribute condition immediately

                    c = eval_condition(:test, @applied_workitem)

                    OpenWFE::set_result(@applied_workitem, c)

                    reply(@applied_workitem)
                end
            end

            def apply_consequence (workitem)

                @consequence_triggered = true

                store_itself()

                i = 1
                i = 0 if @children.size == 1

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

end