* limitations under the License.
 */

package org.gradle.internal.metaobject;

import org.gradle.api.internal.DynamicObjectAware;

public abstract class DynamicObjectUtil {
    public static DynamicObject asDynamicObject(Object object) {
        if (object instanceof DynamicObject) {
            return (DynamicObject)object;
        } else if (object instanceof DynamicObjectAware) {

            }
            DynamicDelegatedPropertiesMock.SettingsMock(
                mock<DynamicAwareSettingsMockType>(name = "settings") {
                    on { asDynamicObject } doReturn dynamicObject
                    on { gradle } doReturn gradleMock
                },
                dynamicObject
            )
        }

    private

    public ConfigureDelegate(Closure<?> configureClosure, Object delegate) {
        _original_owner = configureClosure.getOwner();
        _owner = DynamicObjectUtil.asDynamicObject(_original_owner);
        _delegate = DynamicObjectUtil.asDynamicObject(delegate);
    }

    @Override
    public String toString() {
        return _delegate.toString();
    }

    @Nullable
    public Object _original_owner() {

    
    def "fails lazily for non dsl object"() {
        when:
        def dsl = new DslObject(new Object())

        then:
        notThrown(Exception)

        when:
        dsl.asDynamicObject

        then:
        thrown(IllegalStateException)
    }

    static class Thing {}

    def "works for dsl object"() {
        when:

ant: org.gradle.api.internal.project.DefaultAntBuilder@12345
antBuilderFactory: org.gradle.api.internal.project.DefaultAntBuilderFactory@12345
artifacts: org.gradle.api.internal.artifacts.dsl.DefaultArtifactHandler_Decorated@12345
asDynamicObject: DynamicObject for project ':api'

                ((NamedDomainObjectContainer) property).configure((Closure) arguments[0]);
                return DynamicInvokeResult.found();
            }
            DynamicObject dynamicObject = DynamicObjectUtil.asDynamicObject(property);
            if (dynamicObject.hasMethod("call", arguments)) {
                return dynamicObject.tryInvokeMethod("call", arguments);
            }
        }
        return DynamicInvokeResult.notFound();

    }


private
fun dynamicObjectFor(target: Any): DynamicObject =
    (target as? DynamicObjectAware ?: DslObject(target)).asDynamicObject


private
class NullableDynamicPropertyDelegate(
    private val dynamicLookupRoutine: DynamicLookupRoutine,
    private val owner: DynamicObject,
    private val name: String
) : PropertyDelegate {

            dynamicTarget = scriptObject;
        }

        public void setTarget(Object target) {
            dynamicTarget = DynamicObjectUtil.asDynamicObject(target);
        }

        @Override
        public Map<String, ?> getProperties() {
            return dynamicTarget.getProperties();
        }

        @Override

        buildFile << """
            ${callbackWorkerLeaseService}

            tasks.matching { it.name == '${taskName}' }.all { task ->
                def workerLeaseService = task.asDynamicObject.publicType.getDeclaredField("workerLeaseService")
                workerLeaseService.setAccessible(true)

    public static <T> T configureByMap(Map<?, ?> properties, T delegate) {
        if (properties.isEmpty()) {
            return delegate;
        }
        DynamicObject dynamicObject = DynamicObjectUtil.asDynamicObject(delegate);

        for (Map.Entry<?, ?> entry : properties.entrySet()) {
            String name = entry.getKey().toString();
            Object value = entry.getValue();