class Aws::Record::BatchRead

def build_item(item, item_class)
  new_item_opts = {}
  item.each do |db_name, value|
    name = item_class.attributes.db_to_attribute_name(db_name)
    next unless name
    new_item_opts[name] = value
  end
  item = item_class.new(new_item_opts)
  item.clean!
  item
end

def build_items(item_responses)
  new_items = []
  item_responses.each do |table, unprocessed_items|
    unprocessed_items.each do |item|
      item_class = find_item_class(table, item)
      if item_class.nil? && @client.config.logger
        @client.config.logger.warn(
          'Unexpected response from service.' \
          "Received: #{item}. Skipping above item and continuing"
        )
      else
        new_items << build_item(item, item_class)
      end
    end
  end
  new_items
end

def build_operations(keys)
  operations = Hash.new { |h, k| h[k] = { keys: [] } }
  keys.each do |key|
    operations[key[:table_name]][:keys] << key[:keys]
  end
  operations
end

def complete?
  unprocessed_keys.none?
end

def contains_keys?(item, keys)
  item.merge(keys) == item
end

def each(&block)
  return enum_for(:each) unless block_given?
  @items.each(&block)
  until complete?
    new_items = execute!
    new_items.each(&block)
  end
end

def execute!
  operation_keys = unprocessed_keys[0..BATCH_GET_ITEM_LIMIT - 1]
  @unprocessed_keys = unprocessed_keys[BATCH_GET_ITEM_LIMIT..] || []
  operations = build_operations(operation_keys)
  result = @client.batch_get_item(request_items: operations)
  new_items = build_items(result.responses)
  items.concat(new_items)
  update_unprocessed_keys(result.unprocessed_keys) unless result.unprocessed_keys.nil?
  new_items
end

def find(klass, key = {})
  unprocessed_key = format_unprocessed_key(klass, key)
  store_unprocessed_key(klass, unprocessed_key)
  store_item_class(klass, unprocessed_key)
end

def find_item_class(table, item)
  selected_item = item_classes[table].find { |item_info| contains_keys?(item, item_info[:keys]) }
  selected_item[:class] if selected_item
end

def format_unprocessed_key(klass, key)
  item_key = {}
  attributes = klass.attributes
  klass.keys.each_value do |attr_sym|
    raise Errors::KeyMissing, "Missing required key #{attr_sym} in #{key}" unless key[attr_sym]
    attr_name = attributes.storage_name_for(attr_sym)
    item_key[attr_name] = attributes.attribute_for(attr_sym)
                                    .serialize(key[attr_sym])
  end
  item_key
end

def initialize(opts = {})
  @client = opts[:client]
end

def item_classes
  @item_classes ||= Hash.new { |h, k| h[k] = [] }
end

def items
  @items ||= []
end

def store_item_class(klass, key)
  if item_classes.include?(klass.table_name)
    item_classes[klass.table_name].each do |item|
      if item[:keys] == key && item[:class] != klass
        raise ArgumentError, 'Provided item keys is a duplicate request'
      end
    end
  end
  item_classes[klass.table_name] << { keys: key, class: klass }
end

def store_unprocessed_key(klass, unprocessed_key)
  unprocessed_keys << { keys: unprocessed_key, table_name: klass.table_name }
end

def unprocessed_keys
  @unprocessed_keys ||= []
end

def update_unprocessed_keys(keys)
  keys.each do |table_name, table_values|
    table_values.keys.each do |key| # rubocop:disable Style/HashEachMethods
      unprocessed_keys << { keys: key, table_name: table_name }
    end
  end
end