import org.gradle.internal.snapshot.ValueSnapshot;

import javax.annotation.Nullable;
import java.util.LinkedHashSet;
import java.util.Set;

public class IsolatedSet extends AbstractSetSnapshot<Isolatable<?>> implements Isolatable<Set<Object>> {
    public IsolatedSet(ImmutableSet<Isolatable<?>> elements) {
        super(elements);
    }

    @Override
    public ValueSnapshot asSnapshot() {

    }
}


object IsolatedSetCodec : Codec<IsolatedSet> {
    override suspend fun WriteContext.encode(value: IsolatedSet) {
        write(value.elements)
    }

    override suspend fun ReadContext.decode(): IsolatedSet {
        val elements = readNonNull<ImmutableSet<Isolatable<*>>>()
        return IsolatedSet(elements)
    }
}


object IsolatedListCodec : Codec<IsolatedList> {

        }
    }

    private class IsolatedSetSerializer extends IsolatableSerializer<IsolatedSet> {
        @Override
        protected void serialize(Encoder encoder, IsolatedSet value) throws Exception {
            writeIsolatableSequence(encoder, value.getElements());
        }

        @Override
        protected IsolatedSet deserialize(Decoder decoder) throws Exception {

        def isolated1 = isolatableFactory.isolate(original1)
        isolated1 instanceof IsolatedSet
        def copy1 = isolated1.isolate()
        copy1 == [] as Set
        !copy1.is(original1)

        def original2 = ["123"] as Set
        def isolated2 = isolatableFactory.isolate(original2)
        isolated2 instanceof IsolatedSet
        def copy2 = isolated2.isolate()
        copy2 == ["123"] as Set

            return new IsolatedList(elements);
        }

        @Override
        public Isolatable<?> set(ImmutableSet<Isolatable<?>> elements) {
            return new IsolatedSet(elements);
        }

        @Override
        public Isolatable<?> map(ImmutableList<MapEntrySnapshot<Isolatable<?>>> elements) {
            return new IsolatedMap(elements);
        }