import org.gradle.internal.hash.HashCode;

/**
 * Captures the state a {@link org.gradle.internal.execution.UnitOfWork} after the previous execution has finished.
 */
public interface PreviousExecutionState extends ExecutionInputState, ExecutionOutputState {

    /**
     * Returns the cache key from the previous execution.
     */
    HashCode getCacheKey();

    /**
     * {@inheritDoc}
     */

        def previousExecutionState = Stub(PreviousExecutionState)
        def outputFileSnapshots = ImmutableSortedMap.of("output", outputFileSnapshot)

        _ * context.previousExecutionState >> Optional.of(previousExecutionState)
        _ * previousExecutionState.inputProperties >> ImmutableSortedMap.of()
        _ * previousExecutionState.inputFileProperties >> ImmutableSortedMap.of()

import org.gradle.internal.execution.history.PreviousExecutionState;

import javax.annotation.Nullable;
import java.util.Optional;

public class PreviousExecutionContext extends WorkspaceContext {
    private final PreviousExecutionState previousExecutionState;

    public PreviousExecutionContext(WorkspaceContext parent, @Nullable PreviousExecutionState previousExecutionState) {
        super(parent);

        when:
        step.execute(work, context)
        then:
        _ * context.previousExecutionState >> Optional.of(previousExecutionState)
        1 * previousExecutionState.inputProperties >> ImmutableSortedMap.of()
        1 * previousExecutionState.inputFileProperties >> ImmutableSortedMap.of()
        1 * previousExecutionState.outputFilesProducedByWork >> previousOutputSnapshots

        _ * context.previousExecutionState >> Optional.empty()

        then:
        interaction { expectStore(false, outputFilesProducedByWork) }
        0 * _
    }

    def "output snapshots are stored after failed execution with changed outputs"() {
        def previousExecutionState = Mock(PreviousExecutionState)

        when:
        def result = step.execute(work, context)

        }
        @SuppressWarnings("OptionalGetWithoutIsPresent")
        PreviousExecutionState previousExecutionState = context.getPreviousExecutionState().get();
        ExecutionOutputState executionOutputState = new DefaultExecutionOutputState(true, previousExecutionState.getOutputFilesProducedByWork(), previousExecutionState.getOriginMetadata(), true);

        _ * context.beforeExecutionState >> Optional.of(beforeExecutionState)
        _ * executionStateChanges.changeDescriptions >> ImmutableList.of()

        _ * context.previousExecutionState >> Optional.of(previousExecutionState)
        _ * previousExecutionState.cacheKey >> cacheKey
        _ * context.validationProblems >> ImmutableList.of()
        1 * delegate.execute(work, { CachingContext context ->

        _ * context.previousExecutionState >> Optional.of(previousExecutionState)
        _ * context.validationProblems >> ImmutableList.of(Mock(Problem))
        _ * context.previousExecutionState >> Optional.empty()
        0 * _
    }

    def "provides input file changes when history is available"() {
        def previousExecutionState = Mock(PreviousExecutionState)
        def changes = Mock(ExecutionStateChanges)

        then:
        1 * executionHistoryStore.load(uniqueId) >> Optional.of(previousExecutionState)

        then:
        result == delegateResult
        1 * delegate.execute(work, _) >> { UnitOfWork work, PreviousExecutionContext previousExecutionContext ->
            assert previousExecutionContext.previousExecutionState.get() == previousExecutionState
            return delegateResult
        }

        then:

        Identity identity = context.getIdentity();
        PreviousExecutionState previousExecutionState = context.getHistory()
            .flatMap(history -> history.load(identity.getUniqueId()))
            .orElse(null);
        R result = delegate.execute(work, new PreviousExecutionContext(context, previousExecutionState));

        // If we did not capture any outputs after execution, remove them from history