import org.gradle.internal.serialize.graph.WriteContext
import org.gradle.internal.serialize.graph.readNonNull


object ResolveArtifactNodeCodec : Codec<DefaultResolvableArtifact.ResolveAction> {
    override suspend fun WriteContext.encode(value: DefaultResolvableArtifact.ResolveAction) {
        // TODO - should just discard this action. The artifact location will already have been resolved during writing to the cache

        this.taskNodeFactory = taskNodeFactory;
    }

    @Override
    public boolean resolve(Task task, Object node, final Action<? super Node> resolveAction) {
        return TASK_AS_TASK.resolve(task, node, resolved -> resolveAction.execute(taskNodeFactory.getOrCreateNode(resolved)));
    }

     */
    boolean resolve(Task task, Object node, Action<? super T> resolveAction);

    /**
     * Resolves dependencies to {@link Task} objects.
     */
    WorkDependencyResolver<Task> TASK_AS_TASK = new WorkDependencyResolver<Task>() {
        @Override
        public boolean resolve(Task originalTask, Object node, Action<? super Task> resolveAction) {
            if (node instanceof TaskDependency) {

    public boolean resolve(Task task, Object node, Action<? super Node> resolveAction) {
        if (node instanceof DefaultTransformNodeDependency) {
            DefaultTransformNodeDependency transformNodeDependency = (DefaultTransformNodeDependency) node;
            for (TransformStepNode transformStepNode : transformNodeDependency.getNodes()) {
                resolveAction.execute(transformStepNode);
            }
            return true;

    public File getFile() {
        fileSource.finalizeIfNotAlready();
        return fileSource.get();
    }

    public static class ResolveAction implements WorkNodeAction {
        private final DefaultResolvableArtifact artifact;

        public ResolveAction(DefaultResolvableArtifact artifact) {
            this.artifact = artifact;
        }

        @Override
        public String toString() {

    @Override
    public boolean resolve(Task task, final Object node, Action<? super Node> resolveAction) {
        if (!(node instanceof WorkNodeAction)) {
            return false;
        }

        WorkNodeAction action = (WorkNodeAction) node;
        ActionNode actionNode = actionNodeFor(action);
        resolveAction.execute(actionNode);
        return true;
    }

    @Override
    public void discardAll() {

    private static final WorkDependencyResolver<Task> IGNORE_ARTIFACT_TRANSFORM_RESOLVER = new WorkDependencyResolver<Task>() {
        @Override
        public boolean resolve(Task task, Object node, Action<? super Task> resolveAction) {
            // Ignore artifact transforms
            return node instanceof TransformNodeDependency || node instanceof WorkNodeAction;
        }
    };

    private Supplier<String> toStringProvider = null;