reduce, each_with_object และการออกแบบ accumulator

total = 0
rows.each do |row|
  total += row[:amount]
end

rows.reduce(0) { |sum, row| sum + row[:amount] }

rows.each_with_object({}) do |row, grouped|
  grouped[row[:currency]] ||= 0
  grouped[row[:currency]] += row[:amount]
end

total = 0
invoices.each do |invoice|
  total += invoice[:amount]
end

invoices.reduce(0) { |sum, invoice| sum + invoice[:amount] }

grouped = {}
items.each do |item|
  grouped[item[:category]] ||= []
  grouped[item[:category]] << item[:name]
end

items.each_with_object({}) do |item, grouped|
  grouped[item[:category]] ||= []
  grouped[item[:category]] << item[:name]
end

rows.reduce(0) { |sum, row| sum + row[:amount] }

rows.each_with_object({}) do |row, grouped|
  grouped[row[:category]] ||= []
  grouped[row[:category]] << row[:name]
end

# EXAMPLE CODE
# Topic: topic_15_reduce_accumulators
#
# Purpose:
# - This file demonstrates `reduce` for a simple total.
# - It should pass tests from the beginning.
# - Read it before solving grouped and multi-field accumulator exercises.

class RevenueCalculator
  def total_amount(rows)
    rows.reduce(0) { |sum, row| sum + row[:amount] }
  end
end

# STUDENT TASK (BASIC)
# Topic: topic_15_reduce_accumulators
#
# What to do:
# - Group item names by category.
# - Use `each_with_object` so the grouped hash is introduced right where it is built.
# - Return the grouped hash instead of printing directly.
#
# Expected outcome:
# - You can solve a grouped-data problem with an explicit accumulator object.

class CatalogGrouper
  def names_by_category(items)
    items.each_with_object({}) do |item, grouped|
      grouped[item[:category]] ||= []
      grouped[item[:category]] << item[:name]
    end
  end
end

# STUDENT TASK (ADVANCED)
# Topic: topic_15_reduce_accumulators
#
# Academic purpose:
# - Practice designing an accumulator with more than one field.
# - Show that a single pass can build a useful reporting summary clearly.
#
# Real-world use case:
# - Dashboards and import summaries often need several values at once:
#   count, total, average, and a list of flagged rows.
# - This is a realistic place where accumulator design matters.
#
# Why Ruby is beautiful here:
# - A summary hash can be updated in one pass with clear field names.
# - The accumulator shape mirrors the business question.
# - The final result is easy to inspect in tests and logs.
#
# What to do:
# - Build a summary object using `each_with_object`.
# - Track count, total amount, average amount, and expensive item names.
# - Keep the expensive-item rule explicit in the code.
#
# Expected outcome:
# - Advanced tests pass and you can explain why the accumulator has its chosen shape.

class SalesSummary
  def summarize(items, expensive_threshold: 100)
    summary = items.each_with_object({
      count: 0,
      total_amount: 0,
      average_amount: 0.0,
      expensive_names: []
    }) do |item, acc|
      acc[:count] += 1
      acc[:total_amount] += item[:amount]
      acc[:expensive_names] << item[:name] if item[:amount] >= expensive_threshold
    end

    summary[:average_amount] =
      summary[:count].zero? ? 0.0 : summary[:total_amount].to_f / summary[:count]

    summary
  end
end

# ANSWER KEY (BASIC)
# Topic: topic_15_reduce_accumulators
#
# Solution idea:
# - Start with an empty hash accumulator.
# - Initialize each category bucket lazily.
# - Append names into the right bucket as the iteration proceeds.

class CatalogGrouper
  def names_by_category(items)
    items.each_with_object({}) do |item, grouped|
      grouped[item[:category]] ||= []
      grouped[item[:category]] << item[:name]
    end
  end
end

# ANSWER KEY (ADVANCED)
# Topic: topic_15_reduce_accumulators
#
# Solution idea:
# - Use one summary hash as the accumulator.
# - Update all fields in a single pass.
# - Compute the average after the pass so the intermediate logic stays simple.

class SalesSummary
  def summarize(items, expensive_threshold: 100)
    summary = items.each_with_object({
      count: 0,
      total_amount: 0,
      average_amount: 0.0,
      expensive_names: []
    }) do |item, acc|
      acc[:count] += 1
      acc[:total_amount] += item[:amount]
      acc[:expensive_names] << item[:name] if item[:amount] >= expensive_threshold
    end

    summary[:average_amount] =
      summary[:count].zero? ? 0.0 : summary[:total_amount].to_f / summary[:count]

    summary
  end
end

# This spec is your learning companion for topic_15_reduce_accumulators.
#
# How to use this file:
# 1) Run tests and observe failures or successes.
# 2) Keep the EXAMPLE specs green from the beginning.
# 3) Implement the BASIC exercise as sprint 2: grouped accumulation.
# 4) Implement the ADVANCED exercise as sprint 3: multi-field summary accumulation.
#
# Expected final result:
# - All examples in this file pass.
# - You understand accumulator-driven Ruby as a practical problem-solving style.

require_relative "../example"
require_relative "../basic_exercise"
require_relative "../adv_exercise"

RSpec.describe "topic_15_reduce_accumulators" do
  describe "EXAMPLE purpose: understand reduce as a way to collapse many rows into one total" do
    it "sums revenue rows" do
      calculator = RevenueCalculator.new

      expect(calculator.total_amount([{ amount: 40 }, { amount: 60 }, { amount: 20 }])).to eq(120)
    end
  end

  describe "BASIC EXERCISE purpose: group names with each_with_object instead of manual setup" do
    it "returns names grouped by category" do
      grouper = CatalogGrouper.new
      items = [
        { category: "books", name: "Ruby Book" },
        { category: "books", name: "Refactoring" },
        { category: "home", name: "Desk Lamp" }
      ]

      expect(grouper.names_by_category(items)).to eq(
        {
          "books" => ["Ruby Book", "Refactoring"],
          "home" => ["Desk Lamp"]
        }
      )
    end
  end

  describe "ADVANCED EXERCISE purpose: build a dashboard-style summary in one pass" do
    it "tracks count, total, average, and expensive item names" do
      summary = SalesSummary.new
      items = [
        { name: "Ruby Book", amount: 80 },
        { name: "Refactoring", amount: 120 },
        { name: "Desk Lamp", amount: 150 }
      ]

      expect(summary.summarize(items, expensive_threshold: 100)).to eq(
        {
          count: 3,
          total_amount: 350,
          average_amount: 116.66666666666667,
          expensive_names: ["Refactoring", "Desk Lamp"]
        }
      )
    end
  end
end

#!/usr/bin/env bash
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
ROOT_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"

exec "${ROOT_DIR}/run_tests.sh" "$(basename "${SCRIPT_DIR}")"