# Base class defining the template method
class BeverageMaker
  def brew
    gather_ingredients
    heat_water
    add_ingredients
    steep
    serve
  end

  def gather_ingredients
    puts "Gathering ingredients..."
  end

  def heat_water
    puts "Heating water to appropriate temperature..."
  end

  # These are hook methods that subclasses will override
  def add_ingredients
    raise NotImplementedError, "Subclasses must implement add_ingredients"
  end

  def steep
    raise NotImplementedError, "Subclasses must implement steep"
  end

  def serve
    puts "Pouring into a cup..."
  end
end

# Tea subclass
class TeaMaker < BeverageMaker
  def add_ingredients
    puts "Adding tea leaves to the infuser..."
  end

  def steep
    puts "Steeping for 3-5 minutes..."
  end
end

# Coffee subclass
class CoffeeMaker < BeverageMaker
  def add_ingredients
    puts "Adding ground coffee to the filter..."
  end

  def steep
    puts "Brewing for 4-6 minutes..."
  end

  def serve
    puts "Adding milk and sugar as desired, then pouring..."
  end
end

# Usage
puts "=== Making Tea ==="
tea = TeaMaker.new
tea.brew

puts "\n=== Making Coffee ==="
coffee = CoffeeMaker.new
coffee.brew

class DataProcessor
  def process(file_path)
    data = read_file(file_path)
    data = validate(data)
    data = transform(data)
    data = enrich(data)
    save_output(data)
  end

  def read_file(file_path)
    raise NotImplementedError
  end

  def validate(data)
    puts "Validating data..."
    data
  end

  def transform(data)
    raise NotImplementedError
  end

  def enrich(data)
    puts "Enriching data with metadata..."
    data
  end

  def save_output(data)
    raise NotImplementedError
  end
end

class CSVProcessor < DataProcessor
  def read_file(file_path)
    puts "Reading CSV file: #{file_path}"
    [["Name", "Age"], ["Alice", 30], ["Bob", 25]]
  end

  def transform(data)
    puts "Transforming CSV data to hash format..."
    data
  end

  def save_output(data)
    puts "Saving processed data to database..."
  end
end

class JSONProcessor < DataProcessor
  def read_file(file_path)
    puts "Reading JSON file: #{file_path}"
    {"users" => [{"name" => "Alice", "age" => 30}]}
  end

  def transform(data)
    puts "Transforming JSON data to standardized format..."
    data
  end

  def save_output(data)
    puts "Saving to API endpoint..."
  end
end

# Strategy interface (in Ruby, we use duck typing or modules)
module PaymentStrategy
  def pay(amount)
    raise NotImplementedError
  end
end

# Concrete strategies
class CreditCardPayment
  include PaymentStrategy

  def initialize(card_number, cvv)
    @card_number = card_number
    @cvv = cvv
  end

  def pay(amount)
    puts "Processing credit card payment of $#{amount}"
    puts "Card: #{@card_number[-4..-1]}"
    validate_cvv
    puts "Payment approved!"
  end

  private

  def validate_cvv
    puts "Validating CVV..."
  end
end

class PayPalPayment
  include PaymentStrategy

  def initialize(email)
    @email = email
  end

  def pay(amount)
    puts "Sending $#{amount} via PayPal to #{@email}"
    authenticate
    puts "PayPal payment processed!"
  end

  private

  def authenticate
    puts "Authenticating with PayPal..."
  end
end

class CryptocurrencyPayment
  include PaymentStrategy

  def initialize(wallet_address, crypto_type = "Bitcoin")
    @wallet_address = wallet_address
    @crypto_type = crypto_type
  end

  def pay(amount)
    puts "Sending #{amount} satoshis to wallet #{@wallet_address}"
    puts "Cryptocurrency: #{@crypto_type}"
    confirm_blockchain
    puts "Transaction confirmed on blockchain!"
  end

  private

  def confirm_blockchain
    puts "Confirming on blockchain..."
  end
end

# Context class
class ShoppingCart
  def initialize(payment_strategy)
    @payment_strategy = payment_strategy
    @total = 0
  end

  def add_item(price)
    @total += price
  end

  def checkout
    @payment_strategy.pay(@total)
  end

  # Strategy can be changed at runtime
  def change_payment_method(new_strategy)
    @payment_strategy = new_strategy
  end
end

# Usage
puts "=== Customer 1: Credit Card Payment ==="
cart1 = ShoppingCart.new(CreditCardPayment.new("4532-1234-5678-9010", "123"))
cart1.add_item(50)
cart1.add_item(30)
cart1.checkout

puts "\n=== Customer 2: PayPal Payment ==="
cart2 = ShoppingCart.new(PayPalPayment.new("user@example.com"))
cart2.add_item(100)
cart2.checkout

puts "\n=== Customer 3: Changes mind about payment ==="
cart3 = ShoppingCart.new(CreditCardPayment.new("5412-9876-5432-1098", "456"))
cart3.add_item(75)
puts "Initial strategy: Credit Card"
cart3.change_payment_method(CryptocurrencyPayment.new("1A1z7agoat4WYvtQy06YnYs73m7nEChoCM", "Bitcoin"))
puts "Changed strategy: Cryptocurrency"
cart3.checkout

module SortStrategy
  def sort(array)
    raise NotImplementedError
  end
end

class BubbleSort
  include SortStrategy

  def sort(array)
    puts "Sorting using Bubble Sort..."
    n = array.length
    (0...n).each do |i|
      (0...n - i - 1).each do |j|
        array[j], array[j + 1] = array[j + 1], array[j] if array[j] > array[j + 1]
      end
    end
    array
  end
end

class QuickSort
  include SortStrategy

  def sort(array)
    puts "Sorting using Quick Sort..."
    return array if array.length <= 1
    pivot = array[0]
    left = array[1..-1].select { |x| x < pivot }
    right = array[1..-1].select { |x| x >= pivot }
    sort(left) + [pivot] + sort(right)
  end
end

class DataSorter
  def initialize(strategy)
    @strategy = strategy
  end

  def execute(data)
    @strategy.sort(data)
  end

  def change_strategy(strategy)
    @strategy = strategy
  end
end

# Usage
data = [64, 34, 25, 12, 22, 11, 90]
sorter = DataSorter.new(BubbleSort.new)
puts sorter.execute(data.dup).inspect

sorter.change_strategy(QuickSort.new)
puts sorter.execute(data.dup).inspect

#include <iostream>
#include <vector>

// Generic function template
template <typename T>
T max_value(T a, T b) {
    return (a > b) ? a : b;
}

// Generic class template
template <typename T>
class Stack {
private:
    std::vector<T> elements;

public:
    void push(T value) {
        elements.push_back(value);
    }

    T pop() {
        T value = elements.back();
        elements.pop_back();
        return value;
    }

    bool is_empty() const {
        return elements.empty();
    }
};

int main() {
    // Using template functions with different types
    std::cout << "Max of 5 and 10: " << max_value(5, 10) << std::endl;
    std::cout << "Max of 3.5 and 2.1: " << max_value(3.5, 2.1) << std::endl;

    // Using template classes
    Stack<int> intStack;
    intStack.push(10);
    intStack.push(20);
    std::cout << "Popped: " << intStack.pop() << std::endl;

    Stack<std::string> stringStack;
    stringStack.push("Hello");
    stringStack.push("World");
    std::cout << "Popped: " << stringStack.pop() << std::endl;

    return 0;
}

generic
    type Item_Type is private;
    Max_Length : Integer;
package Stacks is
    type Stack_Type is limited private;

    procedure Push(S : in out Stack_Type; Item : Item_Type);
    procedure Pop(S : in out Stack_Type; Item : out Item_Type);
    function Is_Empty(S : Stack_Type) return Boolean;

private
    type Item_Array is array (1..Max_Length) of Item_Type;
    type Stack_Type is record
        Items : Item_Array;
        Top : Integer := 0;
    end record;
end Stacks;

# Ruby approach: Using blocks and duck typing
class Container
  def initialize
    @items = []
  end

  def add(item)
    @items << item
  end

  def process(&block)
    @items.each { |item| block.call(item) }
  end

  def map(&block)
    @items.map { |item| block.call(item) }
  end

  def select(&block)
    @items.select { |item| block.call(item) }
  end
end

# Using with different types
int_container = Container.new
int_container.add(1)
int_container.add(2)
int_container.add(3)

puts "Original integers:"
int_container.process { |x| puts x }

puts "\nDoubled integers:"
doubled = int_container.map { |x| x * 2 }
puts doubled.inspect

string_container = Container.new
string_container.add("Hello")
string_container.add("World")
string_container.add("Ruby")

puts "\nOriginal strings:"
string_container.process { |s| puts s }

puts "\nUppercased strings:"
uppercased = string_container.map { |s| s.upcase }
puts uppercased.inspect

# A more sophisticated generic-like pattern using modules
module Enumerable
  def filter_map(&block)
    map(&block).select { |item| !item.nil? }
  end

  def partition_by(&block)
    Hash.new { |h, k| h[k] = [] }.tap do |hash|
      each { |item| hash[block.call(item)] << item }
    end
  end
end

class MyList
  include Enumerable

  def initialize(items)
    @items = items
  end

  def each(&block)
    @items.each(&block)
  end

  def map(&block)
    @items.map(&block)
  end

  def select(&block)
    @items.select(&block)
  end
end

# Usage
numbers = MyList.new([1, 2, 3, 4, 5, 6])
evens = numbers.partition_by { |n| n.even? ? :even : :odd }
puts evens.inspect

# Strong aggregation: Car owns its parts
class Engine
  def initialize(horsepower)
    @horsepower = horsepower
  end

  def start
    puts "Engine with #{@horsepower}hp starting..."
  end

  def stop
    puts "Engine stopping..."
  end
end

class Wheel
  def initialize(size)
    @size = size
  end

  def rotate
    puts "#{@size}\" wheel rotating..."
  end
end

class Car
  def initialize(make, model)
    @make = make
    @model = model
    # Aggregation: Car contains Engine and Wheels
    @engine = Engine.new(200)
    @wheels = [
      Wheel.new(18),
      Wheel.new(18),
      Wheel.new(18),
      Wheel.new(18)
    ]
  end

  def start
    puts "Starting #{@make} #{@model}..."
    @engine.start
  end

  def drive
    @wheels.each(&:rotate)
    puts "Car is moving!"
  end

  def stop
    @engine.stop
    puts "Car stopped."
  end
end

# Usage
car = Car.new("Toyota", "Camry")
car.start
car.drive
car.stop

# Acquaintance: Order knows about Customer and Product
class Customer
  def initialize(name, email)
    @name = name
    @email = email
  end

  def name
    @name
  end

  def email
    @email
  end
end

class Product
  def initialize(name, price)
    @name = name
    @price = price
  end

  def name
    @name
  end

  def price
    @price
  end
end

class Order
  def initialize(order_id)
    @order_id = order_id
    @customer = nil  # Acquaintance: will know about a customer
    @products = []  # Acquaintance: will know about products
    @total = 0
  end

  # Receives a customer as a parameter
  def assign_customer(customer)
    @customer = customer
    puts "Order #{@order_id} assigned to #{customer.name}"
  end

  # Receives products as parameters
  def add_product(product, quantity = 1)
    @products << { product: product, quantity: quantity }
    @total += product.price * quantity
  end

  def display_summary
    puts "\n=== Order Summary ==="
    puts "Order ID: #{@order_id}"
    puts "Customer: #{@customer.name}"
    puts "Items:"
    @products.each do |item|
      puts "  - #{item[:product].name}: $#{item[:product].price} x #{item[:quantity]}"
    end
    puts "Total: $#{@total}"
  end
end

# Usage
customer = Customer.new("Alice Johnson", "alice@example.com")
product1 = Product.new("Laptop", 999)
product2 = Product.new("Mouse", 25)

order = Order.new("ORD-001")
order.assign_customer(customer)
order.add_product(product1)
order.add_product(product2, 2)
order.display_summary

# AGGREGATION: Restaurant owns its Menu and Tables
class MenuItem
  def initialize(name, price)
    @name = name
    @price = price
  end

  def description
    "#{@name}: $#{@price}"
  end
end

class Table
  def initialize(table_number, capacity)
    @table_number = table_number
    @capacity = capacity
    @is_occupied = false
  end

  def occupy
    @is_occupied = true
  end

  def free
    @is_occupied = false
  end

  def available?
    !@is_occupied
  end
end

class Menu
  def initialize(cuisine_type)
    @cuisine_type = cuisine_type
    @items = []
  end

  def add_item(item)
    @items << item
  end

  def list_items
    @items.map(&:description)
  end
end

class Restaurant
  def initialize(name)
    @name = name
    # AGGREGATION: Restaurant owns these objects
    @menu = Menu.new("Italian")
    @tables = [
      Table.new(1, 4),
      Table.new(2, 6),
      Table.new(3, 2)
    ]
  end

  def setup_menu
    @menu.add_item(MenuItem.new("Pasta Carbonara", 15))
    @menu.add_item(MenuItem.new("Lasagna", 18))
    @menu.add_item(MenuItem.new("Tiramisu", 8))
  end

  def show_menu
    puts "=== #{@name} Menu ==="
    @menu.list_items.each { |item| puts item }
  end

  def reserve_table(party_size)
    available_table = @tables.find { |t| t.available? && t.capacity >= party_size }
    if available_table
      available_table.occupy
      "Table reserved!"
    else
      "No suitable tables available"
    end
  end
end

# ACQUAINTANCE: Reservation knows about Customer and Restaurant
class Reservation
  def initialize(reservation_id)
    @reservation_id = reservation_id
    @customer = nil
    @restaurant = nil
    @time = nil
    @party_size = nil
  end

  def make_reservation(customer, restaurant, time, party_size)
    @customer = customer
    @restaurant = restaurant
    @time = time
    @party_size = party_size
    puts "Reservation #{@reservation_id} made for #{customer.name} at #{time} for #{party_size} people"
  end

  def confirm
    puts "Confirming reservation for #{@customer.name}..."
    result = @restaurant.reserve_table(@party_size)
    puts result
  end
end

# Usage
restaurant = Restaurant.new("Luigi's Italian Kitchen")
restaurant.setup_menu
restaurant.show_menu

customer = Customer.new("Bob Smith", "bob@example.com")
reservation = Reservation.new("RES-001")
reservation.make_reservation(customer, restaurant, "7:00 PM", 4)
reservation.confirm