class Bundler::GemVersionPromoter

def debug_format_result(dep, spec_groups)
  a = [dep.to_s,
       spec_groups.map {|sg| [sg.version, sg.dependencies_for_activated_platforms.map {|dp| [dp.name, dp.requirement.to_s] }] }]
  last_map = a.last.map {|sg_data| [sg_data.first.version, sg_data.last.map {|aa| aa.join(" ") }] }
  [a.first, last_map, level, strict ? :strict : :not_strict]
end

def either_version_older_than_locked
  @a_ver < @locked_version || @b_ver < @locked_version
end

def filter_dep_specs(spec_groups, locked_spec)
  res = spec_groups.select do |spec_group|
    if locked_spec && !major?
      gsv = spec_group.version
      lsv = locked_spec.version
      must_match = minor? ? [0] : [0, 1]
      matches = must_match.map {|idx| gsv.segments[idx] == lsv.segments[idx] }
      (matches.uniq == [true]) ? (gsv >= lsv) : false
    else
      true
    end
  end
  sort_dep_specs(res, locked_spec)
end

def initialize(locked_specs = SpecSet.new([]), unlock_gems = [])
  @level = :major
  @strict = false
  @locked_specs = locked_specs
  @unlock_gems = unlock_gems
  @sort_versions = {}
end

def level=(value)
  v = case value
      when String, Symbol
        value.to_sym
  end
  raise ArgumentError, "Unexpected level #{v}. Must be :major, :minor or :patch" unless [:major, :minor, :patch].include?(v)
  @level = v
end

def major?
  level == :major
end

def minor?
  level == :minor
end

def move_version_to_end(result, version)
  move, keep = result.partition {|s| s.version.to_s == version.to_s }
  keep.concat(move)
end

def post_sort(result)
  # default :major behavior in Bundler does not do this
  return result if major?
  if unlocking_gem?
    result
  else
    move_version_to_end(result, @locked_version)
  end
end

def segments_do_not_match(level)
  index = [:major, :minor].index(level)
  @a_ver.segments[index] != @b_ver.segments[index]
end

def sort_dep_specs(spec_groups, locked_spec)
  return spec_groups unless locked_spec
  @gem_name = locked_spec.name
  @locked_version = locked_spec.version
  result = spec_groups.sort do |a, b|
    @a_ver = a.version
    @b_ver = b.version
    if major?
      @a_ver <=> @b_ver
    elsif either_version_older_than_locked
      @a_ver <=> @b_ver
    elsif segments_do_not_match(:major)
      @b_ver <=> @a_ver
    elsif !minor? && segments_do_not_match(:minor)
      @b_ver <=> @a_ver
    else
      @a_ver <=> @b_ver
    end
  end
  post_sort(result)
end

def sort_versions(dep, spec_groups)
  before_result = "before sort_versions: #{debug_format_result(dep, spec_groups).inspect}" if ENV["DEBUG_RESOLVER"]
  @sort_versions[dep] ||= begin
    gem_name = dep.name
    # An Array per version returned, different entries for different platforms.
    # We only need the version here so it's ok to hard code this to the first instance.
    locked_spec = locked_specs[gem_name].first
    if strict
      filter_dep_specs(spec_groups, locked_spec)
    else
      sort_dep_specs(spec_groups, locked_spec)
    end.tap do |specs|
      if ENV["DEBUG_RESOLVER"]
        STDERR.puts before_result
        STDERR.puts " after sort_versions: #{debug_format_result(dep, specs).inspect}"
      end
    end
  end
end

def unlocking_gem?
  unlock_gems.empty? || unlock_gems.include?(@gem_name)
end