*
 * @see org.gradle.cache.internal.CompositeCleanupAction
 * @see CacheBuilder#withCleanupStrategy(CacheCleanupStrategy)
 */
public interface CleanupAction {

    void clean(CleanableStore cleanableStore, CleanupProgressMonitor progressMonitor);

    CleanupAction NO_OP = new CleanupAction() {
        @Override
        public void clean(CleanableStore cleanableStore, CleanupProgressMonitor progressMonitor) {
            // no-op

        return new DefaultCacheCleanupStrategy(cleanupAction, cleanupFrequency);
    }

    public static DefaultCacheCleanupStrategy from(CleanupAction cleanupAction) {
        return new DefaultCacheCleanupStrategy(cleanupAction, () -> CleanupFrequency.DAILY);
    }

    @Override
    public CleanupAction getCleanupAction() {
        return cleanupAction;
    }

        private Builder() {
        }

        public Builder add(CleanupAction... actions) {
            Collections.addAll(cleanups, actions);
            return this;
        }

        public Builder add(File baseDir, CleanupAction... actions) {
            for (CleanupAction action : actions) {
                cleanups.add(new ScopedCleanupAction(baseDir, action));
            }

        @Override
        public CleanupAction getCleanupAction() {
            return CleanupAction.NO_OP;
        }

        @Override
        public CleanupFrequency getCleanupFrequency() {
            return CleanupFrequency.NEVER;
        }
    };

    /**
     * Returns the action to perform on cleanup.
     */
    CleanupAction getCleanupAction();

    /**

    def usedGradleVersions = Mock(UsedGradleVersions) {
        getUsedGradleVersions() >> ([] as SortedSet)
    }
    def progressMonitor = Mock(CleanupProgressMonitor)

    @Subject def cleanupAction = new WrapperDistributionCleanupAction(userHomeDir, usedGradleVersions)

    def "deletes distributions for unused versions"() {
        given:

        this.cacheDisplayName = cacheDisplayName;
        this.baseDir = baseDir;
        this.cleanupAction = cleanupAction;
        this.executorFactory = executorFactory;
        this.operations = new CacheAccessOperationsStack();

        store.open()
        store.close()

        then:
        gcFile.lastModified() > modificationTimeBefore
        1 * cacheCleanup.cleanupAction >> cleanupAction
        1 * cacheCleanup.cleanupFrequency >> CleanupFrequency.DAILY
        1 * cleanupAction.clean(store, _)
        0 * _
    }

    def "fails gracefully if cleanup action fails"() {
        when:
        store.open()

    def currentCacheDir = createVersionSpecificCacheDir(currentVersion, NOT_USED_WITHIN_30_DAYS)
    def progressMonitor = Mock(CleanupProgressMonitor)
    def deleter = TestFiles.deleter()

    @Subject def cleanupAction = new VersionSpecificCacheCleanupAction(cachesDir, daysAgo(30), daysAgo(7), deleter, CleanupFrequency.DAILY)

    def "cleans up unused version-specific cache directories"() {
        given:

        getBaseDir() >> cacheDir
    }
    def fileAccessTimeJournal = Spy(ModificationTimeFileAccessTimeJournal)
    def progressMonitor = Stub(CleanupProgressMonitor)
    @Subject def cleanupAction = new LeastRecentlyUsedCacheCleanup(
        new SingleDepthFilesFinder(1), fileAccessTimeJournal, TimestampSuppliers.daysAgo(1))

    def "finds files to delete when files are old"() {
        given:

            @Override
            public void run(BuildOperationContext context) {
                cleanupAction.execute(new DefaultCleanupProgressMonitor(context));
            }

            @Override
            public BuildOperationDescriptor.Builder description() {
                return BuildOperationDescriptor.displayName(cleanupAction.getDisplayName());
            }
        });
    }