Orders are made up of optimal pack combinations

lib/order_line.rb

@@ -11,65 +11,124 @@ def initialize(order_qty, order_item)
   end
 
   def optimal(product)
+    puts "Quantity: #{order_qty}"
     pack_qtys = []
     @order_item.packs(product).each { |p| pack_qtys << [p.qty, p.price] }
+    puts "Packs: #{pack_qtys}"
 
-    whole_packs = whole_packs(pack_qtys, [], order_qty)
+    # Get Exact matches
+    exact_matches = []
+    pack_qtys.sort { |a, b| b <=> a }.each do |p, v|
+      next unless (order_qty / p) * p == order_qty
+      exact_matches << [order_qty / p, p, v]
+    end
+    # puts exact_matches
 
-    return whole_packs[0] if whole_packs[1].zero?
+    # Check for the optimim price
+    price_check = []
+    exact_matches.each do |x, y, z|
+      val = (x * z)
 
-    total_packs = left_over_items(pack_qtys, whole_packs[0], whole_packs[1])
+      price_check << [x, y, z, val]
+    end
+    # puts price_check
 
-    total_packs[0]
-  end
+    numbers = price_check.select { |x| x[3] }.map
 
-  def present_line(packs)
-    sub_total = []
-    sub_item = []
-    packs.each do |k, v, i|
-      sub_total << k * i
-      sub_item << "#{k}x #{v} packs @ #{i}"
+    # Get Part matches
+    partial_matches = []
+    pack_qtys.sort { |a, b| b <=> a }.each do |p, v|
+      partial_matches << [order_qty / p, p, v]
+    end
+    puts "partial: #{partial_matches}"
+
+    # Top up part matches
+    exact_partial = []
+    partial_matches.each do |x, y, z|
+      val = order_qty - (x * y)
+      puts "VAL: #{val}"
+      pack_qtys.detect do |a|
+        # To be optimised: a.include?(val) does not cooperate with Money
+        if a[0] == val || a[0] * 3 == val
+          exact_partial << [x, y, z]
+          exact_partial << [val / a[0], a[0], a[1]]
+        end
+      end
     end
+    puts "exact partial: #{exact_partial}"
 
-    @line_total = sub_total.inject(0) { |sum, x| sum + x }
+    # Check for the optimim partial price
+    partial_price_check = []
+    exact_partial.each do |x, y, z|
+      val = (x * z)
 
-    sub_item.each { |s| s }
-  end
+      partial_price_check << [x, y, z, val]
+    end
+    # puts partial_price_check
 
-  def presenter_line_total
-    @line_total
-  end
+    partial_numbers = partial_price_check.select { |x| x[3] }.map
 
-  private
+    partial_price_array = []
+    partial_numbers.each do |f|
+      partial_price_array << f
+    end
+    # puts partial_price_array
 
-  def whole_packs(pack_qtys, packs, left_over_qty)
-    pack_qtys.sort { |a, b| b <=> a }.each do |p, v|
-      volume = left_over_qty.to_f / p
+    puts "Exact Match: #{exact_matches}"
+    # Array for best price line: 1x 9pk @16 = $16
+    puts "Best Exact Price: #{numbers.min}"
+    puts "Partial Match: #{exact_partial}"
+    puts "Best Partial Price: #{partial_price_array}"
 
-      next unless volume >= 1
+    return calculate_best(numbers, partial_price_array) unless price_check.empty?
 
-      left_over_qty -= volume.to_int * p
+    calculate_best(numbers.min, partial_price_array)
+  end
 
-      packs << [volume.to_int, p, v]
+  def calculate_best(exact, partial)
+    if exact.nil?
+      puts "\nThis is it #{partial}"
+      return partial
     end
 
-    [packs, left_over_qty]
-  end
+    if partial.empty?
+      puts "\nThis is it #{exact}"
+      return exact
+    end
 
-  def left_over_items(pack_qtys, packs, left_over_qty)
-    pack_qtys.sort { |a, b| a <=> b }.each do |p, v|
-      break if left_over_qty.zero?
+    sub_total = []
+    partial.each do |_x, _y, _z, val|
+      sub_total << val
+    end
 
-      next unless left_over_qty <= p
+    # Find total cost of sub_items
+    line_total = sub_total.inject(:+)
 
-      packs.map { |a| a[0] += 1 if a[1].to_i == p }
-      left_over_qty = 0
+    # Return array of the cheapest line
+    if [exact.min[3], line_total].min == line_total
+      puts "\nThis is it #{partial}"
+      return partial
+    end
 
-      next if packs.detect { |a| a[1] == p }
+    puts "\nThis is it #{exact}" if [exact.min[3], line_total].min == exact
+    exact
+  end
 
-      packs << [1, p, v]
+  def present_line(packs)
+    puts "pACKS: #{packs}"
+    sub_total = []
+    sub_item = []
+    packs.each do |k, v, i|
+      sub_total << k * i
+      sub_item << "#{k}x #{v} packs @ #{i}"
     end
 
-    [packs, left_over_qty]
+    @line_total = sub_total.inject(:+)
+
+    sub_item.each { |s| s }
+  end
+
+  def presenter_line_total
+    @line_total
   end
 end

spec/order_line_spec.rb

@@ -25,16 +25,10 @@
   end
 
   describe '#optimal' do
-    it 'should return total_packs[0] which is an Array' do
+    it 'should return optimum combination of packs which is an Enumerator' do
       instance = OrderLine.new(12, Item.new('watermelons'))
 
-      expect(instance.optimal(instance.order_item.name)).to be_a Array
-    end
-
-    it 'should return whole_packs[0] which is an Array' do
-      instance = OrderLine.new(10, Item.new('watermelons'))
-
-      expect(instance.optimal(instance.order_item.name)).to be_a Array
+      expect(instance.optimal(instance.order_item.name)).to be_a Enumerator
     end
   end
 
@@ -54,22 +48,4 @@
       expect(instance.presenter_line_total).to be_a Money
     end
   end
-
-  describe '#whole_packs' do
-    it 'should return an Array' do
-      instance = OrderLine.new(12, Item.new('watermelons'))
-      pack_qtys = [[3, 6.99], [5, 8.99]]
-
-      expect(instance.send(:whole_packs, pack_qtys, [], @order_qty)).to be_a Array
-    end
-  end
-
-  describe '#left_over_items' do
-    it 'should return an Array' do
-      instance = OrderLine.new(12, Item.new('watermelons'))
-      pack_qtys = [[3, 6.99], [5, 8.99]]
-
-      expect(instance.send(:left_over_items, pack_qtys, [], 1)).to be_a Array
-    end
-  end
 end