class Berkshelf::Resolver

def [](demand)
  name = demand.respond_to?(:name) ? demand.name : demand.to_s
  demands.find { |d| d.name == name }
end

def add_demand(demand)
  if has_demand?(demand)
    raise DuplicateDemand, "A demand named '#{demand.name}' is already present."
  end
  demands.push(demand)
end

def add_explicit_dependencies(cookbook)
  graph.populate_local(cookbook)
end

def compute_solver_engine(berksfile)
  if berksfile.required_solver
    begin
      Solve.engine = berksfile.required_solver
    rescue Solve::Errors::InvalidEngine => e
      raise ArgumentError, e.message
    end
  elsif berksfile.preferred_solver
    begin
      Solve.engine = berksfile.preferred_solver
    rescue
      # We should log this, but Berkshelf.log.warn and Berkshelf.formatter.warn
      # both seem inappropriate here.
      # "  Preferred solver ':#{berksfile.preferred_solver}' unavailable"
    end
  end
  # We should log this, but Berkshelf.log.info and Berkshelf.formatter.msg
  # both seem inappropriate here.
  # "  Selected dependency solver engine ':#{Solve.engine}'"
end

def demand_array
  demands.collect do |demand|
    constraint = demand.locked_version || demand.version_constraint
    [demand.name, constraint]
  end
end

def has_demand?(demand)
  !get_demand(demand).nil?
end

def initialize(berksfile, demands = [])
  @berksfile = berksfile
  @graph     = Graph.new
  @demands   = []
  Array(demands).each { |demand| add_demand(demand) }
  compute_solver_engine(berksfile)
end

def resolve
  graph.populate_store
  graph.populate(berksfile.sources)
  Solve.it!(graph, demand_array, ENV["DEBUG_RESOLVER"] ? { ui: Berkshelf.ui } : {}).collect do |name, version|
    dependency = get_demand(name) || Dependency.new(berksfile, name)
    dependency.locked_version = version
    dependency
  end
rescue Solve::Errors::NoSolutionError => e
  raise NoSolutionError.new(demands, e)
end