import java.util.Objects;

public class ClassImplementationSnapshot extends ImplementationSnapshot {
    private final HashCode classLoaderHash;

    public ClassImplementationSnapshot(String classIdentifier, HashCode classLoaderHash) {
        super(classIdentifier);
        this.classLoaderHash = classLoaderHash;
    }

    @Override
    public void appendToHasher(Hasher hasher) {

        String className = type.getName();
        HashCode classLoaderHash = classLoaderHasher.getClassLoaderHash(type.getClassLoader());
        return of(className, classLoaderHash, isLambdaClass(type), null);
    }

    public static ImplementationSnapshot of(String className, @Nullable HashCode classLoaderHash) {
        return of(className, classLoaderHash, isLambdaClassName(className), null);
    }

    private final HashCode classLoaderHash;

    private final String functionalInterfaceClass;
    private final String implClass;
    private final String implMethodName;
    private final String implMethodSignature;
    private final int implMethodKind;

    public LambdaImplementationSnapshot(HashCode classLoaderHash, SerializedLambda lambda) {
        this(

                val buildSrcClassLoaderScope = baseClassLoaderScopeOf(rootProject)
                val classLoaderHash = requireNotNull(classLoaderHierarchyHasher.getClassLoaderHash(buildSrcClassLoaderScope.exportClassLoader))
                val versionCatalogAccessors = generateVersionCatalogAccessors(rootProject, buildSrcClassLoaderScope, classLoaderHash)

            protected ImplementationSnapshot readAdditionalData(String classIdentifier, Decoder decoder) throws Exception {
                HashCode classLoaderHash = hashCodeSerializer.read(decoder);
                return new ClassImplementationSnapshot(classIdentifier, classLoaderHash);
            }

            @Override

    static final SHARED_CLASSLOADER_HASH = TestHashCodes.hashCodeFrom(1234)

    def "class name #className is lambda: #lambda"() {
        HashCode classloaderHash = TestHashCodes.hashCodeFrom(1234)

        expect:
        def snapshot = ImplementationSnapshot.of(className, classloaderHash)
        (snapshot instanceof UnknownImplementationSnapshot) == lambda

        where:
        className                                    | lambda

                executable
        ).accept(visitor)
        return visitor.changes*.message
    }

    private ClassImplementationSnapshot impl(Class<?> type, HashCode classLoaderHash = taskLoaderHash) {
        new ClassImplementationSnapshot(type.getName(), classLoaderHash)
    }

    private class SimpleTask extends DefaultTask {}
    private class PreviousTask extends DefaultTask {}

        write(original)

        expect:
        ImplementationSnapshot copy = written as ImplementationSnapshot
        copy.classIdentifier == original.classIdentifier
        copy.classLoaderHash == null
        copy.unknownReason == UnknownImplementationSnapshot.UnknownReason.UNKNOWN_CLASSLOADER
    }

    def "serializes implementation properties with untracked lambda"() {