/***************************************************************************
 *   Copyright (C) 2005-2019 by the Quassel Project                        *
 *   devel@quassel-irc.org                                                 *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) version 3.                                           *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
 ***************************************************************************/

#include "expressionmatch.h"

#include <QChar>
#include <QDebug>
#include <QString>
#include <QStringList>

#if QT_VERSION >= 0x050000
#include <QRegularExpression>
#else
#include <QRegExp>
#endif

#include "logmessage.h"

ExpressionMatch::ExpressionMatch(const QString &expression, MatchMode mode, bool caseSensitive)
{
    // Store the original parameters for later reference
    _sourceExpression = expression;
    _sourceMode = mode;
    _sourceCaseSensitive = caseSensitive;

    // Calculate the internal regex
    //
    // Do this now instead of on-demand to provide immediate feedback on errors when editing
    // highlight and ignore rules.
    cacheRegEx();
}


bool ExpressionMatch::match(const QString &string, bool matchEmpty) const
{
    // Handle empty expression strings
    if (_sourceExpressionEmpty) {
        // Match found if matching empty is allowed, otherwise no match found
        return matchEmpty;
    }

    if (!isValid()) {
        // Can't match on an invalid rule
        return false;
    }

    // We have "_matchRegEx", "_matchInvertRegEx", or both due to isValid() check above

    // If specified, first check inverted rules
    if (_matchInvertRegExActive && _matchInvertRegEx.isValid()) {
        // Check inverted match rule

        // See _matchRegEx section below for explanations of QRegExp vs. QRegularExpression
        if (
#if QT_VERSION >= 0x050000
                _matchInvertRegEx.match(string).hasMatch()
#else
                _matchInvertRegEx.indexIn(string) != -1
#endif
                ) {
            // Inverted rule matched, the rest of the rule cannot match
            return false;
        }
    }

    if (_matchRegExActive && _matchRegEx.isValid()) {
        // Check regular match rule
    #if QT_VERSION >= 0x050000
        // QRegularExpression does partial matching by default (exact matching requires anchoring
        // expressions to be added)
        // See https://doc.qt.io/qt-5/qregularexpression.html#porting-from-qregexp-exactmatch
        return _matchRegEx.match(string).hasMatch();
    #else
        // QRegExp partial matching is done via indexIn
        // See https://doc.qt.io/qt-5/qregexp.html#indexIn
        return (_matchRegEx.indexIn(string) != -1);
    #endif
    } else {
        // If no valid regular rules exist, due to the isValid() check there must be valid inverted
        // rules that did not match.  Count this as properly matching (implicit wildcard).
        return true;
    }
}


QString ExpressionMatch::trimMultiWildcardWhitespace(const QString &originalRule)
{
    // This gets handled in two steps:
    //
    // 1.  Break apart ";"-separated list into components
    // 2.  Combine whitespace-trimmed components into wildcard expression
    //
    // Let's start by making the list...

    // Convert a ";"-separated list into an actual list, splitting on newlines and unescaping
    // escaped characters

    // Escaped list rules (where "[\n]" represents newline):
    // ---------------
    // Token  | Outcome
    // -------|--------
    // ;      | Split
    // \;     | Keep as "\;"
    // \\;    | Split (keep as "\\")
    // \\\    | Keep as "\\" + "\", set consecutive slashes to 1
    // [\n]   | Split
    // \[\n]  | Split (keep as "\")
    // \\[\n] | Split (keep as "\\")
    // ...    | Keep as "..."
    // \...   | Keep as "\..."
    // \\...  | Keep as "\\..."
    //
    // Strings are forced to end with "\n", always applying "\..." and "\\..." rules
    // "..." also includes another "\" character
    //
    // All whitespace is trimmed from each component

    // "\\" and "\" are not downconverted to allow for other escape codes to be detected in
    // ExpressionMatch::wildcardToRegex

    // Example:
    //
    // > Wildcard rule
    // norm; norm-space ; newline-space [\n] ;escape \; sep ; slash-end-split\\; quad\\\\norm;
    // newline-split-slash\\[\n] slash-at-end\\                       [line does not continue]
    //
    // > Components
    //   norm
    //   norm-space
    //   newline-space
    //   escape \; sep
    //   slash-end-split\\          [line does not continue]
    //   quad\\\\norm
    //   newline-split-slash\\      [line does not continue]
    //   slash-at-end\\             [line does not continue]
    //
    // > Trimmed wildcard rule
    // norm; norm-space; newline-space[\n]escape \; sep; slash-end-split\\; quad\\\\norm;
    // newline-split-slash\\[\n]slash-at-end\\                        [line does not continue]
    //
    // (Newlines are encoded as "[\n]".  Ignore linebreaks for the sake of comment wrapping.)

    // Note: R"(\\)" results in the literal of "\\", two backslash characters.  Anything inside the
    // brackets is treated as a literal.  Outside the brackets but inside the quotes is still
    // escaped.
    //
    // See https://en.cppreference.com/w/cpp/language/string_literal

    // Prepare to loop!

    QString rule(originalRule);

    // Force a termination at the end of the string to trigger a split
    // Don't check for ";" splits as they may be escaped
    if (!rule.endsWith("\n")) {
        rule.append("\n");
    }

    // Result
    QString result = {};
    // Current character
    QChar curChar = {};
    // Current string
    QString curString = {};
    // Max length
    int sourceLength = rule.length();
    // Consecutive "\" characters
    int consecutiveSlashes = 0;

    // We know it's going to be the same length or smaller, so reserve the same size as the string
    result.reserve(sourceLength);

    // For every character...
    for (int i = 0; i < sourceLength; i++) {
        // Get the character
        curChar = rule.at(i);
        // Check if it's on the list of special list characters, converting to Unicode for use
        // in the switch statement
        //
        // See https://doc.qt.io/qt-5/qchar.html#unicode
        switch (curChar.unicode()) {
        case ';':
            // Separator found
            switch (consecutiveSlashes) {
            case 0:
            case 2:
                // ";"   -> Split
                // ...or...
                // "\\;" -> Split (keep as "\\")
                // Not escaped separator, split into a new item

                // Apply the additional "\\" if needed
                if (consecutiveSlashes == 2) {
                    // "\\;" -> Split (keep as "\\")
                    curString.append(R"(\\)");
                }

                // Remove any whitespace, e.g. "item1; item2" -> " item2" -> "item2"
                curString = curString.trimmed();

                // Skip empty items
                if (!curString.isEmpty()) {
                    // Add to list with the same separator used
                    result.append(curString + "; ");
                }
                // Reset the current list item
                curString.clear();
                break;
            case 1:
                // "\;" -> Keep as "\;"
                curString.append(R"(\;)");
                break;
            default:
                // This shouldn't ever happen (even with invalid wildcard rules), log a warning
                qWarning() << Q_FUNC_INFO << "Wildcard rule"
                           << rule << "resulted in rule component"
                           << curString << "with unexpected count of consecutive '\\' ("
                           << consecutiveSlashes << "), ignoring" << curChar << "character!";
                break;
            }
            consecutiveSlashes = 0;
            break;
        case '\\':
            // Split escape
            // Increase consecutive slash count
            consecutiveSlashes++;
            // Check if we've reached "\\\"...
            if (consecutiveSlashes == 3) {
                // "\\\" -> Keep as "\\" + "\"
                curString.append(R"(\\)");
                // Set consecutive slashes to 1, recognizing the trailing "\"
                consecutiveSlashes = 1;
            }
            else if (consecutiveSlashes > 3) {
                // This shouldn't ever happen (even with invalid wildcard rules), log a warning
                qWarning() << Q_FUNC_INFO << "Wildcard rule"
                           << rule << "resulted in rule component"
                           << curString << "with unexpected count of consecutive '\\' ("
                           << consecutiveSlashes << "), ignoring" << curChar << "character!";
                break;
            }
            break;
        case '\n':
            // Newline found
            // Preserve the characters as they are now

            // "[\n]"   -> Split
            // "\[\n]"  -> Split (keep as "\")
            // "\\[\n]" -> Split (keep as "\\")

            switch (consecutiveSlashes) {
            case 0:
                // Keep string as is
                break;
            case 1:
            case 2:
                // Apply the additional "\" or "\\"
                curString.append(QString(R"(\)").repeated(consecutiveSlashes));
                break;
            default:
                // This shouldn't ever happen (even with invalid wildcard rules), log a warning
                qWarning() << Q_FUNC_INFO << "Wildcard rule"
                           << rule << "resulted in rule component"
                           << curString << "with unexpected count of consecutive '\\' ("
                           << consecutiveSlashes << "), applying newline split anyways!";
                break;
            }

            // Remove any whitespace, e.g. "item1; item2" -> " item2" -> "item2"
            curString = curString.trimmed();

            // Skip empty items
            if (!curString.isEmpty()) {
                // Add to list with the same separator used
                result.append(curString + "\n");
            }
            // Reset the current list item
            curString.clear();
            consecutiveSlashes = 0;
            break;
        default:
            // Preserve the characters as they are now
            switch (consecutiveSlashes) {
            case 0:
                // "..."   -> Keep as "..."
                curString.append(curChar);
                break;
            case 1:
            case 2:
                // "\..."  -> Keep as "\..."
                // "\\..." -> Keep as "\\..."
                curString.append(QString("\\").repeated(consecutiveSlashes) + curChar);
                break;
            default:
                // This shouldn't ever happen (even with invalid wildcard rules), log a warning
                qWarning() << Q_FUNC_INFO << "Wildcard rule"
                           << rule << "resulted in rule component"
                           << curString << "with unexpected count of consecutive '\\' ("
                           << consecutiveSlashes << "), ignoring " << curChar << "char escape!";
                break;
            }
            consecutiveSlashes = 0;
            break;
        }
    }

    // Remove any trailing separators
    if (result.endsWith("; ")) {
        result.chop(2);
    }

    // Remove any trailing whitespace
    return result.trimmed();
}


void ExpressionMatch::cacheRegEx()
{
    _matchRegExActive = false;
    _matchInvertRegExActive = false;

    _sourceExpressionEmpty = _sourceExpression.isEmpty();
    if (_sourceExpressionEmpty) {
        // No need to calculate anything for empty strings
        return;
    }

    // Convert the given expression to a regular expression based on the mode
    switch (_sourceMode) {
    case MatchMode::MatchPhrase:
        // Match entire phrase, noninverted
        // Don't trim whitespace for phrase matching as someone might want to match on " word ", a
        // more-specific request than "word".
        _matchRegEx = regExFactory("(?:^|\\W)" + regExEscape(_sourceExpression) + "(?:\\W|$)",
                                   _sourceCaseSensitive);
        _matchRegExActive = true;
        break;
    case MatchMode::MatchMultiPhrase:
        // Match multiple entire phrases, noninverted
        // Convert from multiple-phrase rules
        _matchRegEx = regExFactory(convertFromMultiPhrase(_sourceExpression), _sourceCaseSensitive);
        _matchRegExActive = true;
        break;
    case MatchMode::MatchWildcard:
        // Match as wildcard expression
        // Convert from wildcard rules for a single wildcard
        if (_sourceExpression.startsWith("!")) {
            // Inverted rule: take the remainder of the string
            // "^" + invertComponents.at(0) + "$"
            _matchInvertRegEx = regExFactory("^" + wildcardToRegEx(_sourceExpression.mid(1)) + "$",
                                             _sourceCaseSensitive);
            _matchInvertRegExActive = true;
        }
        else {
            // Normal rule: take the whole string
            // Account for any escaped "!" (i.e. "\!") by skipping past the "\", but don't skip past
            // escaped "\" (i.e. "\\!")
            _matchRegEx =
                    regExFactory("^" + wildcardToRegEx(_sourceExpression.startsWith("\\!")
                                                       ? _sourceExpression.mid(1)
                                                       : _sourceExpression) + "$",
                                 _sourceCaseSensitive);
            _matchRegExActive = true;
        }
        break;
    case MatchMode::MatchMultiWildcard:
        // Match as multiple wildcard expressions
        // Convert from wildcard rules for multiple wildcards
        // (The generator function handles setting matchRegEx/matchInvertRegEx)
        generateFromMultiWildcard(_sourceExpression, _sourceCaseSensitive);
        break;
    case MatchMode::MatchRegEx:
        // Match as regular expression
        if (_sourceExpression.startsWith("!")) {
            // Inverted rule: take the remainder of the string
            _matchInvertRegEx = regExFactory(_sourceExpression.mid(1), _sourceCaseSensitive);
            _matchInvertRegExActive = true;
        }
        else {
            // Normal rule: take the whole string
            // Account for any escaped "!" (i.e. "\!") by skipping past the "\", but don't skip past
            // escaped "\" (i.e. "\\!")
            _matchRegEx =
                    regExFactory(_sourceExpression.startsWith("\\!") ? _sourceExpression.mid(1)
                                                                     : _sourceExpression,
                                 _sourceCaseSensitive);
            _matchRegExActive = true;
        }
        break;
    default:
        // This should never happen if you keep the above consistent
        qWarning() << Q_FUNC_INFO << "Unknown MatchMode" << (int)_sourceMode << "!";
        break;
    }

    if (!_sourceExpressionEmpty && !isValid()) {
        // This can happen with invalid regex, so make it a bit more user-friendly.  Set it to Info
        // level as ideally someone's not just going to leave a broken match rule around.  For
        // MatchRegEx, they probably need to fix their regex rule.  For the other modes, there's
        // probably a bug in the parsing routines (which should also be fixed).
        quInfo() << "Could not parse expression match rule"
                 << _sourceExpression << "(match mode:" << (int)_sourceMode
                 << "), this rule will be ignored";
    }
}


#if QT_VERSION >= 0x050000
QRegularExpression ExpressionMatch::regExFactory(const QString &regExString,
                                                 bool caseSensitive)
#else
QRegExp ExpressionMatch::regExFactory(const QString &regExString, bool caseSensitive)
#endif
{
    // Construct the regular expression object, setting case sensitivity as appropriate
#if QT_VERSION >= 0x050000
    QRegularExpression newRegEx =
            QRegularExpression(regExString, caseSensitive ?
                                   QRegularExpression::PatternOption::NoPatternOption
                                 : QRegularExpression::PatternOption::CaseInsensitiveOption );
#else
    QRegExp newRegEx = QRegExp(regExString, caseSensitive ?
                                   Qt::CaseSensitivity::CaseSensitive
                                 : Qt::CaseSensitivity::CaseInsensitive);
#endif

    // Check if rule is valid
    if (!newRegEx.isValid()) {
        // This can happen with invalid regex, so make it a bit more user-friendly.  Keep this
        // distinct from the main info-level message for easier debugging in case a regex component
        // in Wildcard or Phrase mode breaks.
        qDebug() << "Internal regular expression component" << regExString
                 << "is invalid and will be ignored";
    }
    // Qt 5.4 (QT_VERSION >= 0x050400) offers explicit control over when QRegularExpression objects
    // get optimized.  By default, patterns are only optimized after some number of uses as defined
    // within Qt internals.
    //
    // In the context of ExpressionMatch, some regular expressions might go unused, e.g. a highlight
    // rule might never match a channel pattern, resulting in the contents pattern being untouched.
    // It should be safe to let Qt handle optimization, taking a non-deterministic, one-off
    // performance penalty on optimization for the sake of saving memory usage on patterns that
    // don't get used.
    //
    // If profiling shows expressions are generally used and/or the automatic optimization
    // interferes incurs too high of a penalty (unlikely given we've created regular expression
    // objects willy-nilly before now), this can be revisited to explicitly call...
    //
    // else {
    //     // Optimize regex now
    // #if QT_VERSION >= 0x050400
    //     newRegEx.optimize();
    // #endif
    //
    // }
    //
    // NOTE: This should only be called if the expression is valid!  Apply within an "else" of the
    // inverted isValid() check above.
    //
    // See https://doc.qt.io/qt-5/qregularexpression.html#optimize

    return newRegEx;
}


QString ExpressionMatch::regExEscape(const QString &phrase)
{
    // Escape the given phrase of any special regular expression characters
#if QT_VERSION >= 0x050000
    return QRegularExpression::escape(phrase);
#else
    return QRegExp::escape(phrase);
#endif
}


QString ExpressionMatch::convertFromMultiPhrase(const QString &originalRule)
{
    // Convert the multi-phrase rule into regular expression format
    // Split apart the original rule into components
    // Use QStringList instead of std::vector<QString> to make use of Qt's built-in .join() method
    QStringList components = {};
    // Split on "\n"
    for (auto &&component : originalRule.split("\n", QString::SkipEmptyParts)) {
        // Don't trim whitespace to maintain consistency with single phrase matching
        // As trimming is not performed, empty components will already be skipped.  This means " "
        // is considered a valid matching phrase.

        // Take the whole string, escaping any regex
        components.append(regExEscape(component));
    }

    // Create full regular expression by...
    // > Enclosing within a non-capturing group to avoid overhead of text extraction, "(?:...)"
    // > Flattening normal and inverted rules using the regex OR character "...|..."
    //
    // Before: [foo, bar, baz]
    // After:  (?:^|\W)(?:foo|bar|baz)(?:\W|$)

    if (components.count() == 1) {
        // Single item, skip the noncapturing group
        return "(?:^|\\W)" + components.at(0) + "(?:\\W|$)";
    }
    else {
        return "(?:^|\\W)(?:" + components.join("|") + ")(?:\\W|$)";
    }
}


void ExpressionMatch::generateFromMultiWildcard(const QString &originalRule, bool caseSensitive)
{
    // Convert the wildcard rule into regular expression format
    // First, reset the existing match expressions
    _matchRegEx = {};
    _matchInvertRegEx = {};
    _matchRegExActive = false;
    _matchInvertRegExActive = false;

    // This gets handled in three steps:
    //
    // 1.  Break apart ";"-separated list into components
    // 2.  Convert components from wildcard format into regular expression format
    // 3.  Combine normal/invert components into normal/invert regular expressions
    //
    // Let's start by making the list...

    // Convert a ";"-separated list into an actual list, splitting on newlines and unescaping
    // escaped characters

    // Escaped list rules (where "[\n]" represents newline):
    // ---------------
    // Token  | Outcome
    // -------|--------
    // ;      | Split
    // \;     | Replace with ";"
    // \\;    | Split (keep as "\\")
    // !      | At start: mark as inverted
    // \!     | At start: replace with "!"
    // \\!    | At start: keep as "\\!" (replaced with "\!" in wildcard conversion)
    // !      | Elsewhere: keep as "!"
    // \!     | Elsewhere: keep as "\!"
    // \\!    | Elsewhere: keep as "\\!"
    // \\\    | Keep as "\\" + "\", set consecutive slashes to 1
    // [\n]   | Split
    // \[\n]  | Split (keep as "\")
    // \\[\n] | Split (keep as "\\")
    // ...    | Keep as "..."
    // \...   | Keep as "\..."
    // \\...  | Keep as "\\..."
    //
    // Strings are forced to end with "\n", always applying "\..." and "\\..." rules
    // "..." also includes another "\" character
    //
    // All whitespace is trimmed from each component

    // "\\" and "\" are not downconverted to allow for other escape codes to be detected in
    // ExpressionMatch::wildcardToRegex


    // Example:
    //
    // > Wildcard rule
    // norm;!invert; norm-space ; !invert-space ;;!;\!norm-escaped;\\!slash-invert;\\\\double;
    // escape\;sep;slash-end-split\\;quad\\\\!noninvert;newline-split[\n]newline-split-slash\\[\n]
    // slash-at-end\\               [line does not continue]
    //
    // (Newlines are encoded as "[\n]".  Ignore linebreaks for the sake of comment wrapping.)
    //
    //
    // > Normal components without wildcard conversion
    //   norm
    //   norm-space
    //   !norm-escaped
    //   \\!slash-invert
    //   \\\\double
    //   escape;sep
    //   slash-end-split\\          [line does not continue]
    //   quad\\\\!noninvert
    //   newline-split
    //   newline-split-slash\\      [line does not continue]
    //   slash-at-end\\             [line does not continue]
    //
    // > Inverted components without wildcard conversion
    //   invert
    //   invert-space
    //
    //
    // > Normal components with wildcard conversion
    //   norm
    //   norm\-space
    //   \!norm\-escaped
    //   \\\!slash\-invert
    //   \\\\double
    //   escape\;sep
    //   slash\-end\-split\\        [line does not continue]
    //   quad\\\\\!noninvert
    //   newline\-split
    //   newline\-split\-slash\\    [line does not continue]
    //   slash\-at\-end\\           [line does not continue]
    //
    // > Inverted components with wildcard conversion
    //   invert
    //   invert\-space
    //
    //
    // > Normal wildcard-converted regex
    // ^(?:norm|norm\-space|\!norm\-escaped|\\\!slash\-invert|\\\\double|escape\;sep|
    // slash\-end\-split\\|quad\\\\\!noninvert|newline\-split|newline\-split\-slash\\|
    // slash\-at\-end\\)$
    //
    // > Inverted wildcard-converted regex
    // ^(?:invert|invert\-space)$

    // Note: R"(\\)" results in the literal of "\\", two backslash characters.  Anything inside the
    // brackets is treated as a literal.  Outside the brackets but inside the quotes is still
    // escaped.
    //
    // See https://en.cppreference.com/w/cpp/language/string_literal

    // Prepare to loop!

    QString rule(originalRule);

    // Force a termination at the end of the string to trigger a split
    // Don't check for ";" splits as they may be escaped
    if (!rule.endsWith("\n")) {
        rule.append("\n");
    }

    // Result, sorted into normal and inverted rules
    // Use QStringList instead of std::vector<QString> to make use of Qt's built-in .join() method
    QStringList normalComponents = {}, invertComponents = {};

    // Current character
    QChar curChar = {};
    // Current string
    QString curString = {};
    // Max length
    int sourceLength = rule.length();
    // Consecutive "\" characters
    int consecutiveSlashes = 0;
    // Whether or not this marks an inverted rule
    bool isInverted = false;
    // Whether or not we're at the beginning of the rule (for detecting "!" and "\!")
    bool isRuleStart = true;

    // We know it's going to have ";"-count items or less, so reserve ";"-count items for both.
    // Without parsing it's not easily possible to tell which are escaped or not, and among the
    // non-escaped entries, which are inverted or not.  These get destroyed once out of scope of
    // this function, so balancing towards performance over memory usage should be okay, hopefully.
    int separatorCount = rule.count(";");
    normalComponents.reserve(separatorCount);
    invertComponents.reserve(separatorCount);

    // For every character...
    for (int i = 0; i < sourceLength; i++) {
        // Get the character
        curChar = rule.at(i);
        // Check if it's on the list of special list characters, converting to Unicode for use
        // in the switch statement
        //
        // See https://doc.qt.io/qt-5/qchar.html#unicode
        switch (curChar.unicode()) {
        case ';':
            // Separator found
            switch (consecutiveSlashes) {
            case 0:
            case 2:
                // ";"   -> Split
                // ...or...
                // "\\;" -> Split (keep as "\\")
                // Not escaped separator, split into a new item

                // Apply the additional "\\" if needed
                if (consecutiveSlashes == 2) {
                    // "\\;" -> Split (keep as "\\")
                    curString.append(R"(\\)");
                }

                // Remove any whitespace, e.g. "item1; item2" -> " item2" -> "item2"
                curString = curString.trimmed();

                // Skip empty items
                if (!curString.isEmpty()) {
                    // Add to inverted/normal list
                    if (isInverted) {
                        invertComponents.append(wildcardToRegEx(curString));
                    }
                    else {
                        normalComponents.append(wildcardToRegEx(curString));
                    }
                }
                // Reset the current list item
                curString.clear();
                isInverted = false;
                isRuleStart = true;
                break;
            case 1:
                // "\;" -> Replace with ";"
                curString.append(";");
                isRuleStart = false;
                break;
            default:
                // This shouldn't ever happen (even with invalid wildcard rules), log a warning
                qWarning() << Q_FUNC_INFO << "Wildcard rule"
                           << rule << "resulted in rule component"
                           << curString << "with unexpected count of consecutive '\\' ("
                           << consecutiveSlashes << "), ignoring" << curChar << "character!";
                isRuleStart = false;
                break;
            }
            consecutiveSlashes = 0;
            break;
        case '!':
            // Rule inverter found
            if (isRuleStart) {
                // Apply the inverting logic
                switch (consecutiveSlashes) {
                case 0:
                    // "!"   -> At start: mark as inverted
                    isInverted = true;
                    // Don't include the "!" character
                    break;
                case 1:
                    // "\!"  -> At start: replace with "!"
                    curString.append("!");
                    break;
                case 2:
                    // "\\!" -> At start: keep as "\\!" (replaced with "\!" in wildcard conversion)
                    curString.append(R"(\\!)");
                    break;
                default:
                    // This shouldn't ever happen (even with invalid wildcard rules), log a warning
                    qWarning() << Q_FUNC_INFO << "Wildcard rule"
                             << rule << "resulted in rule component"
                             << curString << "with unexpected count of consecutive '\\' ("
                             << consecutiveSlashes << "), ignoring" << curChar << "character!";
                    break;
                }
            }
            else {
                // Preserve the characters as they are now
                switch (consecutiveSlashes) {
                case 0:
                    // "!"    -> Elsewhere: keep as "!"
                    curString.append("!");
                    break;
                case 1:
                case 2:
                     // "\!"  -> Elsewhere: keep as "\!"
                     // "\\!" -> Elsewhere: keep as "\\!"
                    curString.append(QString(R"(\)").repeated(consecutiveSlashes) + "!");
                    break;
                default:
                    // This shouldn't ever happen (even with invalid wildcard rules), log a warning
                    qWarning() << Q_FUNC_INFO << "Wildcard rule"
                               << rule << "resulted in rule component"
                               << curString << "with unexpected count of consecutive '\\' ("
                               << consecutiveSlashes << "), ignoring" << curChar << "character!";
                    break;
                }
            }
            isRuleStart = false;
            consecutiveSlashes = 0;
            break;
        case '\\':
            // Split escape
            // Increase consecutive slash count
            consecutiveSlashes++;
            // Check if we've reached "\\\"...
            if (consecutiveSlashes == 3) {
                // "\\\" -> Keep as "\\" + "\"
                curString.append(R"(\\)");
                // No longer at the rule start
                isRuleStart = false;
                // Set consecutive slashes to 1, recognizing the trailing "\"
                consecutiveSlashes = 1;
            }
            else if (consecutiveSlashes > 3) {
                // This shouldn't ever happen (even with invalid wildcard rules), log a warning
                qWarning() << Q_FUNC_INFO << "Wildcard rule"
                           << rule << "resulted in rule component"
                           << curString << "with unexpected count of consecutive '\\' ("
                           << consecutiveSlashes << "), ignoring" << curChar << "character!";
                break;
            }
            // Don't set "isRuleStart" here as "\" is used in escape sequences
            break;
        case '\n':
            // Newline found
            // Preserve the characters as they are now

            // "[\n]"   -> Split
            // "\[\n]"  -> Split (keep as "\")
            // "\\[\n]" -> Split (keep as "\\")

            switch (consecutiveSlashes) {
            case 0:
                // Keep string as is
                break;
            case 1:
            case 2:
                // Apply the additional "\" or "\\"
                curString.append(QString(R"(\)").repeated(consecutiveSlashes));
                break;
            default:
                // This shouldn't ever happen (even with invalid wildcard rules), log a warning
                qWarning() << Q_FUNC_INFO << "Wildcard rule"
                           << rule << "resulted in rule component"
                           << curString << "with unexpected count of consecutive '\\' ("
                           << consecutiveSlashes << "), applying newline split anyways!";
                break;
            }

            // Remove any whitespace, e.g. "item1; item2" -> " item2" -> "item2"
            curString = curString.trimmed();

            // Skip empty items
            if (!curString.isEmpty()) {
                // Add to inverted/normal list
                if (isInverted) {
                    invertComponents.append(wildcardToRegEx(curString));
                }
                else {
                    normalComponents.append(wildcardToRegEx(curString));
                }
            }
            // Reset the current list item
            curString.clear();
            isInverted = false;
            isRuleStart = true;
            consecutiveSlashes = 0;
            break;
        default:
            // Preserve the characters as they are now
            switch (consecutiveSlashes) {
            case 0:
                // "..."   -> Keep as "..."
                curString.append(curChar);
                break;
            case 1:
            case 2:
                // "\..."  -> Keep as "\..."
                // "\\..." -> Keep as "\\..."
                curString.append(QString("\\").repeated(consecutiveSlashes) + curChar);
                break;
            default:
                // This shouldn't ever happen (even with invalid wildcard rules), log a warning
                qWarning() << Q_FUNC_INFO << "Wildcard rule"
                           << rule << "resulted in rule component"
                           << curString << "with unexpected count of consecutive '\\' ("
                           << consecutiveSlashes << "), ignoring " << curChar << "char escape!";
                break;
            }
            // Don't mark as past rule start for whitespace (whitespace gets trimmed)
            if (!curChar.isSpace()) {
                isRuleStart = false;
            }
            consecutiveSlashes = 0;
            break;
        }
    }

    // Clean up any duplicates
    normalComponents.removeDuplicates();
    invertComponents.removeDuplicates();

    // Create full regular expressions by...
    // > Anchoring to start and end of string to mimic QRegExp's .exactMatch() handling, "^...$"
    // > Enclosing within a non-capturing group to avoid overhead of text extraction, "(?:...)"
    // > Flattening normal and inverted rules using the regex OR character "...|..."
    //
    // Before: [foo, bar, baz]
    // After:  ^(?:foo|bar|baz)$
    //
    // See https://doc.qt.io/qt-5/qregularexpression.html#porting-from-qregexp-exactmatch
    // And https://regex101.com/

    // Any empty/invalid regex are handled within ExpressionMatch::match()
    if (!normalComponents.isEmpty()) {
        // Create normal match regex
        if (normalComponents.count() == 1) {
            // Single item, skip the noncapturing group
            _matchRegEx = regExFactory("^" + normalComponents.at(0) + "$", caseSensitive);
        }
        else {
            _matchRegEx = regExFactory("^(?:" + normalComponents.join("|") + ")$", caseSensitive);
        }
        _matchRegExActive = true;
    }
    if (!invertComponents.isEmpty()) {
        // Create invert match regex
        if (invertComponents.count() == 1) {
            // Single item, skip the noncapturing group
            _matchInvertRegEx = regExFactory("^" + invertComponents.at(0) + "$", caseSensitive);
        }
        else {
            _matchInvertRegEx =
                    regExFactory("^(?:" + invertComponents.join("|") + ")$", caseSensitive);
        }
        _matchInvertRegExActive = true;
    }
}


QString ExpressionMatch::wildcardToRegEx(const QString &expression)
{
    // Convert the wildcard expression into regular expression format

    // We're taking a little bit different of a route...
    //
    // Original QRegExp::Wildcard rules:
    // --------------------------
    // Wildcard | Regex | Outcome
    // ---------|-------|--------
    // *        | .*    | zero or more of any character
    // ?        | .     | any single character
    //
    // NOTE 1: This is QRegExp::Wildcard, not QRegExp::WildcardUnix
    //
    // NOTE 2: We are ignoring the "[...]" character-class matching functionality of
    // QRegExp::Wildcard as that feature's a bit more complex and can be handled with full-featured
    // regexes.
    //
    // See https://doc.qt.io/qt-5/qregexp.html#wildcard-matching
    //
    // Quassel originally did not use QRegExp::WildcardUnix, which prevented escaping "*" and "?" in
    // messages.  Unfortunately, spam messages might decide to use both, so offering a way to escape
    // makes sense.
    //
    // On the flip-side, that means to match "\" requires escaping as "\\", breaking backwards
    // compatibility.
    //
    // Quassel's Wildcard rules
    // ------------------------------------------
    // Wildcard | Regex escaped | Regex | Outcome
    // ---------|---------------|-------|--------
    // *        | \*            | .*    | zero or more of any character
    // ?        | \?            | .     | any single character
    // \*       | \\\*          | \*    | literal "*"
    // \?       | \\\?          | \?    | literal "?"
    // \[...]   | \\[...]       | [...] | invalid escape, ignore it
    // \\       | \\\\          | \\    | literal "\"
    //
    // In essence, "*" and "?" need changed only if not escaped, "\\" collapses into "\", "\" gets
    // ignored; other characters escape normally.
    //
    // Example:
    //
    // > Wildcard rule
    // never?gonna*give\*you\?up\\test|y\yeah\\1\\\\2\\\1inval
    //
    // ("\\\\" represents "\\", "\\" represents "\", and "\\\" is valid+invalid, "\")
    //
    // > Regex escaped wildcard rule
    // never\?gonna\*give\\\*you\\\?up\\\\test\|y\\yeah\\\\1\\\\\\\\2\\\\\\1inval
    //
    // > Expected correct regex
    // never.gonna.*give\*you\?up\\test\|yyeah\\1\\\\2\\1inval
    //
    // > Undoing regex escaping of "\" as "\\" (i.e. simple replace, with special escapes intact)
    // never.gonna.*give\*you\?up\test\|yyeah\1\\2\1inval

    // Escape string according to regex
    QString regExEscaped(regExEscape(expression));

    // Fix up the result
    //
    // NOTE: In theory, regular expression lookbehind could solve this.  Unfortunately, QRegExp does
    // not support lookbehind, and it's theoretically inefficient, anyways.  Just use an approach
    // similar to that taken by QRegExp's official wildcard mode.
    //
    // Lookbehind example (that we can't use):
    // (?<!abc)test    Negative lookbehind - don't match if "test" is proceeded by "abc"
    //
    // See https://code.qt.io/cgit/qt/qtbase.git/tree/src/corelib/tools/qregexp.cpp
    //
    // NOTE: We don't copy QRegExp's mode as QRegularExpression has more special characters.  We
    // can't use the same escaping code, hence calling the appropriate QReg[...]::escape() above.

    // Prepare to loop!

    // Result
    QString result = {};
    // Current character
    QChar curChar = {};
    // Max length
    int sourceLength = regExEscaped.length();
    // Consecutive "\" characters
    int consecutiveSlashes = 0;

    // We know it's going to be the same length or smaller, so reserve the same size as the string
    result.reserve(sourceLength);

    // For every character...
    for (int i = 0; i < sourceLength; i++) {
        // Get the character
        curChar = regExEscaped.at(i);
        // Check if it's on the list of special wildcard characters, converting to Unicode for use
        // in the switch statement
        //
        // See https://doc.qt.io/qt-5/qchar.html#unicode
        switch (curChar.unicode()) {
        case '?':
            // Wildcard "?"
            switch (consecutiveSlashes) {
            case 1:
                // "?" -> "\?" -> "."
                // Convert from regex escaped "?" to regular expression
                result.append(".");
                break;
            case 3:
                // "\?" -> "\\\?" -> "\?"
                // Convert from regex escaped "\?" to literal string
                result.append(R"(\?)");
                break;
            default:
                // This shouldn't ever happen (even with invalid wildcard rules), log a warning
                qWarning() << Q_FUNC_INFO << "Wildcard rule"
                           << expression << "resulted in escaped regular expression string"
                           << regExEscaped << " with unexpected count of consecutive '\\' ("
                           << consecutiveSlashes << "), ignoring" << curChar << "character!";
                break;
            }
            consecutiveSlashes = 0;
            break;
        case '*':
            // Wildcard "*"
            switch (consecutiveSlashes) {
            case 1:
                // "*" -> "\*" -> ".*"
                // Convert from regex escaped "*" to regular expression
                result.append(".*");
                break;
            case 3:
                // "\*" -> "\\\*" -> "\*"
                // Convert from regex escaped "\*" to literal string
                result.append(R"(\*)");
                break;
            default:
                // This shouldn't ever happen (even with invalid wildcard rules), log a warning
                qWarning() << Q_FUNC_INFO << "Wildcard rule"
                           << expression << "resulted in escaped regular expression string"
                           << regExEscaped << " with unexpected count of consecutive '\\' ("
                           << consecutiveSlashes << "), ignoring" << curChar << "character!";
                break;
            }
            consecutiveSlashes = 0;
            break;
        case '\\':
            // Wildcard escape
            // Increase consecutive slash count
            consecutiveSlashes++;
            // Check if we've hit an escape sequence
            if (consecutiveSlashes == 4) {
                // "\\" -> "\\\\" -> "\\"
                // Convert from regex escaped "\\" to literal string
                result.append(R"(\\)");
                // Reset slash count
                consecutiveSlashes = 0;
            }
            break;
        default:
            // Any other character
            switch (consecutiveSlashes) {
            case 0:
            case 2:
                // "[...]"  -> "[...]"   -> "[...]"
                // ...or...
                // "\[...]" -> "\\[...]" -> "[...]"
                // Either just print the character itself, or convert from regex-escaped invalid
                // wildcard escape sequence to the character itself
                //
                // Both mean doing nothing, the actual character [...] gets appended below
                break;
            case 1:
                // "[...]" -> "\[...]" -> "\"
                // Keep regex-escaped special character "[...]" as literal string
                // (Where "[...]" represents any non-wildcard regex special character)
                result.append(R"(\)");
                // The actual character [...] gets appended below
                break;
            default:
                // This shouldn't ever happen (even with invalid wildcard rules), log a warning
                qWarning() << Q_FUNC_INFO << "Wildcard rule"
                           << expression << "resulted in escaped regular expression string"
                           << regExEscaped << " with unexpected count of consecutive '\\' ("
                           << consecutiveSlashes << "), ignoring" << curChar << "char escape!";
                break;
            }
            consecutiveSlashes = 0;
            // Add the character itself
            result.append(curChar);
            break;
        }
    }

    // Anchoring to simulate QRegExp::exactMatch() is handled in
    // ExpressionMatch::convertFromWildcard()
    return result;
}
