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 {}

    rootProject: Project,
    buildSrcClassLoaderScope: ClassLoaderScope,
    classLoaderHash: HashCode,
    fileCollectionFactory: FileCollectionFactory,
    inputFingerprinter: InputFingerprinter,
    workspaceProvider: KotlinDslWorkspaceProvider,
) : AbstractStage1BlockAccessorsUnitOfWork(
    rootProject, buildSrcClassLoaderScope, classLoaderHash, fileCollectionFactory, inputFingerprinter, workspaceProvider
) {

        """
        succeeds('noOutputs', "--build-cache")

        then:
        def result = operations.first(SnapshotTaskInputsBuildOperationType).result
        result.hash == null
        result.classLoaderHash == null
        result.actionClassLoaderHashes == null
        result.actionClassNames == null
        result.inputValueHashes == null
        result.outputPropertyNames == null
    }

    rootProject: Project,
    buildSrcClassLoaderScope: ClassLoaderScope,
    classLoaderHash: HashCode,
    fileCollectionFactory: FileCollectionFactory,
    inputFingerprinter: InputFingerprinter,
    workspaceProvider: KotlinDslWorkspaceProvider,
) : AbstractStage1BlockAccessorsUnitOfWork(
    rootProject, buildSrcClassLoaderScope, classLoaderHash, fileCollectionFactory, inputFingerprinter, workspaceProvider
) {