/**
   * Helper that parses given expression string using the configured parser. The
   * expression string can contain any number of expressions all contained in "${...}"
   * markers. For instance: "foo${expr0}bar${expr1}". The static pieces of text will
   * also be returned as Expressions that just return that static piece of text. As a
   * result, evaluating all returned expressions and concatenating the results produces
   * the complete evaluated string. Unwrapping is only done of the outermost delimiters
   * found, so the string 'hello ${foo${abc}}' would break into the pieces 'hello ' and
   * 'foo${abc}'. This means that expression languages that used ${..} as part of their
   * functionality are supported without any problem. The parsing is aware of the
   * structure of an embedded expression. It assumes that parentheses '(', square
   * brackets '[' and curly brackets '}' must be in pairs within the expression unless
   * they are within a string literal and a string literal starts and terminates with a
   * single quote '.
   * @param expressionString the expression string
   * @return the parsed expressions
   * @throws ParseException when the expressions cannot be parsed
   */
  public parseExpressions(expressionString: string): spel2js.SpelExpression[] {
    const expressions: spel2js.SpelExpression[] = [];
    const prefix = '${';
    const suffix = '}';

    let startIdx = 0;
    while (startIdx < expressionString.length) {
      const prefixIndex = expressionString.indexOf(prefix, startIdx);
      if (prefixIndex >= startIdx) {
        // an inner expression was found - this is a composite
        if (prefixIndex > startIdx) {
          expressions.push(literalExpression(expressionString.substring(startIdx, prefixIndex)));
        }

        const afterPrefixIndex = prefixIndex + prefix.length;
        const suffixIndex = this.skipToCorrectEndSuffix(suffix, expressionString, afterPrefixIndex);
        if (suffixIndex === -1) {
          throw new Error(
            "No ending suffix '" +
              suffix +
              "' for expression starting at character " +
              prefixIndex +
              ': ' +
              expressionString.substring(prefixIndex),
          );
        }

        if (suffixIndex === afterPrefixIndex) {
          throw new Error(
            "No expression defined within delimiter '" + prefix + suffix + "' at character " + prefixIndex,
          );
        }

        const expr = expressionString.substring(prefixIndex + prefix.length, suffixIndex).trim();

        if (!expr) {
          throw new Error(
            "No expression defined within delimiter '" + prefix + suffix + "' at character " + prefixIndex,
          );
        }

        expressions.push(spel2js.SpelExpressionEvaluator.compile(expr));
        startIdx = suffixIndex + suffix.length;
      } else {
        // no more ${expressions} found in string, add rest as static text
        expressions.push(literalExpression(expressionString.substring(startIdx)));
        startIdx = expressionString.length;
      }
    }

    return expressions;
  }

const literalExpression = (literalString: string) =>
  spel2js.SpelExpressionEvaluator.compile(`'${literalString.replace(/'/g, "''")}'`);