import org.gradle.internal.snapshot.ValueSnapshotter;

import javax.annotation.Nullable;
import java.io.File;

public class FileValueSnapshot extends AbstractScalarValueSnapshot<String> implements Isolatable<File> {
    public FileValueSnapshot(File value) {
        super(value.getPath());
    }

    public FileValueSnapshot(String value) {
        super(value);
    }

    @Override
    public ValueSnapshot asSnapshot() {

        @Override
        protected void serialize(Encoder encoder, FileValueSnapshot value) throws Exception {
            encoder.writeString(value.getValue());
        }

        @Override
        protected FileValueSnapshot deserialize(Decoder decoder) throws Exception {
            return new FileValueSnapshot(decoder.readString());
        }

            encoder.writeSmallInt(HASH_SNAPSHOT);
            encoder.writeBinary(hashSnapshot.getValue().toByteArray());
        } else if (snapshot instanceof FileValueSnapshot) {
            FileValueSnapshot fileSnapshot = (FileValueSnapshot) snapshot;
            encoder.writeSmallInt(FILE_SNAPSHOT);
            encoder.writeString(fileSnapshot.getValue());
        } else if (snapshot instanceof EnumValueSnapshot) {

    }
}


object FileValueSnapshotCodec : Codec<FileValueSnapshot> {
    override suspend fun WriteContext.encode(value: FileValueSnapshot) {
        writeString(value.value)
    }

    override suspend fun ReadContext.decode(): FileValueSnapshot {
        val value = readString()
        return FileValueSnapshot(value)
    }
}

        def original = new EnumValueSnapshot(Thing.THING_1)
        write(original)

        expect:
        original == written
    }

    def "serializes file properties"() {
        def original = new FileValueSnapshot(new File("abc"))
        write(original)

        expect:
        original == written
    }

    def "serializes null properties"() {
        def original = NullValueSnapshot.INSTANCE

                classLoaderHasher.getClassLoaderHash(implementation.getClass().getClassLoader()));
        }

        @Override
        public ValueSnapshot fileValue(File value) {
            return new FileValueSnapshot(value);
        }

        @Override
        public ValueSnapshot attributeValue(Attribute<?> value) {
            return new AttributeDefinitionSnapshot(value, classLoaderHasher);
        }

            throw new IsolationException(implementationClassIdentifier);
        }

        @Override
        public Isolatable<?> fileValue(File value) {
            return new FileValueSnapshot(value);
        }

        @Override
        public Isolatable<?> attributeValue(Attribute<?> value) {
            return new AttributeDefinitionSnapshot(value, classLoaderHasher);
        }

    }

    def "creates isolated file"() {
        expect:
        def original = new File("abc")
        def isolated = isolatableFactory.isolate(original)
        isolated instanceof FileValueSnapshot
        isolated.isolate() == original
    }

    def "can coerce file value"() {
        expect:
        def original = new File("abc")
        def isolated = isolatableFactory.isolate(original)

    }

    def "creates snapshot for file"() {
        expect:
        def snapshot = snapshotter.snapshot(new File("abc"))
        snapshot instanceof FileValueSnapshot
        snapshot == snapshotter.snapshot(new File("abc"))
        snapshot != snapshotter.snapshot(new File("abc").getAbsoluteFile())
        snapshot != snapshotter.snapshot(new File("123"))