Edge Cases and Advanced Usage

# frozen_string_literal: true

class AdvancedUsage
  def self.demonstrate_edge_cases
    puts "=== Edge Cases ==="

    # Edge case 1: Regexp literals are also affected
    pattern = /hello/i
    puts "Regexp source frozen? #{pattern.source.frozen?}"

    # Edge case 2: Symbol to_s returns frozen strings
    symbol = :test_symbol
    symbol_string = symbol.to_s
    puts "Symbol to_s frozen? #{symbol_string.frozen?}"

    # Edge case 3: Exception messages
    begin
      raise StandardError, "This is an error message"
    rescue StandardError => e
      puts "Exception message frozen? #{e.message.frozen?}"
    end

    # Edge case 4: File operations
    require 'tempfile'
    Tempfile.create('test') do |file|
      file.write("test content")
      file.rewind
      content = file.read
      puts "File content frozen? #{content.frozen?}"
    end
  end

  def self.demonstrate_encoding_behavior
    puts "\n=== Encoding Behavior ==="

    # Frozen strings with different encodings
    utf8_string = "Hello 世界"
    ascii_string = "Hello World".encode('ASCII')

    puts "UTF-8 string: #{utf8_string} (encoding: #{utf8_string.encoding}, frozen: #{utf8_string.frozen?})"
    puts "ASCII string: #{ascii_string} (encoding: #{ascii_string.encoding}, frozen: #{ascii_string.frozen?})"

    # Encoding operations create new strings
    converted = utf8_string.encode('ASCII', invalid: :replace, undef: :replace)
    puts "Converted: #{converted} (frozen: #{converted.frozen?})"
  end

  def self.demonstrate_thread_safety
    puts "\n=== Thread Safety Benefits ==="

    shared_string = "I am shared between threads"
    results = []
    mutex = Mutex.new

    threads = 5.times.map do |i|
      Thread.new do
        # Frozen strings are safe to share
        local_result = "Thread #{i}: #{shared_string}"

        mutex.synchronize do
          results << local_result
        end
      end
    end

    threads.each(&:join)

    puts "Shared string frozen? #{shared_string.frozen?}"
    results.each { |result| puts result }

    # Check if all results reference the same shared string parts
    object_ids = results.map { |r| r.match(/: (.+)$/)[1].object_id }.uniq
    puts "All threads used same string object? #{object_ids.length == 1}"
  end

  def self.demonstrate_memory_profiling
    puts "\n=== Memory Profiling ==="

    # Helper to track object allocations
    def self.track_allocations
      before = ObjectSpace.count_objects
      yield
      after = ObjectSpace.count_objects

      {
        strings: after[:T_STRING] - before[:T_STRING],
        objects: after[:T_OBJECT] - before[:T_OBJECT],
        arrays: after[:T_ARRAY] - before[:T_ARRAY],
        hashes: after[:T_HASH] - before[:T_HASH]
      }
    end

    # Test 1: Frozen string usage
    allocations1 = track_allocations do
      strings = 100.times.map { "constant string" }
    end

    # Test 2: Mutable string usage
    allocations2 = track_allocations do
      strings = 100.times.map { "constant string".dup }
    end

    puts "Frozen strings allocated: #{allocations1[:strings]} objects"
    puts "Mutable strings allocated: #{allocations2[:strings]} objects"
    puts "Memory savings: #{allocations2[:strings] - allocations1[:strings]} objects"
  end

  module StringPool
    # String pool implementation using frozen strings
    @pool = {}

    def self.intern(string)
      frozen = string.frozen? ? string : -string
      @pool[frozen] ||= frozen
    end

    def self.size
      @pool.size
    end

    def self.clear
      @pool.clear
    end
  end

  def self.demonstrate_string_pool
    puts "\n=== String Pool Implementation ==="

    # Add strings to pool
    strings = ["hello", "world", "hello", "ruby", "world", "hello"]

    strings.each { |s| StringPool.intern(s) }

    puts "Original strings: #{strings.length}"
    puts "Pooled strings: #{StringPool.size}"

    # Demonstrate that pooled strings are the same object
    str1 = StringPool.intern("hello")
    str2 = StringPool.intern("hello")

    puts "Same object? #{str1.equal?(str2)}"
    puts "Object ID: #{str1.object_id}"
  end
end

AdvancedUsage.demonstrate_edge_cases
AdvancedUsage.demonstrate_encoding_behavior
AdvancedUsage.demonstrate_thread_safety
AdvancedUsage.demonstrate_memory_profiling
AdvancedUsage.demonstrate_string_pool