# Apache License, Version 2.0

#

# Copyright (c) 2013 Juergen Mangler

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#     http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

require 'xmlsimple'

require 'pp'

 

class AdvStanza < Blather::Stanza

  def self.new

    node = super :message

    node.type = :chat

    node.id = SecureRandom.uuid

    node

  end

 

  def body=(bd)

    node = XML::Smart::Dom::Element.new(self)

    node.add('body',"<advmsg><advbody>#{bd}</advbody><advtimesent>" + Time.now.strftime('%d.%m.%Y %H:%M:%S') + "</advtimesent></advmsg>")

  end

end

 

class AdventureHandlerWrapper < WEEL::HandlerWrapperBase

  def initialize(arguments,endpoint=nil,position=nil,continue=nil) # {{{

    @controller = arguments[0]

    @handler_continue = continue

    @handler_endpoint = endpoint

    @handler_position = position

    @handler_passthrough = nil

    @handler_returnValue = nil

    @handler_another = false

  end # }}}

 

  def activity_handle(passthrough, parameters) # {{{

    return if @handler_another

    raise "No endpoint defined. Stopping." if @handler_endpoint.nil?

    @controller.notify("running/activity_calling", :instance => @controller.instance, :activity => @handler_position, :passthrough => passthrough, :endpoint => @handler_endpoint, :parameters => parameters)

 

    if passthrough.nil?

      whichep = 0

      if parameters[:parameters] && parameters[:parameters][:SPE_PARTNER]

        whichep = parameters[:parameters][:SPE_PARTNER].to_i rescue 0

        parameters[:parameters].delete(:SPE_PARTNER)

      end

 

      ep = @handler_endpoint.is_a?(Array) ? @handler_endpoint[whichep] : @handler_endpoint

      gw, op = ep.split('#',2)

      pr, gw = gw.split(/:\/\//)

      pr, gw = 'xmpp-w', pr if gw.nil?

 

      doc = XML::Smart.open_unprotected(::File.dirname(__FILE__) + '/template_req.xml')

      doc.register_namespace 'g', 'http://www.fp7-adventure.eu/xmlSchema/Gateways/'

 

      doc.find("/g:gatewayRequest/g:header/g:operationName").each { |e| e.text = op }

      doc.find("/g:gatewayRequest/g:header/g:interactionType").each { |e| e.text = 'asynchronous' }

 

      doc.find("/g:gatewayRequest/g:payload").each do |e|

        parameters[:parameters].each do |k,v|

          tmp = JSON.parse(v) rescue v

          if tmp.is_a?(Hash) || tmp.is_a?(Array)

           e.add("g:inputParameter", XmlSimple.xml_out(tmp,'keeproot'=>''), 'encoding' => 'false', 'paramName' => k)

          else

            e.add("g:inputParameter", v, 'encoding' => 'false', 'paramName' => k)

          end  

        end

      end

 

      result = {}

 

      if pr == 'xmpp-p'

        pr = 'xmpp-r'

        gw = '[email protected]'

      end

 

      if pr == 'xmpp-r'

        client = Riddl::Client.interface('xmpp://' + gw, ::File.dirname(__FILE__) + '/gateway.xml', :xmpp => @controller.xmpp)

 

        callback = Digest::MD5.hexdigest(Kernel::rand().to_s)

        @controller.callbacks[callback] = CPEE::Callback.new("callback activity: #{@handler_position}",self,:callback,nil,nil,:xmpp)

        @handler_passthrough = callback

 

        params = []

        params << Riddl::Header.new("CPEE_BASE",@controller.base_jid)

        params << Riddl::Header.new("CPEE_INSTANCE",@controller.instance_jid)

        params << Riddl::Header.new("CPEE_CALLBACK",@controller.instance_jid + '/callbacks/' + callback)

        params << Riddl::Parameter::Complex.new("gatewayRequest","text/xml",doc.to_s)

 

        status, result, headers = client.post params

 

        raise "Could not reach #{ep}" unless status == 200

      else #{{{

        msg = AdvStanza.new

        msg.to = gw

        msg.body = doc.root.dump

 

        handlers = handler = nil

        handler = Proc.new do |raw|

          begin

            bd = raw.body.gsub(/<\?[^?]+\?>/,'')

            doc = XML::Smart::string(bd)

            if doc.find('string(/advmsg/responseto)') == msg.id

              callback([ Riddl::Parameter::Complex.new('gatewayResponse','text/xml',StringIO.new(doc.find('/advmsg/advbody/*').first.dump)) ])

              handlers.delete_if{|g,h| h == handler} unless @handler_another

            end

          rescue => e

            @handler_continue.continue WEEL::Signal::Error, "xmpp-w:// problem: #{e}."

          end

        end

        handlers = @controller.xmpp.register_handler(:message,&handler)

        @controller.xmpp.write msg

      end #}}}

    end

  end # }}}

 

  def activity_result_value # {{{

    @handler_returnValue

  end # }}}

  def activity_result_status # {{{

    WEEL::Status.new(1, "everything okay")

  end # }}}

 

  def activity_stop # {{{

    unless @handler_passthrough.nil?

      # delete callback and passthrough

      # when engine is restarted new callbacks have to be established

      # passthrough is set to nil, as continuation is not supported right now

      @controller.notify("semantic/alert", :endpoint => @handler_endpoint, :instance => @controller.instance, :activity => @handler_position, :alert => "The instance stopped." )

      @controller.callbacks.delete(@handler_passthrough)

      @handler_passthrough = nil

    end

  end # }}}

  def activity_passthrough_value # {{{

    @handler_passthrough

  end # }}}

 

  def activity_no_longer_necessary # {{{

    true

  end # }}}

 

  def inform_activity_done # {{{

    @controller.notify("running/activity_done", :endpoint => @handler_endpoint, :instance => @controller.instance, :activity => @handler_position)

  end # }}}

  def inform_activity_manipulate # {{{

    @controller.notify("running/activity_manipulating", :endpoint => @handler_endpoint, :instance => @controller.instance, :activity => @handler_position)

  end # }}}

  def inform_activity_failed(err) # {{{

    puts err.message

    puts err.backtrace

    @controller.notify("running/activity_failed", :endpoint => @handler_endpoint, :instance => @controller.instance, :activity => @handler_position, :message => err.message, :line => err.backtrace[0].match(/(.*?):(\d+):/)[2], :where => err.backtrace[0].match(/(.*?):(\d+):/)[1])

  end # }}}

 

  def inform_syntax_error(err,code)# {{{

    puts err.message

    puts err.backtrace

    @controller.notify("properties/description/error", :instance => @controller.instance, :message => err.message)

  end# }}}

  def inform_manipulate_change(status,changed_dataelements,changed_endpoints,dataelements,endpoints) # {{{

    unless status.nil?

      @controller.serialize_status!

      @controller.notify("properties/status/change", :endpoint => @handler_endpoint, :instance => @controller.instance, :activity => @handler_position, :id => status.id, :message => status.message)

    end

    unless changed_dataelements.nil?

      @controller.serialize_dataelements!

      @controller.notify("properties/dataelements/change", :endpoint => @handler_endpoint, :instance => @controller.instance, :activity => @handler_position, :changed => Hash[changed_dataelements.map{|e| [e,dataelements[e]]}] )

 

      changed_dataelements.each do |de|

        doc = XML::Smart.open_unprotected(::File.dirname(__FILE__) + '/../resources/topics.xml')

        doc.register_namespace 't', 'http://riddl.org/ns/common-patterns/notifications-producer/1.0'

        doc.find('/t:topics/t:topic[@id="semantic"]/t:event').each do |a|

          ann = "##{a.text}"

          if dataelements[:ANNOTATIONS][de.to_s] =~ /#{ann}/

            plain = ann.gsub(/[^a-zA-Z0-9]/,'')

            @controller.notify("semantic/#{plain}", :endpoint => @handler_endpoint, :instance => @controller.instance, :activity => @handler_position, plain => dataelements[de])

          end

        end

      end

    end

    unless changed_endpoints.nil?

      @controller.serialize_endpoints!

      @controller.notify("properties/endpoints/change", :endpoint => @handler_endpoint, :instance => @controller.instance, :activity => @handler_position, :changed => Hash[changed_endpoints.map{|e| [e,endpoints[e]]}] )

    end

  end # }}}

  def inform_position_change(ipc={}) # {{{

    @controller.serialize_positions!

    ipc[:instance] = @controller.instance

    @controller.notify("properties/position/change", ipc)

  end # }}}

  def inform_state_change(newstate) # {{{

    if @controller

      @controller.serialize_state!

      @controller.notify("properties/state/change", :info => @controller.info, :instance => @controller.instance, :state => newstate)

    end

  end # }}}

 

  def vote_sync_after # {{{

    @controller.call_vote("running/syncing_after", :endpoint => @handler_endpoint, :instance => @controller.instance, :activity => @handler_position)

  end # }}}

  def vote_sync_before(parameters=nil) # {{{

    @controller.call_vote("running/syncing_before", :endpoint => @handler_endpoint, :instance => @controller.instance, :activity => @handler_position)

  end # }}}

 

  def callback(result) #{{{

    if result.length == 1 && result[0].is_a?(Riddl::Parameter::Complex) && result[0].mimetype == 'text/xml' && result[0].name == 'gatewayResponse'

      res = {}

      begin

        doc = XML::Smart::string(result[0].value.read)

        doc.register_namespace 'r', 'http://www.fp7-adventure.eu/xmlSchema/Gateways/'

        if doc.find("count(/r:gatewayResponse/r:payload/r:outputData[@paramName='summary'])") == 0

          @handler_another = false

          @handler_returnValue = nil

          @controller.callbacks.delete(@handler_passthrough)

          @handler_passthrough = nil

          @handler_continue.continue

        else  

          doc.find("/r:gatewayResponse/r:payload/r:outputData[@paramName='summary']").each do |e|

            if e.text_only?

              sum = XML::Smart::string(e.text)

              sum.root.namespaces.add(nil,'http://www.fp7-adventure.eu/xmlSchema/Gateways/')

            else

              sum = e.children.first.to_doc

            end  

            sum.register_namespace 'r', 'http://www.fp7-adventure.eu/xmlSchema/Gateways/'

            sum.find("/r:summary/r:info/r:info").each do |i|

              res[i.attributes['name'].downcase] = i.attributes['value']

              res[i.attributes['name'].downcase] = (Float(res[i.attributes['name'].downcase]) rescue res[i.attributes['name'].downcase])

            end

            @controller.notify("running/activity_receiving", :instance => @controller.instance, :activity => @handler_position, :endpoint => @handler_endpoint, :result => JSON.generate(res))

            if doc.find('string(/r:gatewayResponse/r:header/r:commandSequence)') == 'INTERMEDIATE'

              @handler_another = true

              @handler_returnValue = res

              @controller.notify("properties/handlerwrapper/result", :instance => @controller.instance, :activity => @handler_position, :endpoint => @handler_endpoint, :result => JSON.generate(@handler_returnValue) )

              @handler_continue.continue WEEL::Signal::Again

            else  

              @handler_another = false

              @handler_returnValue = res

              @controller.callbacks.delete(@handler_passthrough)

              @handler_passthrough = nil

              @controller.notify("properties/handlerwrapper/result", :instance => @controller.instance, :activity => @handler_position, :endpoint => @handler_endpoint, :result => JSON.generate(@handler_returnValue) )

              @handler_continue.continue

            end  

          end

        end

      rescue => err

        @handler_continue.continue WEEL::Signal::Error, "Your gateway returns a gatewayResponse that doesn't conform to the specification."

      end

    else

      @handler_continue.continue WEEL::Signal::Error, "Your gateway sends a response that I don't understand. It should have one part, content-type text/xml and be called gatewayResponse."

    end

   end #}}}

 

  def simulate(type,nesting,sequence,parent,parameters={}) #{{{

    @controller.notify("simulating/step",

      :instance => @controller.instance,

      :sequence => sequence,

      :type => type,

      :nesting => nesting,

      :parent => parent,

      :parameters => parameters

    )

  end #}}}

 

  #def test_condition(mr,code) #{{{

  #  p 'test condition ------------------------------------------------------------------------'

  #  client = Riddl::Client.new("http://localhost:9292",nil)

  #  resource = client.resource('/')

 

  #  status, res = resource.post [

  #    Riddl::Parameter::Simple.new("dataelements", JSON::generate(mr.data)),

  #    Riddl::Parameter::Simple.new("endpoints", JSON::generate(mr.endpoints)),

  #    Riddl::Parameter::Simple.new("resultname", "result"),

  #    Riddl::Parameter::Simple.new("resultvalue", JSON::generate([])),

  #    Riddl::Parameter::Simple.new("code", code)

  #  ]

 

  #  mval = nil

  #  if status == 200

  #    id = res[0].value

 

  #    resource = client.resource('/' + id)

  #    status, res = resource.get

  #    if status == 200

  #      mval = JSON::parse(res[0].value)

  #    else

  #      raise 'condition exec error B'

  #    end

  #  else

  #    raise 'condition exec error A'

  #  end

 

  #  mval["output"]

  #end #}}}

  def manipulate(mr,code,result=nil,status=nil) #{{{

    client = Riddl::Client.new("http://fp7-adventure.eu:9292",nil)

    resource = client.resource('/')

 

    od = JSON::generate(mr.original_data)

    oe = JSON::generate(mr.original_endpoints)

    ood = JSON::parse(od)

    ooe = JSON::parse(oe)

 

    status, res = resource.post [

      Riddl::Parameter::Simple.new("dataelements", od),

      Riddl::Parameter::Simple.new("endpoints", oe),

      Riddl::Parameter::Simple.new("resultname", "result"),

      Riddl::Parameter::Simple.new("resultvalue", result.nil? ? '{}' : JSON::generate(result)),

      Riddl::Parameter::Simple.new("code", code)

    ]  

 

    mval = nil

    if status == 200

      id = res[0].value

 

      begin

        resource = client.resource('/' + id)

        status, res = resource.get

        if status == 200

          mval = JSON::parse(res[0].value)

        else

          raise 'script exec error B'

        end

        sleep 1 unless mval['state'] == 'executed'

      end until mval['state'] == 'executed'

    else

      raise 'script exec error A'

    end

 

    mval['dataelements'].each do |k,v|

      if ood[k] != v

        mr.data.send(k+'=',v)

      end

    end

    mval['endpoints'].each do |k,v|

      if ooe[k] != v

        mr.endpoints.send(k+'=',v)

      end

    end

    if mval['status'].is_a?(Hash)

      if mr.status.id != mval['status']['id'].to_i

        mr.status.update(mval['status']['id'].to_i,mval['status']['message'])

        if mval['status']['id'].to_i == -1

          raise mval['status']['message']

        end

      end

    end

  end #}}}

end