// SPDX-FileCopyrightText: 2003-2013 Jesper K. Pedersen <jesper.pedersen@kdab.com>
// SPDX-FileCopyrightText: 2005-2007 Dirk Mueller <mueller@kde.org>
// SPDX-FileCopyrightText: 2006-2008 Tuomas Suutari <tuomas@nepnep.net>
// SPDX-FileCopyrightText: 2007-2010 Jan Kundrát <jkt@flaska.net>
// SPDX-FileCopyrightText: 2007-2008 Laurent Montel <montel@kde.org>
// SPDX-FileCopyrightText: 2008 Henner Zeller <h.zeller@acm.org>
// SPDX-FileCopyrightText: 2009 Hassan Ibraheem <hasan.ibraheem@gmail.com>
// SPDX-FileCopyrightText: 2011-2012 Miika Turkia <miika.turkia@gmail.com>
// SPDX-FileCopyrightText: 2012-2016, 2018-2023 Johannes Zarl-Zierl <johannes@zarl-zierl.at>
// SPDX-FileCopyrightText: 2017-2020 Robert Krawitz <rlk@alum.mit.edu>
// SPDX-FileCopyrightText: 2014-2024 Tobias Leupold <tl@stonemx.de>
//
// SPDX-License-Identifier: GPL-2.0-or-later

#include "ImageSearchInfo.h"

#include "AndCategoryMatcher.h"
#include "CategoryMatcher.h"
#include "ContainerCategoryMatcher.h"
#include "ExactCategoryMatcher.h"
#include "NegationCategoryMatcher.h"
#include "NoTagCategoryMatcher.h"
#include "OrCategoryMatcher.h"
#include "ValueCategoryMatcher.h"
#include "WildcardCategoryMatcher.h"

#include <DB/ImageDB.h>
#include <ImageManager/RawImageDecoder.h>
#include <kpabase/FileExtensions.h>
#include <kpabase/Logging.h>
#include <kpabase/SettingsData.h>

#include <KConfigGroup>
#include <KLocalizedString>
#include <KSharedConfig>
#include <QApplication>
#include <QRegularExpression>

using namespace DB;

static QAtomicInt s_matchGeneration;
static int nextGeneration()
{
    return s_matchGeneration++;
}

ImageSearchInfo::ImageSearchInfo()
    : m_matchGeneration(nextGeneration())
{
}

ImageSearchInfo::ImageSearchInfo(const ImageDate &date,
                                 const QString &label, const QString &description)
    : m_date(date)
    , m_label(label)
    , m_description(description)
    , m_isNull(false)
    , m_matchGeneration(nextGeneration())
{
}

ImageSearchInfo::ImageSearchInfo(const ImageDate &date,
                                 const QString &label, const QString &description,
                                 const QString &fnPattern)
    : m_date(date)
    , m_label(label)
    , m_description(description)
    , m_fnPattern(fnPattern)
    , m_isNull(false)
    , m_matchGeneration(nextGeneration())
{
}

QString ImageSearchInfo::label() const
{
    return m_label;
}

QRegularExpression ImageSearchInfo::fnPattern() const
{
    return m_fnPattern;
}

QString ImageSearchInfo::description() const
{
    return m_description;
}

void ImageSearchInfo::checkIfNull()
{
    if (m_compiled.valid || isNull())
        return;
    if (m_date.isNull() && m_label.isEmpty() && m_description.isEmpty()
        && m_rating == -1 && m_megapixel == 0 && m_exifSearchInfo.isEmpty()
        && m_categoryMatchText.isEmpty()
        && freeformMatchText().isEmpty()
#ifdef HAVE_KGEOMAP
        && !m_regionSelection.first.hasCoordinates() && !m_regionSelection.second.hasCoordinates()
#endif
    ) {
        m_isNull = true;
    }
}

bool ImageSearchInfo::isNull() const
{
    return m_isNull;
}

bool ImageSearchInfo::isCacheable() const
{
    return m_isCacheable;
}

void ImageSearchInfo::setCacheable(bool cacheable)
{
    m_isCacheable = cacheable;
}

bool ImageSearchInfo::match(ImageInfoPtr info) const
{
    if (m_isNull)
        return true;

    if (m_isCacheable && info->matchGeneration() == m_matchGeneration)
        return info->isMatched();

    bool ok = doMatch(info);

    if (m_isCacheable) {
        info->setMatchGeneration(m_matchGeneration);
        info->setIsMatched(ok);
    }
    return ok;
}

bool ImageSearchInfo::doMatch(ImageInfoPtr info) const
{
    if (!m_compiled.valid)
        compile();

    // -------------------------------------------------- Rating

    // ok = ok && (_rating == -1 ) || ( _rating == info->rating() );
    if (m_rating != -1) {
        switch (m_ratingSearchMode) {
        case 1:
            // Image rating at least selected
            if (m_rating > info->rating())
                return false;
            break;
        case 2:
            // Image rating less than selected
            if (m_rating < info->rating())
                return false;
            break;
        case 3:
            // Image rating not equal
            if (m_rating == info->rating())
                return false;
            break;
        default:
            if (m_rating != info->rating())
                return false;
            break;
        }
    }

    // -------------------------------------------------- Resolution
    if (m_megapixel && (m_megapixel * 1000000 > info->size().width() * info->size().height()))
        return false;

    if (m_max_megapixel && m_max_megapixel < m_megapixel && (m_max_megapixel * 1000000 < info->size().width() * info->size().height()))
        return false;

    // -------------------------------------------------- Date
    Utilities::FastDateTime actualStart = info->date().start();
    Utilities::FastDateTime actualEnd = info->date().end();

    if (m_date.start().isValid()) {
        if (actualEnd < m_date.start() || (m_date.end().isValid() && actualStart > m_date.end()))
            return false;
    } else if (m_date.end().isValid() && actualStart > m_date.end()) {
        return false;
    }

    // -------------------------------------------------- Label
    if (!m_label.isEmpty() && info->label().indexOf(m_label) == -1)
        return false;

    // -------------------------------------------------- RAW
    if (m_searchRAW && !KPABase::isUsableRawImage(info->fileName()))
        return false;

#ifdef HAVE_MARBLE
    // Search for GPS Position
    if (!m_regionSelection.isNull()) {
        if (!info->coordinates().hasCoordinates())
            return false;

        if (!m_regionSelection.contains(info->coordinates()))
            return false;
    }
#endif

    // -------------------------------------------------- File name pattern
    if (!m_fnPattern.pattern().isEmpty()) {
        const auto match = m_fnPattern.match(info->fileName().relative());
        if (!match.hasMatch()) {
            return false;
        }
    }

    // -------------------------------------------------- Options
    // alreadyMatched map is used to make it possible to search for
    // Jesper & None
    QMap<QString, StringSet> alreadyMatched;
    for (CategoryMatcher *optionMatcher : m_compiled.categoryMatchers) {
        if (!optionMatcher->eval(info, alreadyMatched))
            return false;
    }

    // -------------------------------------------------- Text
    if (!m_description.isEmpty()) {
        const QString &txt(info->description());
        const QStringList list = m_description.split(QChar::fromLatin1(' '), Qt::SkipEmptyParts);
        for (const QString &word : list) {
            if (txt.indexOf(word, 0, Qt::CaseInsensitive) == -1)
                return false;
        }
    }

    // -------------------------------------------------- EXIF
    if (!m_exifSearchInfo.matches(info->fileName()))
        return false;

    // -------------------------------------------------- Freeform
    if (!freeformMatchText().isEmpty()) {
        const auto re = m_freeformMatcher.regularExpression();
        if (!re.match(info->label()).hasMatch()
            && !re.match(info->fileName().relative()).hasMatch()
            && !re.match(info->description()).hasMatch()
            && !m_freeformMatcher.eval(info)) {
            return false;
        }
    }

    return true;
}

QString ImageSearchInfo::categoryMatchText(const QString &name) const
{
    return m_categoryMatchText[name];
}

void ImageSearchInfo::setCategoryMatchText(const QString &name, const QString &value)
{
    if (value.isEmpty()) {
        m_categoryMatchText.remove(name);
    } else {
        m_categoryMatchText[name] = value;
    }
    m_isNull = false;
    m_compiled.valid = false;
    m_matchGeneration = nextGeneration();
}

void ImageSearchInfo::addAnd(const QString &category, const QString &value)
{
    // Escape literal "&"s in value by doubling it
    QString escapedValue = value;
    escapedValue.replace(QString::fromUtf8("&"), QString::fromUtf8("&&"));

    QString val = categoryMatchText(category);
    if (!val.isEmpty())
        val += QString::fromLatin1(" & ") + escapedValue;
    else
        val = escapedValue;

    setCategoryMatchText(category, val);
    m_isNull = false;
    m_compiled.valid = false;
    m_matchGeneration = nextGeneration();
}

void ImageSearchInfo::setRating(short rating)
{
    m_rating = rating;
    m_isNull = false;
    m_matchGeneration = nextGeneration();
    // compiled data is not affected
}

void ImageSearchInfo::setMegaPixel(short megapixel)
{
    m_megapixel = megapixel;
    m_matchGeneration = nextGeneration();
}

void ImageSearchInfo::setMaxMegaPixel(short max_megapixel)
{
    m_max_megapixel = max_megapixel;
    m_matchGeneration = nextGeneration();
}

void ImageSearchInfo::setSearchMode(int index)
{
    m_ratingSearchMode = index;
    m_matchGeneration = nextGeneration();
}

void ImageSearchInfo::setSearchRAW(bool searchRAW)
{
    m_searchRAW = searchRAW;
    m_matchGeneration = nextGeneration();
}

QString ImageSearchInfo::toString() const
{
    QString res;
    bool first = true;
    for (QMap<QString, QString>::ConstIterator it = m_categoryMatchText.begin(); it != m_categoryMatchText.end(); ++it) {
        if (!it.value().isEmpty()) {
            if (first)
                first = false;
            else
                res += QString::fromLatin1(" / ");

            QString txt = it.value();
            if (txt == ImageDB::NONE())
                txt = i18nc("As in No persons, no locations etc. I do realize that translators may have problem with this, "
                            "but I need some how to indicate the category, and users may create their own categories, so this is "
                            "the best I can do - Jesper.",
                            "No %1", it.key());

            if (txt.contains(QString::fromLatin1("|")))
                txt.replace(QString::fromLatin1("&"), QString::fromLatin1(" %1 ").arg(i18n("and")));

            else
                txt.replace(QString::fromLatin1("&"), QString::fromLatin1(" / "));

            txt.replace(QString::fromLatin1("|"), QString::fromLatin1(" %1 ").arg(i18n("or")));
            txt.replace(QString::fromLatin1("!"), QString::fromLatin1(" %1 ").arg(i18n("not")));
            txt.replace(ImageDB::NONE(), i18nc("As in no other persons, or no other locations. "
                                               "I do realize that translators may have problem with this, "
                                               "but I need some how to indicate the category, and users may create their own categories, so this is "
                                               "the best I can do - Jesper.",
                                               "No other %1", it.key()));

            res += txt.simplified();
        }
    }
    return res;
}

void ImageSearchInfo::debug()
{
    for (QMap<QString, QString>::Iterator it = m_categoryMatchText.begin(); it != m_categoryMatchText.end(); ++it) {
        qCDebug(DBCategoryMatcherLog) << it.key() << ", " << it.value();
    }
}

QVariantMap ImageSearchInfo::getLockData() const
{
    QVariantMap pairs;
    pairs[QString::fromLatin1("label")] = m_label;
    pairs[QString::fromLatin1("description")] = m_description;
    pairs[QString::fromLatin1("categories")] = QVariant(m_categoryMatchText.keys());
    for (QMap<QString, QString>::ConstIterator it = m_categoryMatchText.begin(); it != m_categoryMatchText.end(); ++it) {
        pairs[it.key()] = it.value();
    }
    return pairs;
}

ImageSearchInfo ImageSearchInfo::loadLock(const QMap<QString, QVariant> &keyValuePairs)
{
    ImageSearchInfo info;
    info.m_label = keyValuePairs.value(QString::fromLatin1("label"), {}).toString();
    info.m_description = keyValuePairs.value(QString::fromLatin1("description"), {}).toString();
    QStringList categories = keyValuePairs.value(QString::fromLatin1("categories"), {}).toStringList();
    for (QStringList::ConstIterator it = categories.constBegin(); it != categories.constEnd(); ++it) {
        info.setCategoryMatchText(*it, keyValuePairs.value(*it, {}).toString());
    }
    return info;
}

void ImageSearchInfo::compile() const
{
    qCDebug(DBCategoryMatcherLog) << "Compiling search info...";
    m_exifSearchInfo.search();

    CompiledDataPrivate compiledData;

    for (QMap<QString, QString>::ConstIterator it = m_categoryMatchText.begin(); it != m_categoryMatchText.end(); ++it) {
        const QString category = it.key();
        const QString matchText = it.value();

        const QStringList orParts = matchText.split(QString::fromLatin1("|"), Qt::SkipEmptyParts);
        DB::ContainerCategoryMatcher *orMatcher = new DB::OrCategoryMatcher;

        for (QString orPart : orParts) {
            // Split by " & ", not only by "&", so that the doubled "&"s won't be used as a split point
            const QStringList andParts = orPart.split(QString::fromLatin1(" & "), Qt::SkipEmptyParts);

            DB::ContainerCategoryMatcher *andMatcher;
            bool exactMatch = false;
            bool negate = false;
            andMatcher = new DB::AndCategoryMatcher;

            for (QString str : andParts) {
                static const QRegularExpression regexp(QString::fromLatin1("^\\s*!\\s*(.*)$"));
                const auto match = regexp.match(str);
                if (match.hasMatch()) { // str is preceded with NOT
                    negate = true;
                    str = match.captured(1);
                }
                str = str.trimmed();
                CategoryMatcher *valueMatcher;
                if (str == ImageDB::NONE()) { // mark AND-group as containing a "No other" condition
                    exactMatch = true;
                    continue;
                } else {
                    valueMatcher = new DB::ValueCategoryMatcher(category, str);
                    if (negate) {
                        valueMatcher = new DB::NegationCategoryMatcher(valueMatcher);
                        negate = false;
                    }
                }
                andMatcher->addElement(valueMatcher);
            }
            if (exactMatch) {
                DB::CategoryMatcher *exactMatcher = nullptr;
                // if andMatcher has exactMatch set, but no CategoryMatchers, then
                // matching "category / None" is what we want:
                if (andMatcher->mp_elements.count() == 0) {
                    delete andMatcher;
                    exactMatcher = new DB::NoTagCategoryMatcher(category);
                } else {
                    ExactCategoryMatcher *noOtherMatcher = new ExactCategoryMatcher(category);
                    if (andMatcher->mp_elements.count() == 1)
                        noOtherMatcher->setMatcher(andMatcher->mp_elements[0]);
                    else
                        noOtherMatcher->setMatcher(andMatcher);
                    exactMatcher = noOtherMatcher;
                }
                if (negate)
                    exactMatcher = new DB::NegationCategoryMatcher(exactMatcher);
                orMatcher->addElement(exactMatcher);
            } else if (andMatcher->mp_elements.count() == 1)
                orMatcher->addElement(andMatcher->mp_elements[0]);
            else if (andMatcher->mp_elements.count() > 1)
                orMatcher->addElement(andMatcher);
            else
                delete andMatcher;
        }
        CategoryMatcher *matcher = nullptr;
        if (orMatcher->mp_elements.count() == 1)
            matcher = orMatcher->mp_elements[0];
        else if (orMatcher->mp_elements.count() > 1)
            matcher = orMatcher;
        else
            delete orMatcher;

        if (matcher) {
            compiledData.categoryMatchers.append(matcher);
            if (DBCategoryMatcherLog().isDebugEnabled()) {
                qCDebug(DBCategoryMatcherLog) << "Matching text '" << matchText << "' in category " << category << ":";
                matcher->debug(0);
                qCDebug(DBCategoryMatcherLog) << ".";
            }
        }
    }
    compiledData.valid = true;
    std::swap(m_compiled, compiledData);
}

void ImageSearchInfo::debugMatcher() const
{
    if (!m_compiled.valid)
        compile();

    qCDebug(DBCategoryMatcherLog, "And:");
    for (CategoryMatcher *optionMatcher : m_compiled.categoryMatchers) {
        optionMatcher->debug(1);
    }
}

QList<QList<SimpleCategoryMatcher *>> ImageSearchInfo::query() const
{
    if (!m_compiled.valid)
        compile();

    // Combine _optionMachers to one list of lists in Disjunctive
    // Normal Form and return it.

    QList<CategoryMatcher *>::Iterator it = m_compiled.categoryMatchers.begin();
    QList<QList<SimpleCategoryMatcher *>> result;
    if (it == m_compiled.categoryMatchers.end())
        return result;

    result = convertMatcher(*it);
    ++it;

    for (; it != m_compiled.categoryMatchers.end(); ++it) {
        QList<QList<SimpleCategoryMatcher *>> current = convertMatcher(*it);
        QList<QList<SimpleCategoryMatcher *>> oldResult = result;
        result.clear();

        for (QList<SimpleCategoryMatcher *> resultIt : oldResult) {
            for (QList<SimpleCategoryMatcher *> currentIt : current) {
                QList<SimpleCategoryMatcher *> tmp;
                tmp += resultIt;
                tmp += currentIt;
                result.append(tmp);
            }
        }
    }
    return result;
}

Utilities::StringSet ImageSearchInfo::findAlreadyMatched(const QString &group) const
{
    Utilities::StringSet result;
    const QString str = categoryMatchText(group);
    if (str.contains(QString::fromLatin1("|"))) {
        return result;
    }

    const QStringList list = str.split(QString::fromLatin1("&"), Qt::SkipEmptyParts);
    for (const QString &part : list) {
        const QString nm = part.trimmed();
        if (!nm.contains(QString::fromLatin1("!")))
            result.insert(nm);
    }
    return result;
}

QList<SimpleCategoryMatcher *> ImageSearchInfo::extractAndMatcher(CategoryMatcher *matcher) const
{
    QList<SimpleCategoryMatcher *> result;

    AndCategoryMatcher *andMatcher;
    SimpleCategoryMatcher *simpleMatcher;

    if ((andMatcher = dynamic_cast<AndCategoryMatcher *>(matcher))) {
        for (CategoryMatcher *child : andMatcher->mp_elements) {
            SimpleCategoryMatcher *simpleMatcher = dynamic_cast<SimpleCategoryMatcher *>(child);
            Q_ASSERT(simpleMatcher);
            result.append(simpleMatcher);
        }
    } else if ((simpleMatcher = dynamic_cast<SimpleCategoryMatcher *>(matcher)))
        result.append(simpleMatcher);
    else
        Q_ASSERT(false);

    return result;
}

/** Convert matcher to Disjunctive Normal Form.
 *
 * @return OR-list of AND-lists. (e.g. OR(AND(a,b),AND(c,d)))
 */
QList<QList<SimpleCategoryMatcher *>> ImageSearchInfo::convertMatcher(CategoryMatcher *item) const
{
    QList<QList<SimpleCategoryMatcher *>> result;
    OrCategoryMatcher *orMatcher;

    if ((orMatcher = dynamic_cast<OrCategoryMatcher *>(item))) {
        for (CategoryMatcher *child : orMatcher->mp_elements) {
            result.append(extractAndMatcher(child));
        }
    } else
        result.append(extractAndMatcher(item));
    return result;
}

QString ImageSearchInfo::freeformMatchText() const
{
    return m_freeformMatcher.regularExpression().pattern();
}

void ImageSearchInfo::setFreeformMatchText(const QString &freeformMatchText)
{
    setCacheable(false);
    QRegularExpression re { freeformMatchText, QRegularExpression::CaseInsensitiveOption };
    m_freeformMatcher.setRegularExpression(re);
    m_isNull = m_isNull && freeformMatchText.isEmpty();
}

short ImageSearchInfo::rating() const
{
    return m_rating;
}

ImageDate ImageSearchInfo::date() const
{
    return m_date;
}

void ImageSearchInfo::addExifSearchInfo(const Exif::SearchInfo info)
{
    m_exifSearchInfo = info;
    m_isNull = false;
    m_matchGeneration = nextGeneration();
}

void DB::ImageSearchInfo::renameCategory(const QString &oldName, const QString &newName)
{
    m_categoryMatchText[newName] = m_categoryMatchText[oldName];
    m_categoryMatchText.remove(oldName);
    m_compiled.valid = false;
    m_matchGeneration = nextGeneration();
}

#ifdef HAVE_MARBLE
Map::GeoCoordinates::LatLonBox ImageSearchInfo::regionSelection() const
{
    return m_regionSelection;
}

void ImageSearchInfo::setRegionSelection(const Map::GeoCoordinates::LatLonBox &actRegionSelection)
{
    m_regionSelection = actRegionSelection;
    if (!m_regionSelection.isNull()) {
        m_isNull = false;
    }
    m_matchGeneration = nextGeneration();
    // compiled data is not affected
}
#endif

ImageSearchInfo::CompiledDataPrivate::CompiledDataPrivate(const ImageSearchInfo::CompiledDataPrivate &)
{
    // copying invalidates the compiled data
    valid = false;
}

ImageSearchInfo::CompiledDataPrivate::~CompiledDataPrivate()
{
    qDeleteAll(categoryMatchers);
    categoryMatchers.clear();
}

ImageSearchInfo::CompiledDataPrivate &ImageSearchInfo::CompiledDataPrivate::operator=(const ImageSearchInfo::CompiledDataPrivate &)
{
    // copying invalidates the compiled data
    valid = false;
    return *this;
}

// vi:expandtab:tabstop=4 shiftwidth=4:
