module Jekyll::Algolia::Indexer

def self.execute_operations(operations)
  return if Configurator.dry_run?
  return if operations.empty?
  # Run the batches in slices if they are too large
  batch_size = Configurator.algolia('indexing_batch_size')
  slices = operations.each_slice(batch_size).to_a
  should_have_progress_bar = (slices.length > 1)
  if should_have_progress_bar
    progress_bar = ProgressBar.create(
      total: slices.length,
      format: 'Updating index (%j%%) |%B|'
    )
  end
  slices.each do |slice|
    begin
      ::Algolia.batch!(slice)
      progress_bar.increment if should_have_progress_bar
    rescue StandardError => error
      ErrorHandler.stop(error, operations: slice)
    end
  end
end

def self.index
  @index
end

def self.index_exist?(index)
  index.get_settings
  true
rescue StandardError
  false
end

def self.index_object_ids
  @index_object_ids
end

def self.init
  ::Algolia.init(
    application_id: Configurator.application_id,
    api_key: Configurator.api_key
  )
  index_name = Configurator.index_name
  @index = ::Algolia::Index.new(index_name)
  index_object_ids_name = Configurator.index_object_ids_name
  @index_object_ids = ::Algolia::Index.new(index_object_ids_name)
  set_user_agent
  self
end

def self.local_object_ids(records)
  records.map { |record| record[:objectID] }.compact.sort
end

def self.local_setting_id
  settings = Configurator.settings
  settings.delete('userData')
  AlgoliaHTMLExtractor.uuid(settings)
end

def self.record_count(index)
  index.search(
    '',
    attributesToRetrieve: 'objectID',
    distinct: false,
    hitsPerPage: 1
  )['nbHits']
rescue StandardError
  0
end

def self.remote_object_ids
  Logger.log('I:Getting list of existing records')
  # Fast version, using the dedicated index
  has_dedicated_index = index_exist?(index_object_ids)
  return remote_object_ids_from_dedicated_index if has_dedicated_index
  # Slow version, browsing the full index
  remote_object_ids_from_main_index
end

def self.remote_object_ids_from_dedicated_index
  list = []
  begin
    index_object_ids.browse(
      attributesToRetrieve: 'content',
      hitsPerPage: 1000
    ) do |hit|
      list += hit['content']
    end
  rescue StandardError
    return []
  end
  list.sort
end

def self.remote_object_ids_from_main_index
  Logger.verbose("I:Inspecting existing records in index #{index.name}")
  list = []
  # As it might take some time, we display a progress bar
  progress_bar = ProgressBar.create(
    total: record_count(index),
    format: 'Inspecting existing records (%j%%) |%B|'
  )
  begin
    index.browse(
      attributesToRetrieve: 'objectID',
      hitsPerPage: 1000
    ) do |hit|
      list << hit['objectID']
      progress_bar.increment
    end
  rescue StandardError
    return []
  end
  list.sort
end

def self.remote_settings
  index.get_settings
rescue StandardError
  nil
end

def self.run(records)
  init
  # Indexing zero record is surely a misconfiguration
  if records.length.zero?
    files_to_exclude = Configurator.algolia('files_to_exclude').join(', ')
    Logger.known_message(
      'no_records_found',
      'files_to_exclude' => files_to_exclude,
      'nodes_to_index' => Configurator.algolia('nodes_to_index')
    )
    exit 1
  end
  update_settings
  update_records(records)
  Logger.log('I:✔ Indexing complete')
end

def self.set_settings(settings)
  index.set_settings!(settings)
rescue StandardError => error
  ErrorHandler.stop(error, settings: settings)
end

def self.set_user_agent
  user_agent = [
    "Jekyll Integration (#{VERSION})",
    "Algolia for Ruby (#{::Algolia::VERSION})",
    "Jekyll (#{::Jekyll::VERSION})",
    "Ruby (#{RUBY_VERSION})"
  ].join('; ')
  ::Algolia.set_extra_header('User-Agent', user_agent)
end

def self.update_records(records)
  # Getting list of objectID in remote and locally
  remote_ids = remote_object_ids
  local_ids = local_object_ids(records)
  # Making a diff, to see what to add and what to delete
  ids_to_delete = remote_ids - local_ids
  ids_to_add = local_ids - remote_ids
  # What changes should we do to the indexes?
  has_records_to_update = !ids_to_delete.empty? || !ids_to_add.empty?
  has_dedicated_index = index_exist?(index_object_ids)
  # Stop if nothing to change
  if !has_records_to_update && has_dedicated_index
    Logger.log('I:Content is already up to date.')
    return
  end
  # We group all operations into one batch
  operations = []
  # We update records only if there are records to update
  if has_records_to_update
    Logger.log("I:Updating records in index #{index.name}...")
    Logger.log("I:Records to delete: #{ids_to_delete.length}")
    Logger.log("I:Records to add:    #{ids_to_add.length}")
    # Transforming ids into real records to add
    records_by_id = Hash[records.map { |r| [r[:objectID], r] }]
    records_to_add = ids_to_add.map { |id| records_by_id[id] }
    # Deletion operations come first, to avoid hitting an overquota too
    # soon if it can be avoided
    ids_to_delete.each do |object_id|
      operations << {
        action: 'deleteObject', indexName: index.name,
        body: { objectID: object_id }
      }
    end
    # Then we add the new records
    operations += records_to_add.map do |new_record|
      { action: 'addObject', indexName: index.name, body: new_record }
    end
  end
  # We update the dedicated index everytime we update records, but we also
  # create it if it does not exist
  should_update_dedicated_index = has_records_to_update ||
                                  !has_dedicated_index
  if should_update_dedicated_index
    operations << { action: 'clear', indexName: index_object_ids.name }
    local_ids.each_slice(100).each do |ids|
      operations << {
        action: 'addObject', indexName: index_object_ids.name,
        body: { content: ids }
      }
    end
  end
  execute_operations(operations)
end

def self.update_settings
  current_remote_settings = remote_settings || {}
  remote_setting_id = current_remote_settings.dig('userData', 'settingID')
  settings = Configurator.settings
  setting_id = local_setting_id
  are_settings_forced = Configurator.force_settings?
  # The config we're about to push is the same we pushed previously. We
  # won't push again.
  if setting_id == remote_setting_id && !are_settings_forced
    Logger.log('I:Settings are already up to date.')
    # Check if remote config has been changed outside of the plugin, so we
    # can warn users that they should not alter their config from outside
    # of the plugin.
    current_remote_settings.delete('userData')
    changed_keys = Utils.diff_keys(settings, current_remote_settings)
    unless changed_keys.nil?
      warn_of_manual_dashboard_editing(changed_keys)
    end
    return
  end
  # Settings have changed, we push them
  settings['userData'] = {
    'settingID' => setting_id,
    'pluginVersion' => VERSION
  }
  Logger.log("I:Updating settings of index #{index.name}")
  return if Configurator.dry_run?
  set_settings(settings)
end

def self.warn_of_manual_dashboard_editing(changed_keys)
  # Transform the hash into readable YAML
  yaml_lines = changed_keys
               .to_yaml(indentation: 2)
               .split("\n")[1..-1]
  yaml_lines.map! do |line|
    line = line.gsub(/^ */) { |spaces| ' ' * spaces.length }
    line = line.gsub('- ', '  - ')
    "W:    #{line}"
  end
  Logger.known_message(
    'settings_manually_edited',
    settings: yaml_lines.join("\n")
  )
end