class ManageIQ::Providers::AwesomeCloud::CloudManager::EventCatcher < ManageIQ::Providers::BaseManager::EventCatcher
  require_nested :Runner
end

class ManageIQ::Providers::AwesomeCloud::CloudManager::EventCatcher::Runner < ManageIQ::Providers::BaseManager::EventCatcher::Runner
  # This is the main method run in the first thread by the core event catcher runner.
  # It is responsible for retrieving events from the provider and putting them on
  # an internal queue for the core runner thread to parse and put on MiqQueue.
  def monitor_events
    # Start up our event monitor
    event_monitor_handle.start

    # Tell the core runner thread that the event monitor is started.  The worker
    # won't be marked as "running" until this happens.
    event_monitor_running

    # And finally poll for events.  This should be implemented as a blocking method
    # which yields events caught from the provider
    event_monitor_handle.poll do |event|
      @queue.enq(event)
    end
  ensure
    stop_event_monitor
  end

  # This method is called by core when shutting down the event catcher
  def stop_event_monitor
    event_monitor_handle.stop
  end

  # This is called by the core runner thread to parse and put the event on the queue.
  def queue_event(event)
    event_hash = ManageIQ::Providers::AwesomeCloud::CloudManager::EventParser.event_to_hash(event, @cfg[:ems_id])
    EmsEvent.add_queue('add', @cfg[:ems_id], event_hash)
  end

  private

  # The Stream class isn't a requirement but helps to encapsulate the logic of
  # fetching events from the provider.
  def event_monitor_handle
    @event_monitor_handle ||= begin
      self.class.module_parent::Stream.new
    end
  end
end

class ManageIQ::Providers::AwesomeCloud::CloudManager::EventCatcher::Stream
  attr_reader :ems, :stop_polling, :poll_sleep

  def initialize(ems, options = {})
    @ems = ems
    @stop_polling = false
    @poll_sleep = options[:poll_sleep] || 20.seconds
  end

  def start
    @stop_polling = false
  end

  def stop
    @stop_polling = true
  end

  def poll
    since = nil

    loop do
      ems.with_provider_connection(:service => "Events") do |events_client|
        # Replace with your provider's events API
        events = events_client.get_events(:since => since)
        since = Time.now.utc

        break if stop_polling

        events.each { |event| yield event }
      end
      sleep(poll_sleep)
    end
  end
end

module ManageIQ::Providers::AwesomeCloud::CloudManager::EventParser
  def self.event_to_hash(event, ems_id)
    event_hash = {
      :event_type => event[:event_name],
      :source     => "AWESOME_CLOUD",
      :ems_ref    => event[:id],
      :timestamp  => event[:time],
      :full_data  => event,  # Make sure this serializes properly and isn't dumping a native object
    }

    # Parse any additional information e.g. instances, images, etc...
    case event_hash[:event_type]
    when /com.awesome-cloud.vm/
      parse_vm_event!(event, event_hash)
    end

    event_hash
  end

  def self.parse_vm_event!(event, event_hash)
    return if event[:vm].nil?

    # The uid_ems/ems_ref should match the attributes that you set in the inventory
    # parser since they will be used to lookup the VM object by the MiqEventHandler
    event_hash[:vm_uid_ems] = event.dig(:vm, :id)
    event_hash[:vm_ems_ref] = event.dig(:vm, :id)
    event_hash[:vm_name]    = event.dig(:vm, :name)
  end
end

class ManageIQ::Providers::AwesomeCloud::CloudManager::EventTargetParser
  attr_reader :ems_event

  def initialize(ems_event)
    @ems_event = ems_event
  end

  def parse
    target_collection = InventoryRefresh::TargetCollection.new(
      :manager => ems_event.ext_management_system,
      :event   => ems_event
    )

    raw_event = ems_event.full_data

    if raw_event[:vm]
      target_collection.add_target(:association => :vms, :manager_ref => {:ems_ref => raw_event[:vm][:id])
    end

    # Add in other resource types that you might want to handle here

    # Return the set of targets from this event
    target_collection.targets
  end
end