module NulogyMessageBusProducer
  # Configuration for the gem
  class Config
    FAILURE_MODES = [:raise, :soft_fail].freeze

    attr_reader :registered_schemas
    attr_reader :configured_subscriptions
    attr_writer :context_for_subscription

    def initialize(options = {})
      @registered_schemas = {}
      @configured_subscriptions = []

      producing_events_fails_with(:raise)

      update(options)
    end

    def context_for_subscription(subscription)
      @context_for_subscription ||= ->(_) {}
      @context_for_subscription.call(subscription)
    end

    def register_schema(schema:, key:)
      @registered_schemas[key] = schema
    end

    def producing_events_fails_with(mode, &block)
      @event_error_handler =
        case mode
        when :raise
          method(:raise_handler)
        when :soft_fail
          block || ->(_) {}
        else
          unknown_mode_error(mode)
        end
    end

    def handle_event_generation_error(subscription_id:, context:, variables:, result:)
      @event_error_handler.call(
        subscription_id: subscription_id,
        context: context,
        variables: variables,
        result: result
      )
    end

    def update(options = {})
      options.each { |key, value| public_send("#{key}=", value) }
    end

    def add_subscription!(schema:, query:)
      @configured_subscriptions ||= []

      schema_key = NulogyMessageBusProducer.resolve_schema_key(schema)
      query_parser = Configuration::QueryParser.new(query)
      subscription = Subscriptions::ConfiguredSubscription.new(
        id: query_parser.subscription_id,
        subscription_group_id: query_parser.subscription_group_id,
        schema_key: schema_key,
        event_type: query_parser.event_type,
        topic_name: query_parser.topic,
        query: query
      )

      if subscription.valid?
        @configured_subscriptions << subscription
        subscription
      else
        raise ArgumentError, subscription.errors.full_messages
      end
    end

    private

    def raise_handler(subscription_id:, context:, variables:, result:)
      raise StandardError, <<~MESSAGE
        A subscription event could not be produced for subscription #{subscription_id}

        The GraphQL engine returned this response:

        #{result.to_h}

        context: #{context.inspect}
        variables: #{variables.inspect}
      MESSAGE
    end

    def unknown_mode_error(mode)
      options = FAILURE_MODES.map(&:inspect).join(", ")

      raise ArgumentError, "The failure mode `#{mode}` is not valid. The modes are: #{options}."
    end
  end
end