class StaticReporter
  def generate_report_for_sales
    puts "Generating sales report..."
    # ... complex report logic ...
    puts "Sales report generated."
  end

  def generate_report_for_marketing
    puts "Generating marketing report..."
    # ... complex report logic ...
    puts "Marketing report generated."
  end

  def generate_report_for_finance
    puts "Generating finance report..."
    # ... complex report logic ...
    puts "Finance report generated."
  end
end

# Usage of the static reporter
puts "--- Static Reporter Usage ---"
reporter_static = StaticReporter.new
reporter_static.generate_report_for_sales
reporter_static.generate_report_for_marketing


# --- Refactoring with define_method for DRYness ---

class DynamicReporter
  # A shared template for report generation logic
  def self.report_template(department_name)
    Proc.new do
      puts "Generating #{department_name} report..."
      # Simulating complex report logic dynamically
      puts "Complex calculations for #{department_name}..."
      puts "Data aggregation for #{department_name}..."
      puts "#{department_name} report generated."
    end
  end

  # Dynamically define report generation methods for various departments
  # We activate define_method to create these methods at runtime
  ["sales", "marketing", "finance", "operations"].each do |department|
    method_name = "generate_report_for_#{department}".to_sym
    define_method(method_name, &report_template(department))
  end
end

# Usage of the dynamic reporter
puts "\n--- Dynamic Reporter Usage ---"
reporter_dynamic = DynamicReporter.new
reporter_dynamic.generate_report_for_sales
reporter_dynamic.generate_report_for_operations

# We can even define a new method after initialization if needed
puts "\n--- Adding a new dynamic method ---"
DynamicReporter.define_method(:generate_report_for_hr, &DynamicReporter.report_template("HR"))
reporter_dynamic.generate_report_for_hr

class Decoder
  attr_reader :instance_variable

  def initialize(value)
    @instance_variable = value
  end

  # Method 1: Basic define_method with a block
  # We observe the scope closure, where 'message' is captured from the defining context.
  def self.define_simple_method(name)
    message = "Hello from #{name}!"
    define_method(name) do |arg = 'default_arg'|
      puts "  #{message} Argument: #{arg}"
      puts "  'self' inside #{name}: #{self.class}"
      # We can access instance variables from the *instance* of the class.
      puts "  Instance variable from #{name}: #{@instance_variable}" if defined?(@instance_variable)
    end
  end

  # Method 2: define_method with a Proc object
  # This demonstrates passing a pre-defined Proc, detaching the block from the immediate defining scope.
  def self.define_proc_method(name, proc_obj)
    define_method(name, proc_obj)
  end

  # Method 3: define_method to copy an existing method (rare, but possible)
  # We illustrate defining a new method by referencing an existing one.
  def self.define_copied_method(new_name, existing_method)
    # The second argument to define_method can be an actual Method object or a Symbol/String
    # pointing to an existing method visible from the current context.
    define_method(new_name, existing_method)
  end

  # An example method to be copied
  def existing_behavior
    puts "  This is the original existing behavior."
  end
end

puts "--- Decoding define_method examples ---"
Decoder.define_simple_method(:dynamic_greeting)
Decoder.define_proc_method(:proc_greeting, Proc.new do |name|
  puts "  Greeting from Proc for #{name}!"
  puts "  'self' inside proc_greeting: #{self.class}"
  puts "  Instance variable from proc_greeting: #{@instance_variable}" if defined?(@instance_variable)
end)

decoder_instance = Decoder.new("MyInstanceValue")
decoder_instance.dynamic_greeting
decoder_instance.dynamic_greeting("custom_value")
decoder_instance.proc_greeting("Bob")

# Demonstrating copying an existing method
Decoder.define_copied_method(:cloned_behavior, Decoder.instance_method(:existing_behavior))
decoder_instance.cloned_behavior

puts "\n--- Understanding 'self' context ---"
# 'self' in the defining context (class scope) is Decoder
puts "Defining context 'self': #{self}"

class AnotherClass
  # We observe that 'self' inside the dynamically defined method refers to the *instance* of the class it's defined on.
  define_method(:who_am_i) do
    puts "  'self' inside dynamically defined 'who_am_i': #{self.class}"
    puts "  Object ID of self: #{self.object_id}"
  end
end

another_instance = AnotherClass.new
another_instance.who_am_i

class AttributeBuilder
  # We engineer a class method to dynamically add attributes to any given class.
  def self.build_attributes_for(target_class, *attributes)
    attributes.each do |attr_name|
      # Define a getter method dynamically
      target_class.define_method(attr_name) do
        instance_variable_get("@#{attr_name}")
      end

      # Define a setter method dynamically
      target_class.define_method("#{attr_name}=") do |value|
        instance_variable_set("@#{attr_name}", value)
      end

      puts "  Engineered attribute '#{attr_name}' for #{target_class}"
    end
  end
end

# --- Example: Building a flexible data model ---
class UserProfile
  # No attributes defined yet
end

puts "--- Dynamically building UserProfile attributes ---"
# We activate the attribute builder for UserProfile
AttributeBuilder.build_attributes_for(UserProfile, :name, :email, :age)

user = UserProfile.new
user.name = "Alice"
user.email = "alice@example.com"
user.age = 30

puts "  User Profile: Name: #{user.name}, Email: #{user.email}, Age: #{user.age}"

# --- Example: Extending an existing class dynamically ---
class Product
  attr_accessor :id, :description # Some existing attributes
end

puts "\n--- Dynamically extending Product attributes ---"
# We extend the Product class with new dynamic attributes
AttributeBuilder.build_attributes_for(Product, :price, :quantity)

product = Product.new
product.id = 123
product.description = "Advanced Widget"
product.price = 99.99
product.quantity = 500

puts "  Product: ID: #{product.id}, Description: #{product.description}, Price: #{product.price}, Quantity: #{product.quantity}"


# --- Contrast with method_missing (conceptual) ---
puts "\n--- Conceptual distinction: define_method vs. method_missing ---"
# define_method: Proactive. Methods exist before call.
# method_missing: Reactive. Intercepts calls to non-existent methods.
# We choose define_method when we know *what* methods to create.
# We reserve method_missing for truly unknown or variable method patterns.

require 'minitest/autorun'

class DynamicConfiguration
  # We engineer a system for dynamic configuration loading.
  def initialize(settings_hash)
    settings_hash.each do |key, value|
      # We activate define_method to create getter methods for each setting.
      define_method(key) do
        value # The block captures 'value' from the defining scope
      end
    end
  end

  # Example of a potential pitfall: accidentally overriding existing methods
  def existing_method
    "Original behavior"
  end

  def define_colliding_method
    # This demonstrates a method collision if 'existing_method' was also in settings_hash
    define_method(:existing_method) do
      "Overridden behavior!"
    end
  end
end

# --- Best Practice: Testing dynamically defined methods ---
class TestDynamicConfiguration < Minitest::Test
  def setup
    @config_settings = { host: 'localhost', port: 8080, debug_mode: true }
    @config = DynamicConfiguration.new(@config_settings)
  end

  def test_dynamic_host_method
    # We assert that the dynamically created method returns the correct value.
    assert_equal 'localhost', @config.host, "Expected host method to return 'localhost'"
  end

  def test_dynamic_port_method
    # We verify the existence and value of another dynamic method.
    assert_respond_to @config, :port, "Expected config to respond to :port"
    assert_equal 8080, @config.port, "Expected port method to return 8080"
  end

  def test_non_existent_method_raises_error
    # We confirm that methods not defined dynamically do not exist.
    assert_raises(NoMethodError) { @config.unknown_setting }
  end

  def test_method_collision_avoidance
    # This test conceptually demonstrates the pitfall.
    # In real applications, we guard against this by checking method existence.
    original_behavior = @config.existing_method # Should be "Original behavior"
    @config.define_colliding_method # This would override 'existing_method'
    overridden_behavior = @config.existing_method # Now should be "Overridden behavior!"

    # We verify that a collision occurred and the method was indeed redefined.
    assert_equal "Original behavior", original_behavior
    assert_equal "Overridden behavior!", overridden_behavior
  end
end

# --- Performance Consideration (Conceptual) ---
puts "\n--- Performance implications (conceptual) ---"
# While define_method is efficient, defining millions of methods might consume memory.
# We choose dynamic definition for manageable sets of methods or where flexibility is paramount.
# Avoid creating an excessive number of methods that are rarely used.