module Jekyll::Algolia::FileBrowser

def self.absolute_path(file)
  pathname = Pathname.new(file.path)
  return pathname.cleanpath.to_s if pathname.absolute?
  File.join(Configurator.get('source'), file.path)
end

def self.allowed_extension?(file)
  extensions = Configurator.algolia('extensions_to_index')
  extname = File.extname(file.path)[1..-1]
  extensions.include?(extname)
end

def self.collection(file)
  return nil unless file.respond_to?(:collection)
  collection_name = file.collection.label
  # Posts are a special kind of collection, but it's an implementation
  # detail from my POV, so I'll exclude them
  return nil if collection_name == 'posts'
  collection_name
end

def self.date(file)
  date = file.data['date']
  return nil if date.nil?
  # The date is *exactly* the time where the `jekyll algolia` was run.
  # What a coincidence! It's a safe bet to assume that the original date
  # was nil and has been overwritten by Jekyll
  return nil if date.to_i == Jekyll::Algolia.start_time.to_i
  date.to_i
end

def self.excerpt_html(file)
  excerpt = excerpt_raw(file)
  return nil if excerpt.nil?
  return nil if excerpt.empty?
  excerpt.to_s.tr("\n", ' ').strip
end

def self.excerpt_raw(file)
  Logger.silent do
    return file.data['excerpt'].to_s
  end
rescue StandardError
  return nil
end

def self.excerpt_text(file)
  html = excerpt_html(file)
  Utils.html_to_text(html)
end

def self.excluded_by_user?(file)
  excluded_from_config?(file) || excluded_from_hook?(file)
end

def self.excluded_from_config?(file)
  excluded_patterns = Configurator.algolia('files_to_exclude')
  jekyll_source = Configurator.get('source')
  # Transform the glob patterns into a real list of files
  excluded_files = []
  Dir.chdir(jekyll_source) do
    excluded_patterns.each do |pattern|
      Dir.glob(pattern).each do |match|
        excluded_files << File.expand_path(match)
      end
    end
  end
  excluded_files.include?(absolute_path(file))
end

def self.excluded_from_hook?(file)
  Hooks.should_be_excluded?(file.path)
end

def self.indexable?(file)
  return false if static_file?(file)
  return false if is_404?(file)
  return false if pagination_page?(file)
  return false unless allowed_extension?(file)
  return false if excluded_by_user?(file)
  true
end

def self.is_404?(file)
  File.basename(file.path, File.extname(file.path)) == '404'
end

def self.metadata(file)
  raw_data = raw_data(file)
  specific_data = {
    collection: collection(file),
    date: date(file),
    excerpt_html: excerpt_html(file),
    excerpt_text: excerpt_text(file),
    slug: slug(file),
    type: type(file),
    url: url(file)
  }
  metadata = Utils.compact_empty(raw_data.merge(specific_data))
  metadata
end

def self.pagination_page?(file)
  # paginate_path contains a special `:num` part that is the page number
  # We convert that to a regexp
  paginate_path = Configurator.get('paginate_path')
  paginate_path_as_regexp = paginate_path.gsub(':num', '([0-9]*)')
  regexp = %r{#{paginate_path_as_regexp}/index\.html$}
  # Make sure all file paths start with a / for comparison
  filepath = file.path
  filepath = "/#{filepath}" unless filepath[0] == '/'
  Utils.match?(filepath, regexp)
end

def self.raw_data(file)
  data = file.data.clone
  # Remove all keys where we have a specific getter
  data.each_key do |key|
    data.delete(key) if respond_to?(key)
  end
  # Also delete keys we manually handle
  data.delete('excerpt')
  # Convert all keys to symbols
  data = Utils.keys_to_symbols(data)
  data
end

def self.relative_path(file)
  pathname = Pathname.new(file.path)
  return file.path if pathname.relative?
  jekyll_source = Pathname.new(Configurator.get('source'))
  pathname.relative_path_from(jekyll_source).cleanpath.to_s
end

def self.slug(file)
  # We get the real slug from the file data if available
  return file.data['slug'] if file.data.key?('slug')
  # We create it ourselves from the filepath otherwise
  File.basename(file.path, File.extname(file.path)).downcase
end

def self.static_file?(file)
  file.is_a?(Jekyll::StaticFile)
end

def self.type(file)
  type = file.class.name.split('::')[-1].downcase
  type = 'post' if type == 'document' && file.collection.label == 'posts'
  type
end

def self.url(file)
  file.url
end