module ReversingInit
  def initialize(**kwargs)
    super(**kwargs.to_a.reverse.to_h)
  end
end

Base = Data.define(:a, :b, :c) { include ReversingInit }
class Sub < Base; end  # empty subclass

obj = Sub.new(a: 1, b: 2, c: 3)

obj.a     #=> 1  (correct)
obj.b     #=> 2  (correct)
obj.c     #=> 3  (correct)
obj.to_h  #=> {a: 3, b: 2, c: 1}  (WRONG — expected {a: 1, b: 2, c: 3})

obj.deconstruct  #=> [3, 2, 1]  (WRONG — expected [1, 2, 3])

obj2 = obj.with(b: 20)
obj2.a  #=> 3   (WRONG — expected 1; corruption propagated via to_h)
obj2.b  #=> 20  (correct — was explicitly set)
obj2.c  #=> 1   (WRONG — expected 3)

#!/usr/bin/env ruby
# frozen_string_literal: true

puts "#{RUBY_ENGINE} #{RUBY_ENGINE_VERSION} (#{RUBY_VERSION})"
puts

$failures = []

def assert_equal(expected, actual, description)
  if expected == actual
    puts "  PASS: #{description}"
  else
    puts "  FAIL: #{description}"
    puts "    expected: #{expected.inspect}"
    puts "    actual:   #{actual.inspect}"
    $failures << description
  end
end

module ReversingInit
  def initialize(**kwargs)
    super(**kwargs.to_a.reverse.to_h)
  end
end

# ─── Controls: all PASS on JRuby ─────────────────────────────────────────────

puts "Control 1: Module in Data.define, NO subclass"
C1 = Data.define(:a, :b, :c) { include ReversingInit }
c1 = C1.new(a: 1, b: 2, c: 3)
assert_equal(1, c1.a, "c1.a")
assert_equal({a: 1, b: 2, c: 3}, c1.to_h, "c1.to_h")
puts

puts "Control 2: No module, subclass overrides initialize directly"
C2Base = Data.define(:a, :b, :c)
class C2 < C2Base
  def initialize(**kwargs)
    super(**kwargs.to_a.reverse.to_h)
  end
end
c2 = C2.new(a: 1, b: 2, c: 3)
assert_equal(1, c2.a, "c2.a")
assert_equal({a: 1, b: 2, c: 3}, c2.to_h, "c2.to_h")
puts

puts "Control 3: Module in subclass (not base)"
C3Base = Data.define(:a, :b, :c)
class C3 < C3Base
  include ReversingInit
end
c3 = C3.new(a: 1, b: 2, c: 3)
assert_equal(1, c3.a, "c3.a")
assert_equal({a: 1, b: 2, c: 3}, c3.to_h, "c3.to_h")
puts

# ─── Bug: Module in base + subclass ──────────────────────────────────────────

puts "BUG: Module in Data.define base + empty subclass"
BugBase = Data.define(:a, :b, :c) { include ReversingInit }
class Bug < BugBase; end

bug = Bug.new(a: 1, b: 2, c: 3)

puts "  Accessors (correct on JRuby):"
assert_equal(1, bug.a, "bug.a")
assert_equal(2, bug.b, "bug.b")
assert_equal(3, bug.c, "bug.c")

puts "  to_h (BROKEN on JRuby):"
assert_equal({a: 1, b: 2, c: 3}, bug.to_h, "bug.to_h")

puts "  deconstruct (BROKEN on JRuby):"
assert_equal([1, 2, 3], bug.deconstruct, "bug.deconstruct")

puts "  with (propagates corruption via to_h):"
bug2 = bug.with(b: 20)
assert_equal(1, bug2.a, "bug.with.a")
assert_equal(20, bug2.b, "bug.with.b")
assert_equal(3, bug2.c, "bug.with.c")
puts

# ─── Summary ─────────────────────────────────────────────────────────────────
puts "=" * 60
if $failures.empty?
  puts "All assertions passed."
else
  puts "#{$failures.size} failure(s):"
  $failures.each { |f| puts "  - #{f}" }
  exit 1
end