module InheritHook
  def inherited(subclass)
    puts "InhertHook#inherited called for #{subclass}"
    subclass.base_or_eigenclass_instance.set_eigenclass_owner
  end
end

class Base
  def initialize(klass)
    puts "#{self.class}#initialize called for #{klass}"
    @klass = klass
    puts "Returning #{self}"
  end

  def set_eigenclass_owner
    puts "Base#set_eigenclass_owner called on #{self}"
    @klass.singleton_class.base_or_eigenclass_instance.owner_class = 'something'
  end
end

class EigenClass < Base
  attr_writer :owner_class
end

module Engine
  def self.apply(target, klass = Base)
    puts "Engine.apply called on #{target}, #{klass}"
    return if target.respond_to?(:base_or_eigenclass_instance)

    apply_to_eigenclass(target)

    target.instance_eval do
      define_method(:base_or_eigenclass_instance) do
        @base_or_eigenclass_instance ||= klass.new(self)
      end
    end
  end

  private

  def self.apply_to_eigenclass(target)
    puts "Engine.apply_to_eigenclass called on #{target}"
    return if (target <= Object.singleton_class)

    singleton_class = target.singleton_class
    singleton_class.extend(InheritHook)
    apply(singleton_class, EigenClass)
    apply(singleton_class)
  end
end

Object.extend(InheritHook)
Engine.apply(Object)

class C end

module InheritHook
  def inherited(subclass)
    puts "InhertHook#inherited(#{subclass})"
    subclass.base_or_eigenclass_instance
  end
end

class Base
  def initialize(klass)
    puts "#{self.class}#initialize(#{klass})"
    @klass = klass
  end
end

class EigenClass < Base
end

module Engine
  def self.apply(target, klass = Base)
    puts "Engine.apply(#{target}, #{klass})"
    if target.respond_to?(:base_or_eigenclass_instance)
      puts "Early return because already applied"
      return
    end

    apply_to_eigenclass(target)

    target.instance_eval do
      define_method(:base_or_eigenclass_instance) do
        @base_or_eigenclass_instance ||= klass.new(self)
      end
    end
  end

  private

  def self.apply_to_eigenclass(target)
    puts "Engine.apply_to_eigenclass(#{target})"
    return if (target <= Object.singleton_class)

    singleton_class = target.singleton_class
    singleton_class.extend(InheritHook)
    apply(singleton_class, EigenClass)
    apply(singleton_class)
  end
end

Object.extend(InheritHook)
Engine.apply(Object)

class C end

module ExtendedModule end

klass = Object.singleton_class
klass.extend(ExtendedModule)

if !klass.respond_to?(:dynamically_defined_method)
  puts "Defining dynamically_defined_method"

  klass.instance_eval do
    define_method(:dynamically_defined_method) {}
  end
end

puts klass.respond_to?(:dynamically_defined_method)