module Jekyll::Algolia::FileBrowser

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

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

def self.categories(file)
  file.data['categories'] || []
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)
  # Collections get their date from .date, while pages read it from .data.
  # Jekyll by default will set the date of collection to the current date,
  # but we overwrote this.
  date = if file.respond_to?(:date)
           file.date
         else
           file.data['date']
         end
  return nil if date.nil?
  date.to_time.to_i
end

def self.excerpt_html(file)
  # If it's a post with a custom separator for the excerpt, we honor it
  return excerpt_raw(file) if use_default_excerpt?(file)
  # Otherwise we take the first matching node
  html = file.content
  selector = Configurator.algolia('nodes_to_index')
  first_node = Nokogiri::HTML(html).css(selector).first
  return nil if first_node.nil?
  first_node.to_s
end

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

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

def self.excluded_from_config?(file)
  excluded_patterns = Configurator.algolia('files_to_exclude')
  jekyll_source = Configurator.get('source')
  path = absolute_path(file.path)
  excluded_patterns.each do |pattern|
    pattern = File.expand_path(File.join(jekyll_source, pattern))
    return true if File.fnmatch(pattern, path, File::FNM_PATHNAME)
  end
  false
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 redirect?(file)
  return false unless allowed_extension?(file)
  return false if excluded_from_config?(file)
  return false if excluded_from_hook?(file)
  true
end

def self.is_404?(file)
  ['404.md', '404.html'].include?(File.basename(file.path))
end

def self.metadata(file)
  raw_data = raw_data(file)
  specific_data = {
    collection: collection(file),
    tags: tags(file),
    categories: categories(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.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
  data.delete('excerpt')
  # Delete other keys added by Jekyll that are not in the front-matter and
  # not needed for search
  data.delete('draft')
  data.delete('ext')
  # Convert all values to a version that can be serialized to JSON
  data = Utils.jsonify(data)
  # Convert all keys to symbols
  data = Utils.keys_to_symbols(data)
  data
end

def self.redirect?(file)
  file.respond_to?(:name) && file.name == 'redirect.html'
end

def self.relative_path(filepath)
  pathname = Pathname.new(filepath)
  config_source = Configurator.get('source') || ''
  jekyll_source = Pathname.new(File.expand_path(config_source))
  # Removing any starting ./
  if pathname.relative?
    fullpath = File.expand_path(File.join(jekyll_source, pathname))
    return fullpath.gsub(%r{^#{jekyll_source}/}, '')
  end
  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.tags(file)
  file.data['tags'] || []
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

def self.use_default_excerpt?(file)
  # Only posts can have excerpt
  return false unless type(file) == 'post'
  # User defined their own separator in the config
  custom_separator = file.excerpt_separator.to_s.strip
  return false if custom_separator.empty?
  # This specific post contains this separator
  file.content.include?(custom_separator)
end