package sqlancer;

import java.time.Duration;

import java.time.Instant;

import java.util.ArrayList;

import java.util.List;

import sqlancer.common.query.Query;

public class StatementReducer<G extends GlobalState<O, ?, C>, O extends DBMSSpecificOptions<?>, C extends SQLancerDBConnection>

implements Reducer<G> {

private final DatabaseProvider<G, O, C> provider;

private boolean observedChange;

private int partitionNum;

public StatementReducer(DatabaseProvider<G, O, C> provider) {

this.provider = provider;

}

private boolean hasNotReachedLimit(long curr, long limit) {

if (limit == MainOptions.NO_REDUCE_LIMIT) {

return true;

}

return curr < limit;

}

@SuppressWarnings("unchecked")

@Override

public void reduce(G state, Reproducer<G> reproducer, G newGlobalState) throws Exception {

long maxReduceTime = state.getOptions().getMaxStatementReduceTime();

long maxReduceSteps = state.getOptions().getMaxStatementReduceSteps();

List<Query<C>> knownToReproduceBugStatements = new ArrayList<>();

for (Query<?> stat : state.getState().getStatements()) {

knownToReproduceBugStatements.add((Query<C>) stat);

}

System.out.println("Starting query:");

printQueries(knownToReproduceBugStatements);

System.out.println();

if (knownToReproduceBugStatements.size() <= 1) {

return;

}

Instant timeOfReductionBegins = Instant.now();

long currentReduceSteps = 0;

long currentReduceTime = 0;

partitionNum = 2;

while (knownToReproduceBugStatements.size() >= 2 && hasNotReachedLimit(currentReduceSteps, maxReduceSteps)

&& hasNotReachedLimit(currentReduceTime, maxReduceTime)) {

observedChange = false;

knownToReproduceBugStatements = tryReduction(state, reproducer, newGlobalState,

knownToReproduceBugStatements);

if (!observedChange) {

if (partitionNum == knownToReproduceBugStatements.size()) {

break;

}

// increase the search granularity

partitionNum = Math.min(partitionNum * 2, knownToReproduceBugStatements.size());

currentReduceSteps++;

Instant currentInstant = Instant.now();

currentReduceTime = Duration.between(currentInstant, timeOfReductionBegins).getSeconds();

}

}

System.out.println("Reduced query:");

printQueries(knownToReproduceBugStatements);

newGlobalState.getState().setStatements(new ArrayList<>(knownToReproduceBugStatements));

}

private List<Query<C>> tryReduction(G state, // NOPMD

Reproducer<G> reproducer, G newGlobalState, List<Query<C>> knownToReproduceBugStatements) throws Exception {

List<Query<C>> statements = knownToReproduceBugStatements;

int start = 0;

int subLength = statements.size() / partitionNum;

while (start < statements.size()) {

// newStatements = candidate[:start] + candidate[start+subLength:]

// in other word, remove [start, start+subLength) from candidates

try (C con2 = provider.createDatabase(newGlobalState)) {

newGlobalState.setConnection(con2);

List<Query<C>> candidateStatements = new ArrayList<>(statements);

candidateStatements.subList(start, start + subLength).clear();

newGlobalState.getState().setStatements(new ArrayList<>(candidateStatements));

for (Query<C> s : candidateStatements) {

try {

s.execute(newGlobalState);

} catch (Throwable ignoredException) {

// ignore

}

}

try {

if (reproducer.bugStillTriggers(newGlobalState)) {

observedChange = true;

statements = candidateStatements;

partitionNum = Math.max(partitionNum - 1, 2);

break;

// reproducer.outputHook((SQLite3GlobalState) newGlobalState);

// state.getLogger().logReduced(newGlobalState.getState());

}

} catch (Throwable ignoredException) {

}

}

start = start + subLength;

}

return statements;

}

private void printQueries(List<Query<C>> statements) {

System.out.println("===============================");

for (Query<?> q : statements) {

System.out.println(q.getLogString());

}

System.out.println("===============================");

}

}