class HTMLProofer::Runner

def before_request(&block)
  @before_request ||= []
  @before_request << block if block
  @before_request
end

def check_files
  process_files.each do |result|
    URL_TYPES.each do |url_type|
      type = :"#{url_type}_urls"
      ivar_name = "@#{type}"
      ivar = instance_variable_get(ivar_name)
      if ivar.empty?
        instance_variable_set(ivar_name, result[type])
      else
        result[type].each do |url, metadata|
          ivar[url] = [] if ivar[url].nil?
          ivar[url].concat(metadata)
        end
      end
    end
    @failures.concat(result[:failures])
  end
  validate_external_urls unless @options[:disable_external]
  validate_internal_urls
end

def check_list_of_links
  @external_urls = @source.uniq.each_with_object({}) do |link, hash|
    url = Attribute::Url.new(self, link, base_url: nil).to_s
    hash[url] = []
  end
  validate_external_urls
end

def check_parsed(path, source)
  result = { internal_urls: {}, external_urls: {}, failures: [] }
  checks.each do |klass|
    @current_source = source
    @current_filename = path
    check = Object.const_get(klass).new(self, @html)
    @logger.log(:debug, "Running #{check.short_name} in #{path}")
    @current_check = check
    check.run
    result[:external_urls].merge!(check.external_urls) { |_key, old, current| old.concat(current) }
    result[:internal_urls].merge!(check.internal_urls) { |_key, old, current| old.concat(current) }
    result[:failures].concat(check.failures)
  end
  result
end

def check_sri?
  @options[:check_sri]
end

def checks
  return @checks if defined?(@checks) && !@checks.nil?
  return (@checks = ["LinkCheck"]) if @type == :links
  @checks = HTMLProofer::Check.subchecks(@options).map(&:name)
  @checks
end

def enforce_https?
  @options[:enforce_https]
end

def failed_checks
  @reporter.failures.flatten.select { |f| f.is_a?(Failure) }
end

def files
  @files ||= if @type == :directory
    @source.map do |src|
      pattern = File.join(src, "**", "*{#{@options[:extensions].join(",")}}")
      Dir.glob(pattern).select do |f|
        File.file?(f) && !ignore_file?(f)
      end.map { |f| { source: src, path: f } }
    end.flatten
  elsif @type == :file && @options[:extensions].include?(File.extname(@source))
    [@source].reject { |f| ignore_file?(f) }.map { |f| { source: f, path: f } }
  else
    []
  end
end

def format_checks_list(checks)
.map do |check|
k.sub("HTMLProofer::Check::", "")
rt.join(", ")

def ignore_file?(file)
  @options[:ignore_files].each do |pattern|
    if pattern.is_a?(String) && pattern == file
      @logger.log(:debug, "Ignoring #{file} because it matches #{pattern}")
      return true
    end
    next unless pattern.is_a?(Regexp) && pattern.match(file)
    @logger.log(:debug, "Ignoring #{file} because it matches regexp #{pattern}")
    return true
  end
  false
end

def initialize(src, opts = {})
  @options = HTMLProofer::Configuration.generate_defaults(opts)
  @type = @options.delete(:type)
  @source = src
  @logger = HTMLProofer::Log.new(@options[:log_level])
  @cache = Cache.new(self, @options[:cache])
  @external_urls = {}
  @internal_urls = {}
  @failures = []
  @before_request = []
  @resolved_paths = {}
  @current_check = nil
  @current_source = nil
  @current_filename = nil
  @reporter = Reporter::Terminal.new(logger: @logger)
end

def load_cache(type)
 instance_variable_get(:"@#{type}_urls")
ng_urls_count = @cache.size(type)
text = pluralize(existing_urls_count, "#{type} link", "#{type} links")
r.log(:debug, "Found #{cache_text} in the cache")
o_check = @cache.retrieve_urls(ivar, type)
o_check

def load_external_cache
  load_cache(:external)
end

def load_file(path, source)
  @html = create_nokogiri(path)
  check_parsed(path, source)
end

def load_internal_cache
  load_cache(:internal)
end

def process_files
  loaded_files = []
  files.each do |file|
    Async do |task|
      task.async do
        loaded_files << load_file(file[:path], file[:source])
      end
    end
  end
  loaded_files
end

def report_failed_checks
  @reporter.report
  failure_text = pluralize(@failures.length, "failure", "failures")
  @logger.log(:fatal, "\nHTML-Proofer found #{failure_text}!")
  exit(1)
end

def run
  check_text = pluralize(checks.length, "check", "checks")
  if @type == :links
    @logger.log(:info, "Running #{check_text} (#{format_checks_list(checks)}) on #{@source} ...\n\n")
    check_list_of_links unless @options[:disable_external]
  else
    @logger.log(
      :info,
      "Running #{check_text} (#{format_checks_list(checks)}) in #{@source} on *#{@options[:extensions].join(", ")} files ...\n\n",
    )
    check_files
    @logger.log(:info, "Ran on #{pluralize(files.length, "file", "files")}!\n\n")
  end
  @cache.write
  @reporter.failures = @failures
  if @failures.empty?
    @logger.log(:info, "HTML-Proofer finished successfully.")
  else
    @failures.uniq!
    report_failed_checks
  end
end

def validate_external_urls
  external_url_validator = HTMLProofer::UrlValidator::External.new(self, @external_urls)
  external_url_validator.before_request = @before_request
  @failures.concat(external_url_validator.validate)
end

def validate_internal_urls
  internal_link_validator = HTMLProofer::UrlValidator::Internal.new(self, @internal_urls)
  @failures.concat(internal_link_validator.validate)
end