module Rage::Events

def self.__build_event_handler(event_class)
  subscriber_calls = __get_subscribers(event_class).map do |subscriber_class|
    arguments = "event"
    context_type, _ = subscriber_class.instance_method(:call).parameters.find do |param_type, param_name|
      param_name == :context || param_type == :keyrest
    end
    if context_type
      if context_type == :keyreq
        arguments += ", context: context || {}"
      else
        arguments += ", context:"
      end
    end
    if subscriber_class.__is_deferred
      "#{subscriber_class}.enqueue(#{arguments})"
    else
      "#{subscriber_class}.new.__call(#{arguments})"
    end
  end
  if subscriber_calls.empty?
    ->(_, _) {}
  else
    __event_handlers[event_class] = eval <<-RUBY
      ->(event, context) { #{subscriber_calls.join("; ")} }
    RUBY
  end
end

def self.__eager_load_subscribers
  subscribers = Dir["#{Rage.root}/app/**/*.rb"].select do |path|
    File.foreach(path).any? do |line|
      line.include?("include Rage::Events::Subscriber") || line.include?("subscribe_to")
    end
  end
  subscribers.each do |path|
    Rage.code_loader.load_file(path)
  end
rescue => e
  puts "ERROR: Failed to load an event subscriber: #{e.class} (#{e.message})."
  puts e.backtrace.join("\n")
end

def self.__event_handlers
  @__event_handlers ||= {}
end

def self.__get_subscribers(event_class)
  event_class.ancestors.take_while { |klass|
    klass != Object && klass != Data
  }.each_with_object([]) { |klass, memo|
    memo.concat(__registered_subscribers[klass]).uniq! if __registered_subscribers.has_key?(klass)
  }
end

def self.__register_subscriber(event_class, handler_class)
  __registered_subscribers[event_class] << handler_class
end

def self.__registered_subscribers
  @__registered_subscribers ||= Hash.new { |hash, key| hash[key] = [] }
end

def self.__reset_subscribers
  __registered_subscribers.clear
  __event_handlers.clear
  Rage::Events.__eager_load_subscribers
end

def self.publish(event, context: nil)
  handler = __event_handlers[event.class] || __build_event_handler(event.class)
  Rage::Telemetry.tracer.span_events_event_publish(event:, context:) do
    handler.call(event, context)
  end
  nil
end