recommendations by weight

recommendation.rb

class Recommendation 

  attr_reader :trucks, :recommendations

  def initialize(category, year, miles, engine_block, make)
    @category = category
    @year = year
    @miles = miles
    @engine_block = engine_block
    @make = make
    @trucks = []
    @recommendations = []
  end

private
  def  get_model_year_counts
    case @category
    when "Day Cab"
      DayCab.count(:group => "model_year")
    when "Sleeper"
    when "Mid-Range Diesel"
    else
    end
  end

  def get_trucks(years_back_count)
    initial_year = @year - years_back_count

    case @category
    when "Day Cab"
      @trucks = DayCab.where(:model_year => initial_year..@year)
    when "Sleeper"
    when "Mid-Range Diesel"
    else
    end
  end

  def find_trucks
    model_years_count = get_model_year_counts
    years_back_count = 0
    trucks_count = 0

    while trucks_count < 10
      current_year = @year - years_back_count
      trucks_count += model_years_count[current_year].to_i
      years_back_count += 1
    end

    get_trucks(years_back_count)
  end

  def model_year_weight(model_year)
    if model_year == @year
      1
    elsif model_year == (@year - 1)
      0.5
    elsif model_year < @year
      0.1
    else
      0
    end
  end

  def miles_weight(miles)
    if miles == @miles
      2
    elsif miles <= (@miles - 25000) || miles <= (@miles + 25000)
      1
    else
      0
    end
  end

  def engine_block_size_weight(engine_block_size)
    engine_block_size == @engine_block_size ? 1 : 0
  end

  def make_weight(make)
    make == @make ? 1 : 0
  end

  def calculate_weight(truck)
    weight = 0.0
    weight += model_year_weight(truck.model_year)
    weight += miles_weight(truck.miles)
    weight += engine_block_size_weight(truck.engine_block_size)
    weight += make_weight(truck.make)

    return weight
  end

  def trucks_list
    find_trucks.map do |truck|
      {
        id: truck.id,
        date: truck.sale_date,
        weight: calculate_weight(truck)
      }
    end
  end

  def get_recommended_truck_ids(trucks)
    list = trucks.sort_by { |t| [t[:weight], t[:date]] }.reverse

    list[0..9].map { |t| t[:id] }
  end

  def truck_record(id)
    @trucks.select { |t| t.id == id }
  end

  def get_truck_recommendations(ids)
    ids.map { |id| truck_record(id) }
  end

public
  def generate
    ids = get_recommended_truck_ids(trucks_list)
    get_truck_recommendations(ids)
  end

end