package au.id.zancanaro.javacheck.state;

import java.util.*;

public class CommandList<S> {
    private final List<GeneratedCommand<S, ?, ?>> commands;
    private final S initialState;

    public CommandList(S initialState, List<GeneratedCommand<S, ?, ?>> commands) {
        this.initialState = initialState;
        this.commands = new ArrayList<>(commands);
    }

    public int size() {
        return commands.size();
    }

    public CommandResult<S> run(S initialState) {
        Map<Integer, Object> values = new HashMap<>();
        CommandResult<S> result = CommandResult.success(initialState);
        for (GeneratedCommand<S, ?, ?> generated : commands) {
            result = runRealCommand(generated, result.getState(), values);
            if (result.isFailed()) {
                break;
            }
        }
        return result;
    }

    private static <S, A, R> CommandResult<S> runRealCommand(
            GeneratedCommand<S, A, R> generated,
            S state,
            Map<Integer, Object> values) {
        int id = generated.getId();
        Command<S, A, R> command = generated.getCommand();
        A args = generated.getArgs();
        try {
            if (!command.preCondition(state, args)) {
                return CommandResult.fail(state, new Error("Precondition failed"));
            }
            final S oldState = state;
            R result = CommandValue.withValues(values, () -> command.runCommand(oldState, args));
            values.put(id, result);
            final S newState = CommandValue.withValues(values, () ->
                    command.nextState(oldState, args, new CommandValue<>(id)));
            state = newState;
            try {
                CommandValue.withValues(values, () -> command.postCondition(oldState, newState, args, result));
            } catch (Throwable ex) {
                return CommandResult.fail(state, ex);
            }
            return CommandResult.success(state);
        } catch (Throwable ex) {
            return CommandResult.fail(state, ex);
        }
    }

    private static <S, A, R> CommandResult<S> runAbstractCommand(
            GeneratedCommand<S, A, R> generated,
            S state) {
        int id = generated.getId();
        Command<S, A, R> command = generated.getCommand();
        A args = generated.getArgs();
        try {
            if (!command.preCondition(state, args)) {
                return CommandResult.fail(state, new Error("Precondition failed"));
            }
            state = command.nextState(state, args, new CommandValue<>(id));
            return CommandResult.success(state);
        } catch (Throwable ex) {
            return CommandResult.fail(state, ex);
        }
    }

    public boolean isValid() {
        CommandResult<S> result = CommandResult.success(initialState);
        for (GeneratedCommand<S, ?, ?> generated : commands) {
            result = runAbstractCommand(generated, result.getState());
            if (result.isFailed()) {
                break;
            }
        }
        return !result.isFailed();
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        Iterator<GeneratedCommand<S, ?, ?>> iterator = commands.iterator();
        while (iterator.hasNext()) {
            builder.append(iterator.next());
            if (iterator.hasNext()) {
                builder.append(", \n\t");
            }
        }
        return "\n\t" + builder.toString();
    }
}