class Bundler::ParallelInstaller

def self.call(*args)
  new(*args).call
end

def self.max_threads
  [Bundler.settings[:jobs].to_i - 1, 1].max
end

def call
  # Since `autoload` has the potential for threading issues on 1.8.7
  # TODO:  remove in bundler 2.0
  require "bundler/gem_remote_fetcher" if RUBY_VERSION < "1.9"
  check_for_corrupt_lockfile
  enqueue_specs
  process_specs until @specs.all?(&:installed?) || @specs.any?(&:failed?)
  handle_error if @specs.any?(&:failed?)
  @specs
ensure
  worker_pool && worker_pool.stop
end

def check_for_corrupt_lockfile
  missing_dependencies = @specs.map do |s|
    [
      s,
      s.missing_lockfile_dependencies(@specs.map(&:name)),
    ]
  end.reject { |a| a.last.empty? }
  return if missing_dependencies.empty?
  warning = []
  warning << "Your lockfile was created by an old Bundler that left some things out."
  if @size != 1
    warning << "Because of the missing DEPENDENCIES, we can only install gems one at a time, instead of installing #{@size} at a time."
    @size = 1
  end
  warning << "You can fix this by adding the missing gems to your Gemfile, running bundle install, and then removing the gems from your Gemfile."
  warning << "The missing gems are:"
  missing_dependencies.each do |spec, missing|
    warning << "* #{missing.map(&:name).join(", ")} depended upon by #{spec.name}"
  end
  Bundler.ui.warn(warning.join("\n"))
end

def enqueue_specs
  @specs.select(&:ready_to_enqueue?).each do |spec|
    if spec.dependencies_installed? @specs
      spec.state = :enqueued
      worker_pool.enq spec
    end
  end
end

def handle_error
  errors = @specs.select(&:failed?).map(&:error)
  if exception = errors.find {|e| e.is_a?(Bundler::BundlerError) }
    raise exception
  end
  raise Bundler::InstallError, errors.map(&:to_s).join("\n\n")
end

def initialize(installer, all_specs, size, standalone, force)
  @installer = installer
  @size = size
  @standalone = standalone
  @force = force
  @specs = all_specs.map {|s| SpecInstallation.new(s) }
end

def process_specs
  spec = worker_pool.deq
  spec.state = :installed unless spec.failed?
  enqueue_specs
end

def worker_pool
  @worker_pool ||= Bundler::Worker.new @size, "Parallel Installer", lambda { |spec_install, worker_num|
    gem_installer = Bundler::GemInstaller.new(
      spec_install.spec, @installer, @standalone, worker_num, @force
    )
    success, message = gem_installer.install_from_spec
    if success && !message.nil?
      spec_install.post_install_message = message
    elsif !success
      spec_install.state = :failed
      spec_install.error = message
    end
    spec_install
  }
end