/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.brooklyn.core.workflow.steps.variables;

import com.google.common.reflect.TypeToken;
import freemarker.core.ParseException;
import org.apache.brooklyn.api.mgmt.ManagementContext;
import org.apache.brooklyn.config.ConfigKey;
import org.apache.brooklyn.core.config.ConfigKeys;
import org.apache.brooklyn.core.workflow.WorkflowExecutionContext;
import org.apache.brooklyn.core.workflow.WorkflowExpressionResolution;
import org.apache.brooklyn.core.workflow.WorkflowStepDefinition;
import org.apache.brooklyn.core.workflow.WorkflowStepInstanceExecutionContext;
import org.apache.brooklyn.util.collections.*;
import org.apache.brooklyn.util.core.flags.TypeCoercions;
import org.apache.brooklyn.util.core.predicates.DslPredicates;
import org.apache.brooklyn.util.core.text.TemplateProcessor;
import org.apache.brooklyn.util.exceptions.Exceptions;
import org.apache.brooklyn.util.guava.Maybe;
import org.apache.brooklyn.util.text.QuotedStringTokenizer;
import org.apache.brooklyn.util.text.Strings;
import org.apache.brooklyn.util.time.Duration;
import org.apache.brooklyn.util.time.Timestamp;
import org.apache.commons.lang3.tuple.MutablePair;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.annotation.Nullable;
import java.time.Instant;
import java.util.*;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.stream.Collectors;

public class SetVariableWorkflowStep extends WorkflowStepDefinition {

    private static final Logger log = LoggerFactory.getLogger(SetVariableWorkflowStep.class);

    public static final String SHORTHAND =
            "[ [ ${variable.type} ] ${variable.name} [ \"=\" ${value...} ] ]";

    public static final ConfigKey<TypedValueToSet> VARIABLE = ConfigKeys.newConfigKey(TypedValueToSet.class, "variable");
    public static final ConfigKey<Object> VALUE = ConfigKeys.newConfigKey(Object.class, "value");

    public enum InterpolationMode {
        WORDS,
        DISABLED,
        FULL,
    }
    public static final ConfigKey<InterpolationMode> INTERPOLATION_MODE = ConfigKeys.newConfigKey(InterpolationMode.class, "interpolation_mode",
            "Whether interpolation runs on the full value (not touching quotes; the default in most places), " +
                    "on words (if unquoted, unquoting others; the default for 'let var = value' shorthand), " +
                    "or is disabled (not applied at all)");
    public static final ConfigKey<TemplateProcessor.InterpolationErrorMode> INTERPOLATION_ERRORS = ConfigKeys.newConfigKey(TemplateProcessor.InterpolationErrorMode.class, "interpolation_errors",
            "Whether unresolvable interpolated expressions fail and return an error (the default for 'let'), " +
                    "ignore the expression leaving it in place (the default for 'load'), " +
                    "or replace the expression with a blank string");

    @Override
    public void populateFromShorthand(String expression) {
        Map<String, Object> newInput = populateFromShorthandTemplate(SHORTHAND, expression, true, true);
        if (newInput.get(VALUE.getName())!=null && input.get(INTERPOLATION_MODE.getName())==null) {
            setInput(INTERPOLATION_MODE, InterpolationMode.WORDS);
        }
    }

    @Override
    public void validateStep(@Nullable ManagementContext mgmt, @Nullable WorkflowExecutionContext workflow) {
        super.validateStep(mgmt, workflow);

        if (input.get(VARIABLE.getName())==null) {
            throw new IllegalArgumentException("Variable name is required");
        }
        if (input.get(VALUE.getName())==null) {
            throw new IllegalArgumentException("Value is required");
        }
    }

    @Override
    protected Object doTaskBody(WorkflowStepInstanceExecutionContext context) {
        TypedValueToSet variable = context.getInput(VARIABLE);
        if (variable ==null) throw new IllegalArgumentException("Variable name is required");
        String name = context.resolve(WorkflowExpressionResolution.WorkflowExpressionStage.STEP_INPUT, variable.name, String.class);
        if (Strings.isBlank(name)) throw new IllegalArgumentException("Variable name is required");
        TypeToken<?> type = context.lookupType(variable.type, () -> null);

        Object unresolvedValue = input.get(VALUE.getName());

        Object resolvedValue = new ConfigurableInterpolationEvaluation(context, type, unresolvedValue, context.getInputOrDefault(INTERPOLATION_MODE), context.getInputOrDefault(INTERPOLATION_ERRORS)).evaluate();

        Object oldValue = setWorkflowScratchVariableDotSeparated(context, name, resolvedValue);
        // these are easily inferred from workflow vars
//        context.noteOtherMetadata("Value set", resolvedValue);
//        if (oldValue!=null) context.noteOtherMetadata("Previous value", oldValue);
        return context.getPreviousStepOutput();
    }

    static Object setWorkflowScratchVariableDotSeparated(WorkflowStepInstanceExecutionContext context, String name, Object resolvedValue) {
        Object oldValue;
        if (name.contains(".")) {
            String[] names = name.split("\\.");
            String names0 = names[0];
            if ("output".equals(names0)) throw new IllegalArgumentException("Cannot set subfield in output");  // catch common error
            Object h = context.getWorkflowExectionContext().getWorkflowScratchVariables().get(names0);
            if (!(h instanceof Map)) throw new IllegalArgumentException("Cannot set " + name + " because " + names0 + " is " + (h == null ? "unset" : "not a map"));
            for (int i = 1; i < names.length - 1; i++) {
                Object hi = ((Map<?, ?>) h).get(names[i]);
                if (hi == null) {
                    hi = MutableMap.of();
                    ((Map) h).put(names[i], hi);
                } else if (!(hi instanceof Map))
                    throw new IllegalArgumentException("Cannot set " + name + " because " + names[i] + " is not a map");
                h = hi;
            }
            oldValue = ((Map) h).put(names[names.length - 1], resolvedValue);
        } else if (name.contains("[")) {
            String[] names = name.split("((?<=\\[|\\])|(?=\\[|\\]))");
            if (names.length != 4 || !"[".equals(names[1]) || !"]".equals(names[3])) {
                throw new IllegalArgumentException("Invalid list index specifier " + name);
            }
            String listName = names[0];
            int listIndex = Integer.parseInt(names[2]);
            Object o = context.getWorkflowExectionContext().getWorkflowScratchVariables().get(listName);
            if (!(o instanceof List))
                throw new IllegalArgumentException("Cannot set " + name + " because " + listName + " is " + (o == null ? "unset" : "not a list"));

            List l = MutableList.copyOf(((List)o));
            if (listIndex < 0 || listIndex >= l.size()) {
                throw new IllegalArgumentException("Invalid list index " + listIndex);
            }
            oldValue = l.set(listIndex, resolvedValue);
            context.getWorkflowExectionContext().updateWorkflowScratchVariable(listName, l);
        } else {
            oldValue = context.getWorkflowExectionContext().updateWorkflowScratchVariable(name, resolvedValue);
        }
        return oldValue;
    }

    private enum LetMergeMode { NONE, SHALLOW, DEEP }

    public static class ConfigurableInterpolationEvaluation<T> {
        protected final WorkflowStepInstanceExecutionContext context;
        protected final TypeToken<T> type;
        protected final Object unresolvedValue;
        protected final InterpolationMode interpolationMode;
        protected final TemplateProcessor.InterpolationErrorMode errorMode;

        public ConfigurableInterpolationEvaluation(WorkflowStepInstanceExecutionContext context, TypeToken<T> type, Object unresolvedValue) {
            this(context, type, unresolvedValue, null, null);
        }
        public ConfigurableInterpolationEvaluation(WorkflowStepInstanceExecutionContext context, TypeToken<T> type, Object unresolvedValue, InterpolationMode interpolationMode, TemplateProcessor.InterpolationErrorMode errorMode) {
            this.context = context;
            this.unresolvedValue = unresolvedValue;
            this.type = type;
            this.interpolationMode = interpolationMode;
            this.errorMode = errorMode;
        }

        public boolean unquotedStartsWith(String s, char c) {
            if (s==null) return false;
            s = s.trim();
            s = Strings.removeFromStart(s, "\"");
            s = Strings.removeFromStart(s, "\'");
            s = s.trim();
            return (s.startsWith(""+c));
        }

        public boolean trimmedEndsWithQuote(String s) {
            if (s==null) return false;
            s = s.trim();
            return s.endsWith("\"") || s.endsWith("\'");
        }

        public Function<String,TypeToken<?>> ifUnquotedStartsWithThen(char c, Class<?> clazz) {
            return s -> (!unquotedStartsWith(s, c)) ? null : TypeToken.of(clazz);
        }

        public T evaluate() {
            try {
                Object result = unresolvedValue;

                Object resultCoerced;
                TypeToken<? extends Object> typeIntermediate = type == null ? TypeToken.of(Object.class) : type;

                if (interpolationMode == InterpolationMode.DISABLED) {
                    resultCoerced = context.getWorkflowExectionContext().resolveCoercingOnly(WorkflowExpressionResolution.WorkflowExpressionStage.STEP_RUNNING, result, typeIntermediate);

                } else if (result instanceof String && interpolationMode == InterpolationMode.WORDS) {
                    result = process((String) result);
                    resultCoerced = context.getWorkflowExectionContext().resolveCoercingOnly(WorkflowExpressionResolution.WorkflowExpressionStage.STEP_RUNNING, result, typeIntermediate);

                } else {
                    // full, or null the default
                    resultCoerced = resolveSubPart(result, typeIntermediate);
                }

                return (T) resultCoerced;
            } catch (Exception e) {
                throw e;
            }
        }

        <T> T resolveSubPart(Object v, TypeToken<T> type) {
            return new WorkflowExpressionResolution(context.getWorkflowExectionContext(), WorkflowExpressionResolution.WorkflowExpressionStage.STEP_RUNNING, false, WorkflowExpressionResolution.WrappingMode.NONE, errorMode)
                    .resolveWithTemplates(v, type);
        }

        Object process(String input) {
            if (Strings.isBlank(input)) return input;

            List<String> wordsByQuote = null;
            try {
                // first deal with internal quotes
                QuotedStringTokenizer qst = qst(input);
                if (qst.isQuoted(input)) {
                    // special treatment if whole line is quoted
                    wordsByQuote = MutableList.of(input);
                } else {
                    wordsByQuote = qst.remainderAsList();
                }
                // then look for operators etc
                return process(wordsByQuote);
            } catch (Exception e) {
                Exceptions.propagateIfFatal(e);
                if (wordsByQuote==null || wordsByQuote.size()>1) {
                    if (Exceptions.getCausalChain(e).stream().anyMatch(cause -> cause instanceof ParseException || cause instanceof IllegalArgumentException)) {
                        // try again with the whole thing as tokens, if it is an interpolated string with spaces inside it or mismatched quotes
                        try {
                            return process(MutableList.of(input));
                        } catch (Exception e2) {
                            log.debug("Failed to process expression as tokens or as string; preferring error from former, but error from latter was: " + e2);
                        }
                    }
                }
                throw Exceptions.propagate(e);
            }
        }

        QuotedStringTokenizer qst(String input) {
            return QuotedStringTokenizer.builder().includeQuotes(true).includeDelimiters(true).expectQuotesDelimited(true).failOnOpenQuote(true).build(input);
        }

        Object process(List<String> w) {
            return process(w, false);
        }

        Object process(List<String> w, boolean ternaryColonAllowed) {
            // if no tokens, treat as null
            if (w.isEmpty()) return null;

            Maybe<Object> result;

            // Order of operations:
            // not used: () [] -> . :: (i.e. Function call, scope, array/member access)
            // not used: ! ~ - + & ++ -- (i.e. unary operators)

            // #__: ?: (i.e. ternary)
            result = handleTokenIfPresent(w, false,
                    ternaryColonAllowed ? MutableMap.of(
                        "?", this::handleTernaryCondition,
                        ":", this::handleTernaryArms)
                            : MutableMap.of("?", this::handleTernaryCondition)
            );
            if (result.isPresent()) return result.get();


            // ?: ?? (nullish - treat as an unary operator)
            result = handleTokenIfPresent(w, false, MutableMap.of("??", this::handleNullish));
            if (result.isPresent()) return result.get();
            //NOTE: levels 4 and 3 are out of order (by the C Order or operations)

            // #4: + -
            result = handleTokenIfPresent(w, true, MutableMap.of("+", this::handleAdd, "-", this::handleSubtract));
            if (result.isPresent()) return result.get();

            // #3: - * / % MOD
            result = handleTokenIfPresent(w, true, MutableMap.of("*", this::handleMultiply, "/", this::handleDivide));
            if (result.isPresent()) return result.get();
            result = handleTokenIfPresent(w, true, MutableMap.of("%", this::handleModulo));
            if (result.isPresent()) return result.get();

            // #5: << >> (i.e. bitwise shift left and right

            // #6: < <= > >=
            result = handleTokenIfPresent(w, false, MutableMap.of(
                    "==", this::handleEquals,
                    "<", this::handleOrderedLessThan,
                    "<=", this::handleOrderedLessThanOrEqual,
                    ">", this::handleOrderedGreaterThan,
                    ">=", this::handleOrderedGreaterThanOrEqual
            ));
            if (result.isPresent()) return result.get();

            // #7: == !=
            // #8: & (i.e. bitwise AND)
            // #9: ^ (i.e. bitwise XOR)
            // #10: | (i.e. bitwise OR)

            // #11: && (i.e. logical AND)
            result = handleTokenIfPresent(w, false, MutableMap.of("&&", this::handleBooleanAnd));
            if (result.isPresent()) return result.get();
            // #12: || (i.e. logical OR)
            result = handleTokenIfPresent(w, false, MutableMap.of("||", this::handleBooleanOr));
            if (result.isPresent()) return result.get();


            // #14: = += -= *= /= %= &= |= ^= <<= >>= (i.e. assignment operators)
            // #15: ,

            // tokens include space delimiters and are still quotes, so unwrap then just stitch together. will preserve spaces.
            boolean resolveToString = w.size()>1;
            QuotedStringTokenizer qst = qst("");
            List<Object> objs = w.stream().map(t -> {
                if (qst.isQuoted(t)) return qst.unwrapIfQuoted(t);
                TypeToken<?> target = resolveToString ? TypeToken.of(String.class) : TypeToken.of(Object.class);
                return resolveSubPart(t, target);
            }).collect(Collectors.toList());
            if (!resolveToString) return objs.get(0);
            return ((List<String>)(List)objs).stream().collect(Collectors.joining());
        }

        private Maybe<Object> handleTokenIfPresent(List<String> tokens, boolean startAtRight, Map<String, BiFunction<List<String>,List<String>,Object>> tokenProcessors) {
            for (int i0=0; i0<tokens.size(); i0++) {
                int i = startAtRight ? tokens.size()-1-i0 : i0;
                String t = tokens.get(i);
                BiFunction<List<String>, List<String>, Object> p = tokenProcessors.get(t);
                if (p!=null) {
                    List<String> lhs = trim(tokens.subList(0, i));
                    List<String> rhs = trim(tokens.subList(i + 1, tokens.size()));
                    return Maybe.of(p.apply(lhs, rhs));
                }
            }
            return Maybe.absent();
        }

        private List<String> trim(List<String> l) {
            if (!l.isEmpty() && Strings.isBlank(l.get(0))) l = l.subList(1, l.size());
            if (!l.isEmpty() && Strings.isBlank(l.get(l.size()-1))) l = l.subList(0, l.size()-1);
            return l;
        }

        Object handleNullish(List<String> lhs, List<String> rhs) {
            return processMaybe(lhs, null).or(() -> process(rhs));
        }

        Maybe<Object> processMaybe(List<String> lhs, Function<String,TypeToken<?>> explicitType) {
            try {
                Object result = process(lhs);
                if (result!=null) return Maybe.of(result);
                return Maybe.absent("null");

            } catch (Exception e) {
                if (Exceptions.isCausedByInterruptInAnyThread(e) && !Thread.currentThread().isInterrupted()) {
                    // value was unavailable, pass through to RHS
                    return Maybe.absent("unavailable");

                } else {
                    Exceptions.propagateIfFatal(e);
                }

                if (log.isTraceEnabled()) {
                    log.trace("Non-fatal exception processing expression "+ lhs +" (in context where there is an alterantive)", e);
                }
                return Maybe.absent(e);
            }
        }

        Maybe<Integer> asInteger(Object x) {
            Maybe<Integer> xi = TypeCoercions.tryCoerce(x, Integer.class);
            Maybe<Double> xd = asDouble(x);
            if (xi.isAbsent() || xd.isAbsent()) return xi;
            if (Math.abs(xd.get() - xi.get())<0.0000000001) return xi;
            return Maybe.absent("Double value does not match integer value");
        }

        Maybe<Double> asDouble(Object x) {
            Maybe<Double> v = TypeCoercions.tryCoerce(x, Double.class);
            if (v.isPresent() && !Double.isFinite(v.get())) return Maybe.absent(() -> new IllegalArgumentException("Value cannot be coerced to double: "+v));
            return v;
        }

        Object applyMathOperator(String op, List<String> lhs0, List<String> rhs0, BiFunction<Integer,Integer,Number> ifInt, BiFunction<Double,Double,Number> ifDouble) {
            Object lhs = process(lhs0);
            Object rhs = process(rhs0);

            if ("+".equals(op)) {
                if (lhs instanceof Duration) {
                    if (rhs instanceof Instant || rhs instanceof Date) {
                        Object newRhs = lhs;
                        lhs = rhs;
                        rhs = newRhs;
                        // fall through to below
                    } else {
                        return TypeCoercions.coerce(rhs, Duration.class).add((Duration) lhs);
                    }
                }
                if (lhs instanceof Instant) return TypeCoercions.coerce(rhs, Duration.class).addTo((Instant) lhs);
                if (lhs instanceof Date)
                    return new Timestamp((Instant) TypeCoercions.coerce(rhs, Duration.class).addTo(((Date) lhs).toInstant()));
            } else if ("-".equals(op)) {
                if (lhs instanceof Duration) {
                    return ((Duration)lhs).subtract(TypeCoercions.coerce(rhs, Duration.class));
                }
                if (lhs instanceof Instant) {
                    if (rhs instanceof Instant) return Duration.between((Instant)rhs, (Instant)lhs);
                    return TypeCoercions.coerce(rhs, Duration.class).multiply(-1).addTo((Instant) lhs);
                }
                if (lhs instanceof Date) {
                    if (rhs instanceof Date) return Duration.between(((Date)rhs).toInstant(), ((Date)lhs).toInstant());
                    return new Timestamp((Instant) TypeCoercions.coerce(rhs, Duration.class).multiply(-1).addTo(((Date) lhs).toInstant()));
                }
            }

            Maybe<Integer> lhsI = asInteger(lhs);
            Maybe<Integer> rhsI = asInteger(rhs);
            if (lhsI.isPresent() && rhsI.isPresent()) {
                Number x = ifInt.apply(lhsI.get(), rhsI.get());
                return ((Maybe)asInteger(x)).orMaybe(() -> asDouble(x)).get();
            }

            if (ifDouble!=null) {
                Maybe<Double> lhsD = asDouble(lhs);
                Maybe<Double> rhsD = asDouble(rhs);
                if (lhsD.isPresent() && rhsD.isPresent()) return asDouble(ifDouble.apply(lhsD.get(), rhsD.get())).get();

                if (lhsD.isAbsent()) failOnInvalidArgument("left", op, lhs0, lhs);
                if (rhsD.isAbsent()) failOnInvalidArgument("right", op, rhs0, rhs);
            } else {
                if (lhsI.isAbsent()) failOnInvalidArgument("left", op, lhs0, lhs);
                if (rhsI.isAbsent()) failOnInvalidArgument("right", op, rhs0, rhs);
            }

            throw new IllegalArgumentException("Should not come here");
        }

        Object applyBooleanOperator(List<String> lhs0, List<String> rhs0, BiFunction<Boolean, Boolean, Boolean> biFn) {
            Object lhs = process(lhs0);
            Object rhs = process(rhs0);

            Maybe<Boolean> lhsB = asBoolean(lhs);
            Maybe<Boolean> rhsB = asBoolean(rhs);
            if (lhsB.isPresent() && rhsB.isPresent()) {
                return biFn.apply(lhsB.get(), rhsB.get());
            }
            throw new IllegalArgumentException("Should not come here");
        }

        boolean applyComparison(List<String> lhs0, List<String> rhs0, Function<Integer, Boolean> test) {
            Object lhs = process(lhs0);
            Object rhs = process(rhs0);

            return DslPredicates.coercedCompare(lhs, rhs, test);
        }

        Maybe<Boolean> asBoolean(Object x) {
            return TypeCoercions.tryCoerce(x, Boolean.class);
        }

        private IllegalArgumentException failOnInvalidArgument(String side, String op, Object pre, Object post) {
            String msg = "Invalid "+side+" argument to operation '"+op+"'";

            String postS = ""+post;
            if (postS.contains("*") || postS.contains("+") || postS.contains("+") || postS.contains("/")) {
                // we could weaken this contraint but for now at least make it clear
                msg += "; mathematical operations must have spaces around them for disambiguation";
            }

            throw new IllegalArgumentException(msg + ": "+pre+" => "+post);
        }

        Object handleMultiply(List<String> lhs, List<String> rhs) {
            return applyMathOperator("*", lhs, rhs, (a,b)->a*b, (a,b)->a*b);
        }

        Object handleDivide(List<String> lhs, List<String> rhs) {
            return applyMathOperator("/", lhs, rhs, (a,b)->1.0*a/b, (a,b)->a/b);
        }

        Object handleBooleanAnd(List<String> lhs, List<String> rhs) {
            return applyBooleanOperator(lhs, rhs, (a, b) -> a && b);
        }

        Object handleBooleanOr(List<String> lhs, List<String> rhs) {
            return applyBooleanOperator(lhs, rhs, (a, b) -> a || b);
        }

        Object handleOrderedGreaterThan(List<String> lhs, List<String> rhs) {
            return applyComparison(lhs, rhs, v -> v>0);
        }

        Object handleOrderedGreaterThanOrEqual(List<String> lhs, List<String> rhs) {
            return applyComparison(lhs, rhs, v -> v>=0);
        }

        Object handleOrderedLessThan(List<String> lhs, List<String> rhs) {
            return applyComparison(lhs, rhs, v -> v<0);
        }

        Object handleOrderedLessThanOrEqual(List<String> lhs, List<String> rhs) {
            return applyComparison(lhs, rhs, v -> v<=0);
        }

        boolean handleEquals(List<String> lhs, List<String> rhs) {
            return DslPredicates.coercedEqual(process(lhs), process(rhs));
        }

        Object handleTernaryCondition(List<String> lhs0, List<String> rhs0) {
            //log.info(String.format("Ternary Condition 0: [lhs:%s][rhs:%s]", lhs0, rhs0));
            Object lhs = process(lhs0);
            Object rhs;
            int questionIndex = rhs0.indexOf("?");
            int colonIndex = rhs0.indexOf(":");
            if (questionIndex > -1 && questionIndex < colonIndex) {
                // Nested ternary
                rhs = handleNestedTernaryRhs(rhs0);
            } else if (questionIndex > -1 && colonIndex < questionIndex) {
                // Chained ternary
                rhs = handleChainedTernaryRhs(rhs0);
            } else {
                // non-nested or chained
                rhs = process(rhs0, true);
            }
            //log.info(String.format("Ternary Condition 1: [lhs:%s][rhs:%s]", lhs, rhs));

            if (!(rhs instanceof TernaryArms)) throw new IllegalArgumentException("Mismatched ternary ':' operator");

            Maybe<Boolean> condition = asBoolean(lhs);
            if (condition.isPresent()){
                if (condition.get()) {
                    // ? left : right -- rhs length is 5 [left, ,:, ,right]
                    // ? true && true : false || false -- rhs length is ???
                    return process( ((TernaryArms)rhs).getLeft());
                    //throw new IllegalArgumentException("TERNARY CONDITION IS TRUE");
                } else {
                    return process( ((TernaryArms)rhs).getRight());
                    //throw new IllegalArgumentException("TERNARY CONDITION IS FALSE");
                }
            }

            throw new IllegalArgumentException("Leading term of ternary '"+lhs+"' does not evaluate to a boolean");
        }

        public TernaryArms handleNestedTernaryRhs(List<String> rhs) {
            int lastColonIndex = rhs.lastIndexOf(":");
            if (lastColonIndex == -1) {
                throw new IllegalArgumentException("Mismatched ternary ':' operator");
            }
            int firstColonIndex = rhs.indexOf(":");
            if (firstColonIndex == lastColonIndex) {
                return (TernaryArms) process(rhs);
            }
            return new TernaryArms(trim(rhs.subList(0, lastColonIndex)), trim(rhs.subList(lastColonIndex + 1, rhs.size())));
        }

        public TernaryArms handleChainedTernaryRhs(List<String> rhs) {
            int colonIndex = rhs.indexOf(":");
            if (colonIndex == -1) {
                throw new IllegalArgumentException("Mismatched ternary ':' operator");
            }
            return new TernaryArms(trim(rhs.subList(0, colonIndex)), trim(rhs.subList(colonIndex + 1, rhs.size())));
        }

        static class TernaryArms extends MutablePair<List<String>,List<String>> {
            public TernaryArms(List<String> lhs, List<String> rhs) {
                super(lhs, rhs);
            }
        }

        public Object handleTernaryArms(List<String> lhs0, List<String> rhs0) {
            //log.info(String.format("Ternary 0: [lhs:%s][rhs:%s]", lhs0, rhs0));
            return new TernaryArms(lhs0, rhs0);
        }

        Object handleAdd(List<String> lhs, List<String> rhs) {
            return applyMathOperator("+", lhs, rhs, (a,b)->a+b, (a,b)->a+b);
        }

        Object handleSubtract(List<String> lhs, List<String> rhs) {
            return applyMathOperator("-", lhs, rhs, (a,b)->a-b, (a,b)->a-b);
        }

        Object handleModulo(List<String> lhs, List<String> rhs) {
            return applyMathOperator("%", lhs, rhs, (a,b)->a%b, null);
        }
    }

    @Override protected Boolean isDefaultIdempotent() { return true; }

}