class Person {
    String name
    int age
    String greet() { "Hi, I'm ${name}" }
}

def p = new Person(name: 'Alice', age: 30)

// Every object has a metaClass
println "MetaClass type: ${p.metaClass.class.simpleName}"

// List all methods the MOP knows about
def methods = p.metaClass.methods*.name.unique().sort()
println "Methods (${methods.size()}): ${methods.take(10)}..."

// List meta-methods (GDK methods added by Groovy)
def metaMethods = p.metaClass.metaMethods*.name.unique().sort()
println "GDK MetaMethods (${metaMethods.size()}): ${metaMethods.take(10)}..."

// List properties
def props = p.metaClass.properties*.name.sort()
println "Properties: ${props}"

// Check if a method exists
println "Has greet()? ${p.metaClass.respondsTo(p, 'greet').size() > 0}"
println "Has fly()? ${p.metaClass.respondsTo(p, 'fly').size() > 0}"

MetaClass type: HandleMetaClass
Methods (10): [equals, getAge, getClass, getMetaClass, getName, greet, hashCode, notify, notifyAll, setAge]...
GDK MetaMethods (10): [addShutdownHook, any, asBoolean, asType, collect, dump, each, eachWithIndex, every, find]...
Properties: [age, class, name]
Has greet()? true
Has fly()? false

class MyClass {
    String message = 'default'

    String speak() { "Speaking: ${message}" }
}

def obj = new MyClass()

// Every Groovy class implements GroovyObject
println "Is GroovyObject? ${obj instanceof GroovyObject}"

// GroovyObject provides these methods:
// 1. invokeMethod(String name, Object args)
println obj.invokeMethod('speak', null)

// 2. getProperty(String name)
println obj.getProperty('message')

// 3. setProperty(String name, Object value)
obj.setProperty('message', 'Hello MOP!')
println obj.getProperty('message')

// 4. getMetaClass() / setMetaClass()
println "MetaClass: ${obj.getMetaClass().class.simpleName}"

// Normal Groovy code uses these under the hood:
// obj.speak()    → obj.invokeMethod('speak', null)
// obj.message    → obj.getProperty('message')
// obj.message=x  → obj.setProperty('message', x)
println "\nBoth routes produce same result:"
println "Direct: ${obj.speak()}"
println "MOP:    ${obj.invokeMethod('speak', null)}"

Is GroovyObject? true
Speaking: default
default
Hello MOP!
MetaClass: HandleMetaClass

Both routes produce same result:
Direct: Speaking: Hello MOP!
MOP:    Speaking: Hello MOP!

class ResolutionTracer {
    // Step 1: Class's own method
    def realMethod() { "Step 1: Found on the class itself" }

    // Step 3: methodMissing (called when method not found)
    def methodMissing(String name, def args) {
        "Step 3: methodMissing caught '${name}'"
    }
}

def obj = new ResolutionTracer()

// Call an existing method → Step 1
println obj.realMethod()

// Add a method via metaClass → Step 2
obj.metaClass.dynamicMethod = { -> "Step 2: Found on metaClass" }
println obj.dynamicMethod()

// Call a nonexistent method → Step 3
println obj.unknownMethod()

// The full resolution order for a regular Groovy object:
println "\n--- Resolution Order ---"
println "1. MetaClass checks for the method (includes class methods + added methods)"
println "2. If not found: methodMissing() on the object"
println "3. If no methodMissing: throw MissingMethodException"

Step 1: Found on the class itself
Step 2: Found on metaClass
Step 3: methodMissing caught 'unknownMethod'

--- Resolution Order ---
1. MetaClass checks for the method (includes class methods + added methods)
2. If not found: methodMissing() on the object
3. If no methodMissing: throw MissingMethodException

class NormalClass {
    def hello() { "NormalClass.hello()" }
    def methodMissing(String name, def args) { "NormalClass.methodMissing(${name})" }
}

class InterceptableClass implements GroovyInterceptable {
    def hello() { "InterceptableClass.hello()" }

    def invokeMethod(String name, def args) {
        def method = this.metaClass.getMetaMethod(name, args)
        if (method) {
            return "INTERCEPTED → ${method.invoke(this, args)}"
        }
        return "INTERCEPTED → no method '${name}' found"
    }
}

println "--- Normal Class ---"
def normal = new NormalClass()
println normal.hello()          // Direct to class method
println normal.goodbye()        // Goes to methodMissing

println "\n--- Interceptable Class ---"
def interceptable = new InterceptableClass()
println interceptable.hello()     // Goes through invokeMethod FIRST
println interceptable.goodbye()   // Also goes through invokeMethod

println "\n--- Key Difference ---"
println "Normal: existing methods bypass methodMissing"
println "Interceptable: ALL calls go through invokeMethod"

--- Normal Class ---
NormalClass.hello()
NormalClass.methodMissing(goodbye)

--- Interceptable Class ---
INTERCEPTED → InterceptableClass.hello()
INTERCEPTED → no method 'goodbye' found

--- Key Difference ---
Normal: existing methods bypass methodMissing
Interceptable: ALL calls go through invokeMethod

// The registry is accessible via GroovySystem
def registry = GroovySystem.metaClassRegistry
println "Registry type: ${registry.class.simpleName}"

// Get the MetaClass for String
def stringMC = registry.getMetaClass(String)
println "String MetaClass: ${stringMC.class.simpleName}"

// Add a method to String
String.metaClass.excited = { -> delegate.toUpperCase() + '!!!' }
println 'hello'.excited()

// Check the MetaClass changed
def newMC = registry.getMetaClass(String)
println "After adding method: ${newMC.class.simpleName}"

// Remove the custom MetaClass - resets to default
registry.removeMetaClass(String)

try {
    'hello'.excited()
} catch (MissingMethodException e) {
    println "After reset: excited() is gone"
}

// The default MetaClass is restored
def defaultMC = registry.getMetaClass(String)
println "Reset MetaClass: ${defaultMC.class.simpleName}"

// You can also iterate registered MetaClasses
println "\nSample registered classes:"
def iterator = registry.iterator()
def count = 0
while (iterator.hasNext() && count < 5) {
    def mc = iterator.next()
    println "  ${mc.theClass.simpleName} → ${mc.class.simpleName}"
    count++
}

Registry type: MetaClassRegistryImpl
String MetaClass: MetaClassImpl
HELLO!!!
After adding method: ExpandoMetaClass
After reset: excited() is gone
Reset MetaClass: MetaClassImpl

Sample registered classes:
  String → ExpandoMetaClass

class Calculator {
    int add(int a, int b) { a + b }
    double add(double a, double b) { a + b }
    int multiply(int a, int b) { a * b }
}

def calc = new Calculator()

// Find all 'add' methods
def addMethods = calc.metaClass.respondsTo(calc, 'add')
println "Overloaded 'add' methods: ${addMethods.size()}"
addMethods.each { method ->
    def params = method.nativeParameterTypes*.simpleName.join(', ')
    println "  ${method.returnType.simpleName} add(${params})"
}

// Find a specific method by parameter types
def intAdd = calc.metaClass.getMetaMethod('add', [1, 2] as Object[])
println "\nFound int add: ${intAdd}"
println "Invoke it: ${intAdd.invoke(calc, [3, 4] as Object[])}"

// List all declared methods (excluding Object methods)
def declaredMethods = calc.metaClass.methods.findAll {
    it.declaringClass.theClass == Calculator
}
println "\nDeclared methods:"
declaredMethods.each { m ->
    def params = m.nativeParameterTypes*.simpleName.join(', ')
    println "  ${m.returnType.simpleName} ${m.name}(${params})"
}

// Check if a method is a GDK (Groovy-added) method
def dumpMethod = calc.metaClass.metaMethods.find { it.name == 'dump' }
println "\ndump() is GDK method: ${dumpMethod != null}"
println "dump() declaring class: ${dumpMethod?.declaringClass?.theClass?.simpleName}"

Overloaded 'add' methods: 2
  double add(double, double)
  int add(int, int)

Found int add: public int Calculator.add(int,int)
Invoke it: 7

Declared methods:
  Lookup $getLookup()
  double add(double, double)
  int add(int, int)
  MetaClass getMetaClass()
  int multiply(int, int)
  void setMetaClass(MetaClass)

dump() is GDK method: true
dump() declaring class: Object

class PropertyDemo {
    String name = 'Alice'       // Groovy property (auto getter/setter)
    public String publicField = 'public'  // Plain field (no getter/setter)
    private String secret = 'hidden'

    // Custom getter overrides default
    String getTitle() { "Dr. ${name}" }

    def propertyMissing(String prop) {
        "dynamic:${prop}"
    }
}

def obj = new PropertyDemo()

// Property access resolution order:
// 1. MetaClass property (metaClass-added properties)
// 2. Groovy property (with getter/setter)
// 3. Map-like access (if the class supports it)
// 4. propertyMissing()

println "--- Property Access ---"
println "name: ${obj.name}"           // Step 2: getter
println "title: ${obj.title}"         // Step 2: custom getter
println "unknown: ${obj.unknown}"     // Step 4: propertyMissing

// Add a metaClass property (takes priority - Step 1)
obj.metaClass.priority = 'meta-property'
println "priority: ${obj.priority}"

// Inspect properties via MOP
println "\n--- MetaProperties ---"
obj.metaClass.properties.each { prop ->
    if (prop.name in ['name', 'publicField', 'class']) {
        println "  ${prop.name}: type=${prop.type.simpleName}"
    }
}

// Direct field access bypasses the MOP
println "\n--- Direct Field Access ---"
println "Direct field: ${obj.@publicField}"
println "Via MOP: ${obj.publicField}"

--- Property Access ---
name: Alice
title: Dr. Alice
unknown: dynamic:unknown

--- MetaProperties ---
  name: type=String
  publicField: type=String
  class: type=Class

--- Direct Field Access ---
Direct field: public
Via MOP: public

class LoggingMetaClass extends DelegatingMetaClass {
    private List log = []

    LoggingMetaClass(MetaClass delegate) {
        super(delegate)
    }

    Object invokeMethod(Object object, String methodName, Object[] arguments) {
        log << "invoke: ${methodName}(${arguments?.join(', ') ?: ''})"
        super.invokeMethod(object, methodName, arguments)
    }

    Object getProperty(Object object, String property) {
        log << "get: ${property}"
        super.getProperty(object, property)
    }

    void setProperty(Object object, String property, Object newValue) {
        log << "set: ${property} = ${newValue}"
        super.setProperty(object, property, newValue)
    }

    List getLog() { log }
}

class Account {
    String owner
    double balance = 0.0

    void deposit(double amount) { balance += amount }
    void withdraw(double amount) { balance -= amount }
}

// Install custom MetaClass
def originalMC = Account.metaClass
def loggingMC = new LoggingMetaClass(originalMC)
loggingMC.initialize()
Account.metaClass = loggingMC

def account = new Account()
account.owner = 'Alice'
account.deposit(100.0)
account.deposit(50.0)
account.withdraw(30.0)
println "Balance: ${account.balance}"

println "\nMOP Log:"
loggingMC.log.each { println "  ${it}" }

// Clean up
GroovySystem.metaClassRegistry.removeMetaClass(Account)

Balance: 120.0

MOP Log:
  set: owner = Alice
  invoke: deposit(100.0)
  invoke: deposit(50.0)
  invoke: withdraw(30.0)
  get: balance

// Java classes don't implement GroovyObject, but the MOP still works
def javaString = "Hello World"
println "String is GroovyObject? ${javaString instanceof GroovyObject}"

// Yet we can still use MOP features on Java classes
println "MetaClass: ${javaString.metaClass.class.simpleName}"

// GDK methods are added via the MOP to Java classes
println "reverse: ${javaString.reverse()}"        // GDK method
println "take(5): ${javaString.take(5)}"           // GDK method
println "padLeft: ${'42'.padLeft(5, '0')}"         // GDK method

// We can add methods to Java classes via MetaClass
ArrayList.metaClass.sum = { -> delegate.inject(0) { acc, val -> acc + val } }
def nums = [1, 2, 3, 4, 5] as ArrayList
println "Sum: ${nums.sum()}"

// How does the MOP handle Java classes?
// Answer: Groovy wraps Java objects in a special invoker
// that routes calls through the MetaClass before reaching Java methods

// Java class MetaMethod inspection
def stringMethods = javaString.metaClass.metaMethods
    .findAll { it.name.startsWith('to') }
    *.name
    .unique()
    .sort()
println "\nGDK 'to*' methods on String: ${stringMethods}"

// Cleanup
GroovySystem.metaClassRegistry.removeMetaClass(ArrayList)

String is GroovyObject? false
MetaClass: HandleMetaClass
reverse: dlroW olleH
take(5): Hello
padLeft: 00042
Sum: 15

GDK 'to*' methods on String: [toBigDecimal, toBigInteger, toBoolean, toCharacter, toDouble, toFloat, toInteger, toList, toLong, toSet, toShort, toString, toURI, toURL, tokenize]

class MopTracer {
    // Real method
    def realMethod() { "result from realMethod" }

    // methodMissing handler
    def methodMissing(String name, def args) {
        "result from methodMissing(${name})"
    }

    static void trace(obj, String methodName) {
        println "\n--- Tracing: ${methodName}() ---"

        // Check 1: MetaClass has the method?
        def metaMethod = obj.metaClass.getMetaMethod(methodName, [] as Object[])
        if (metaMethod) {
            println "  [1] MetaClass found: ${metaMethod.declaringClass.theClass.simpleName}.${methodName}()"
            println "      Method type: ${metaMethod.class.simpleName}"
            println "      Result: ${metaMethod.invoke(obj, [] as Object[])}"
            return
        }
        println "  [1] MetaClass: NOT FOUND"

        // Check 2: Is there a GDK metaMethod?
        def gdkMethod = obj.metaClass.metaMethods.find { it.name == methodName }
        if (gdkMethod) {
            println "  [2] GDK method found: ${gdkMethod.declaringClass.theClass.simpleName}.${methodName}()"
            return
        }
        println "  [2] GDK methods: NOT FOUND"

        // Check 3: Does the object have methodMissing?
        def hasMissing = obj.metaClass.respondsTo(obj, 'methodMissing')
        if (hasMissing) {
            println "  [3] methodMissing() will handle it"
            def result = obj."${methodName}"()
            println "      Result: ${result}"
            return
        }
        println "  [3] methodMissing: NOT DEFINED"
        println "  [4] MissingMethodException will be thrown"
    }
}

def obj = new MopTracer()

// Trace different method calls
MopTracer.trace(obj, 'realMethod')
MopTracer.trace(obj, 'getClass')
MopTracer.trace(obj, 'fantasticMethod')

// Add a metaClass method and trace it
obj.metaClass.addedMethod = { -> "I was added!" }
MopTracer.trace(obj, 'addedMethod')

--- Tracing: realMethod() ---
  [1] MetaClass found: MopTracer.realMethod()
      Method type: CachedMethod
      Result: result from realMethod

--- Tracing: getClass() ---
  [1] MetaClass found: Object.getClass()
      Method type: CachedMethod
      Result: class MopTracer

--- Tracing: fantasticMethod() ---
  [1] MetaClass: NOT FOUND
  [2] GDK methods: NOT FOUND
  [3] methodMissing() will handle it
      Result: result from methodMissing(fantasticMethod)

--- Tracing: addedMethod() ---
  [1] MetaClass found: MopTracer.addedMethod()
      Method type: ClosureMetaMethod
      Result: I was added!

class Service {
    String name = 'MyService'
    def start() { "${name} started" }
    def stop() { "${name} stopped" }
    def status(String detail) { "${name}: ${detail}" }
}

def svc = new Service()

// respondsTo - check if a method exists
println "Has start()? ${svc.metaClass.respondsTo(svc, 'start') as boolean}"
println "Has restart()? ${svc.metaClass.respondsTo(svc, 'restart') as boolean}"
println "Has status(String)? ${svc.metaClass.respondsTo(svc, 'status', String) as boolean}"
println "Has status(int)? ${svc.metaClass.respondsTo(svc, 'status', Integer) as boolean}"

// hasProperty - check if a property exists
println "\nHas 'name'? ${svc.metaClass.hasProperty(svc, 'name') != null}"
println "Has 'version'? ${svc.metaClass.hasProperty(svc, 'version') != null}"

// Practical: safe method invocation
def safeCaller = { obj, String method, Object... args ->
    if (obj.metaClass.respondsTo(obj, method, args)) {
        return obj."${method}"(*args)
    }
    return "Method '${method}' not available"
}

println "\n--- Safe Calls ---"
println safeCaller(svc, 'start')
println safeCaller(svc, 'status', 'running')
println safeCaller(svc, 'restart')

// getAttribute vs getProperty - bypasses getters
println "\n--- getAttribute (bypasses getter) ---"
svc.metaClass.getAttribute(svc, 'name').with { println "Attribute: ${it}" }
svc.metaClass.getProperty(svc, 'name').with { println "Property: ${it}" }

Has start()? true
Has restart()? false
Has status(String)? true
Has status(int)? false

Has 'name'? true
Has 'version'? false

--- Safe Calls ---
MyService started
MyService: running
Method 'restart' not available

--- getAttribute (bypasses getter) ---
Attribute: MyService
Property: MyService

// MetaClass hierarchy:
// MetaClass (interface)
//   ├── MetaClassImpl (default for all classes)
//   ├── ExpandoMetaClass (supports adding methods at runtime)
//   ├── DelegatingMetaClass (wraps another MetaClass)
//   ├── ProxyMetaClass (deprecated, use DelegatingMetaClass)
//   └── HandleMetaClass (wrapper returned by .metaClass property)

class Simple { }

def s = new Simple()

// Default MetaClass
println "Default: ${InvokerHelper.getMetaClass(s).class.simpleName}"

// After adding a method, it becomes ExpandoMetaClass
Simple.metaClass.hello = { -> "hello" }
println "After metaClass mod: ${InvokerHelper.getMetaClass(s).class.simpleName}"

// HandleMetaClass is the wrapper you see via .metaClass
println "Via .metaClass: ${s.metaClass.class.simpleName}"

// Clean up
GroovySystem.metaClassRegistry.removeMetaClass(Simple)
println "After cleanup: ${InvokerHelper.getMetaClass(new Simple()).class.simpleName}"

Default: MetaClassImpl
After metaClass mod: ExpandoMetaClass
Via .metaClass: HandleMetaClass
After cleanup: MetaClassImpl

FOR A REGULAR GROOVY OBJECT (no GroovyInterceptable):
─────────────────────────────────────────────────────
1. MetaClass.invokeMethod() is called
2. MetaClass searches for the method in this order:
   a. Methods added to the metaClass (ExpandoMetaClass methods)
   b. Methods declared on the class itself
   c. Methods inherited from superclasses
   d. GDK methods (from DefaultGroovyMethods)
3. If found → invoke the method
4. If NOT found → call object.methodMissing(name, args)
5. If methodMissing not defined → throw MissingMethodException

FOR A GROOVYINTERCEPTABLE OBJECT:
──────────────────────────────────
1. object.invokeMethod(name, args) is called FIRST
2. Your invokeMethod implementation decides what to do
   (typically looks up the real method via metaClass and invokes it)
3. If you don't handle it → throw MissingMethodException

FOR A JAVA OBJECT (not a GroovyObject):
───────────────────────────────────────
1. Groovy wraps the call via ScriptBytecodeAdapter
2. MetaClass is looked up from MetaClassRegistry
3. Same resolution as step 2a-2d above
4. If NOT found → throw MissingMethodException
   (no methodMissing, since it's not a Groovy class)

// Groovy uses CallSite caching to optimize MOP dispatch
// After the first call, the resolution result is cached

class PerfTest {
    int value = 0
    void increment() { value++ }
}

def obj = new PerfTest()

// First call: full MOP resolution (slower)
// Subsequent calls: cached (much faster)

def start = System.nanoTime()
100_000.times { obj.increment() }
def elapsed = (System.nanoTime() - start) / 1_000_000.0

println "100K calls via MOP: ${String.format('%.2f', elapsed)} ms"
println "Value: ${obj.value}"

// With @CompileStatic, there's no MOP overhead at all
// But you lose dynamic features
println "\nOptimization hierarchy (fastest to slowest):"
println "  1. @CompileStatic methods (no MOP)"
println "  2. Cached call sites (after first call)"
println "  3. MetaClass methods"
println "  4. methodMissing (uncached)"
println "  5. GroovyInterceptable invokeMethod"

100K calls via MOP: 42.15 ms
Value: 100000

Optimization hierarchy (fastest to slowest):
  1. @CompileStatic methods (no MOP)
  2. Cached call sites (after first call)
  3. MetaClass methods
  4. methodMissing (uncached)
  5. GroovyInterceptable invokeMethod

// Test 1: Adds a method to String
String.metaClass.testHelper = { -> "test helper result" }
println "Test 1: ${'hello'.testHelper()}"

// Test 2: Assumes String is clean - FAILS if Test 1 didn't clean up!
// This is a common source of flaky tests
println "Test 2: String still has testHelper? ${String.metaClass.respondsTo('', 'testHelper') as boolean}"

// Fix: Always clean up in test teardown
GroovySystem.metaClassRegistry.removeMetaClass(String)
println "After cleanup: String has testHelper? ${String.metaClass.respondsTo('', 'testHelper') as boolean}"

// Better fix: Use per-instance metaClass or Spock's @ConfineMetaClassChanges
println "\nBest practice: Use per-instance metaClass in tests"
def s = "hello"
s.metaClass.testHelper = { -> "only on this instance" }
println s.testHelper()
println "Other strings affected? ${'world'.metaClass.respondsTo('world', 'testHelper') as boolean}"

Test 1: test helper result
Test 2: String still has testHelper? true
After cleanup: String has testHelper? false

Best practice: Use per-instance metaClass in tests
only on this instance
Other strings affected? false

// Pitfall: calling methods inside invokeMethod can cause infinite recursion

class DangerousInterceptor implements GroovyInterceptable {
    def hello() { "Hello!" }

    def invokeMethod(String name, def args) {
        // DANGER: calling println here also goes through invokeMethod!
        // println "Calling ${name}"  // This would cause StackOverflowError

        // Safe: use direct metaMethod invocation
        def method = this.metaClass.getMetaMethod(name, args)
        if (method) {
            return method.invoke(this, args)
        }
        throw new MissingMethodException(name, this.class, args)
    }
}

def d = new DangerousInterceptor()
println d.hello()

// The fix: in GroovyInterceptable, always use metaClass.getMetaMethod()
// to invoke methods, never call them directly from within invokeMethod
println "Safe invocation via getMetaMethod works correctly"

Hello!
Safe invocation via getMetaMethod works correctly