/*
 *  SPDX-FileCopyrightText: 2019 Agata Cacko <cacko.azh@gmail.com>
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 */

#include "KisResourceSearchBoxFilter.h"


#include <QRegularExpression>
#include <QList>
#include <QSet>
#include <kis_debug.h>

class Q_DECL_HIDDEN KisResourceSearchBoxFilter::Private
{
public:
    Private()
        : searchTokenizer("\\s*,+\\s*")
    {}

    QRegularExpression searchTokenizer;

    QChar excludeBegin {'!'};
    QChar tagBegin {'#'};
    QChar exactMatchBeginEnd {'"'};

    QSet<QString> tagExactMatchesIncluded;
    QSet<QString> tagExactMatchesExcluded;
    QSet<QString> resourceExactMatchesIncluded;
    QSet<QString> resourceExactMatchesExcluded;

    QList<QString> resourceNamesPartialIncluded;
    QList<QString> resourceNamesPartialExcluded;
    QList<QString> tagsPartialIncluded;
    QList<QString> tagsPartialExcluded;

    QString filter;
};


KisResourceSearchBoxFilter::KisResourceSearchBoxFilter()
    : m_d(new Private())
{
}

KisResourceSearchBoxFilter::~KisResourceSearchBoxFilter()
{

}

bool checkDelimitersAndCut(const QChar& begin, const QChar& end, QString& token) {
    if (token.startsWith(begin) && token.endsWith(end)) {
        token.remove(0, 1);
        token = token.left(token.length() - 1);
        return true;
    } else {
        return false;
    }
}

bool checkDelimitersAndCut(const QChar& beginEnd, QString& token) {
    return checkDelimitersAndCut(beginEnd, beginEnd, token);
}

bool checkPrefixAndCut(QChar& prefix, QString& token) {
    if (token.startsWith(prefix)) {
        token.remove(0, 1);
        return true;
    } else {
        return false;
    }
}

void KisResourceSearchBoxFilter::setFilter(const QString& filter)
{
    m_d->filter = QString(filter);
    initializeFilterData();
}


bool KisResourceSearchBoxFilter::matchesResource(const QString &_resourceName, const QStringList &tagList) const
{
    // exact matches
    QString resourceName = _resourceName.toLower();

    if (m_d->resourceExactMatchesIncluded.count() > 0
            && !m_d->resourceExactMatchesIncluded.contains(resourceName)) {
        return false;
    }
    if (m_d->resourceExactMatchesExcluded.contains(resourceName)) {
        return false;
    }

    // partial name matches
    if (m_d->resourceNamesPartialIncluded.count() > 0) {
        Q_FOREACH(const QString& partialName, m_d->resourceNamesPartialIncluded) {
            if (!resourceName.contains(partialName) && tagList.filter(partialName, Qt::CaseInsensitive).isEmpty()) {
                return false;
            }
        }
    }

    Q_FOREACH(const QString& partialName, m_d->resourceNamesPartialExcluded) {
        if (resourceName.contains(partialName) || tagList.filter(partialName, Qt::CaseInsensitive).size() > 0) {
            return false;
        }
    }

    // Tag partial matches
    if (m_d->tagsPartialIncluded.count() > 0 ) {
        Q_FOREACH(const QString& partialTag, m_d->tagsPartialIncluded) {
            if (tagList.filter(partialTag, Qt::CaseInsensitive).isEmpty()) {
                return false;
            }
        }
    }

    if (m_d->tagsPartialExcluded.count() > 0) {
        Q_FOREACH(const QString& partialTag, m_d->tagsPartialExcluded) {
            if (tagList.filter(partialTag, Qt::CaseInsensitive).size() > 0) {
                return false;
            }
        }
    }

    // Tag exact matches
    if (m_d->tagExactMatchesIncluded.count() > 0) {
        Q_FOREACH(const QString& tagName, m_d->tagExactMatchesIncluded) {
            if (!tagList.contains(tagName, Qt::CaseInsensitive)) {
                return false;
            }
        }
    }

    if (m_d->tagExactMatchesExcluded.count() > 0) {
        Q_FOREACH(const QString excludedTag, m_d->tagExactMatchesExcluded) {
            if (tagList.contains(excludedTag, Qt::CaseInsensitive)) {
                return false;
            }
        }
    }

    return true;
}

bool KisResourceSearchBoxFilter::isEmpty()
{
    return m_d->filter.isEmpty();
}

void KisResourceSearchBoxFilter::clearFilterData()
{
    m_d->resourceExactMatchesIncluded.clear();
    m_d->resourceExactMatchesExcluded.clear();
    m_d->tagExactMatchesIncluded.clear();
    m_d->tagExactMatchesExcluded.clear();

    m_d->resourceNamesPartialIncluded.clear();
    m_d->resourceNamesPartialExcluded.clear();
    m_d->tagsPartialIncluded.clear();
    m_d->tagsPartialExcluded.clear();
}

void KisResourceSearchBoxFilter::initializeFilterData()
{
    clearFilterData();

    QString tempFilter(m_d->filter);

    QStringList tokens = tempFilter.split(m_d->searchTokenizer, Qt::SkipEmptyParts);

    Q_FOREACH(const QString& token, tokens) {
        QString workingToken(token.toLower());
        const bool included = !checkPrefixAndCut(m_d->excludeBegin, workingToken);

        if (checkPrefixAndCut(m_d->tagBegin, workingToken)) {
            if (checkDelimitersAndCut(m_d->exactMatchBeginEnd, workingToken)) {
                if (included) {

                    m_d->tagExactMatchesIncluded.insert(workingToken);
                } else {

                    m_d->tagExactMatchesExcluded.insert(workingToken);
                }
            } else {
                if (included) {

                    m_d->tagsPartialIncluded.append(workingToken);
                } else {

                    m_d->tagsPartialExcluded.append(workingToken);
                }
            }
        } else if (checkDelimitersAndCut(m_d->exactMatchBeginEnd, workingToken)) {
            if (included) {

                m_d->resourceExactMatchesIncluded.insert(workingToken);
            } else {

                m_d->resourceExactMatchesExcluded.insert(workingToken);
            }

        } else {
            if (included) {

                m_d->resourceNamesPartialIncluded.append(workingToken);
            } else {

                m_d->resourceNamesPartialExcluded.append(workingToken);
            }
        }
    }
}
