aircraftmodellist.cpp

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
#include "misc/simulation/aircraftmodellist.h"
 
#include <tuple>
 
#include <QDir>
#include <QFileInfo>
#include <QJsonValue>
#include <QList>
#include <QMultiMap>
#include <QStringBuilder>
 
#include "config/buildconfig.h"
#include "misc/aviation/callsign.h"
#include "misc/directoryutils.h"
#include "misc/fileutils.h"
#include "misc/iterator.h"
#include "misc/math/mathutils.h"
#include "misc/mixin/mixincompare.h"
#include "misc/network/networkutils.h"
#include "misc/range.h"
#include "misc/setbuilder.h"
#include "misc/statusmessage.h"
#include "misc/stringutils.h"
#include "misc/swiftdirectories.h"
 
using namespace swift::config;
using namespace swift::misc::network;
using namespace swift::misc::math;
using namespace swift::misc::aviation;
using namespace swift::misc::physical_quantities;
 
SWIFT_DEFINE_SEQUENCE_MIXINS(swift::misc::simulation, CAircraftModel, CAircraftModelList)
 
namespace swift::misc::simulation
{
    CAircraftModelList::CAircraftModelList(const CSequence<CAircraftModel> &other) : CSequence<CAircraftModel>(other) {}
 
    bool CAircraftModelList::containsModelString(const QString &modelString, Qt::CaseSensitivity sensitivity) const
    {
        return std::any_of(cbegin(), cend(), [&](const CAircraftModel &model) {
            return model.matchesModelString(modelString, sensitivity);
        });
    }
 
    bool CAircraftModelList::containsModelStringOrDbKey(const CAircraftModel &model,
                                                        Qt::CaseSensitivity sensitivity) const
    {
        return std::any_of(cbegin(), cend(), [&](const CAircraftModel &m) {
            return (m.hasValidDbKey() && m.getDbKey() == model.getDbKey()) ||
                   m.matchesModelString(model.getModelString(), sensitivity);
        });
    }
 
    bool CAircraftModelList::containsCallsign(const CCallsign &callsign) const
    {
        return this->contains(&CAircraftModel::getCallsign, callsign);
    }
 
    bool CAircraftModelList::containsCombinedType(const QString &combinedType) const
    {
        if (combinedType.isEmpty()) { return false; }
        const QString ct(combinedType.toUpper().trimmed());
        return this->containsBy(
            [&](const CAircraftModel &model) { return model.getAircraftIcaoCode().getCombinedType() == ct; });
    }
 
    bool CAircraftModelList::containsModelsWithAircraftIcaoDesignator(const QString &aircraftDesignator) const
    {
        return this->contains(&CAircraftModel::getAircraftIcaoCodeDesignator, aircraftDesignator);
    }
 
    bool CAircraftModelList::containsModelsWithAircraftAndAirlineIcaoDesignator(const QString &aircraftDesignator,
                                                                                const QString &airlineDesignator) const
    {
        return this->contains(&CAircraftModel::getAircraftIcaoCodeDesignator, aircraftDesignator,
                              &CAircraftModel::getAirlineIcaoCodeDesignator, airlineDesignator);
    }
 
    bool CAircraftModelList::containsAirlineLivery(const CAirlineIcaoCode &airline) const
    {
        if (!airline.hasValidDesignator()) { return false; }
        return this->contains(&CAircraftModel::getAirlineIcaoCode, airline);
    }
 
    CAircraftModelList CAircraftModelList::findByModelString(const QString &modelString,
                                                             Qt::CaseSensitivity sensitivity) const
    {
        return this->findBy(
            [&](const CAircraftModel &model) { return model.matchesModelString(modelString, sensitivity); });
    }
 
    CAircraftModelList CAircraftModelList::findEmptyModelStrings() const
    {
        return this->findBy([&](const CAircraftModel &model) { return !model.hasModelString(); });
    }
 
    CAircraftModel CAircraftModelList::findFirstByModelStringOrDefault(const QString &modelString,
                                                                       Qt::CaseSensitivity sensitivity) const
    {
        if (modelString.isEmpty()) { return {}; }
        return this->findFirstByOrDefault(
            [&](const CAircraftModel &model) { return model.matchesModelString(modelString, sensitivity); });
    }
 
    CAircraftModel CAircraftModelList::findFirstByModelStringAliasOrDefault(const QString &modelString,
                                                                            Qt::CaseSensitivity sensitivity) const
    {
        if (modelString.isEmpty()) { return {}; }
        return this->findFirstByOrDefault(
            [&](const CAircraftModel &model) { return model.matchesModelStringOrAlias(modelString, sensitivity); });
    }
 
    CAircraftModel CAircraftModelList::findFirstByCallsignOrDefault(const CCallsign &callsign) const
    {
        if (callsign.isEmpty()) { return {}; }
        return this->findFirstByOrDefault([&](const CAircraftModel &model) { return model.getCallsign() == callsign; });
    }
 
    CAircraftModelList CAircraftModelList::findByIcaoDesignators(const CAircraftIcaoCode &aircraftIcaoCode,
                                                                 const CAirlineIcaoCode &airlineIcaoCode) const
    {
        const QString aircraft(aircraftIcaoCode.getDesignator());
        const QString airline(airlineIcaoCode.getDesignator());
 
        if (airline.isEmpty())
        {
            return this->findBy(
                [&](const CAircraftModel &model) { return model.getAircraftIcaoCode().getDesignator() == aircraft; });
        }
        if (aircraft.isEmpty())
        {
            return this->findBy(
                [&](const CAircraftModel &model) { return model.getAirlineIcaoCode().getDesignator() == airline; });
        }
        return this->findBy([&](const CAircraftModel &model) {
            return model.getAirlineIcaoCode().getDesignator() == airline &&
                   model.getAircraftIcaoCode().getDesignator() == aircraft;
        });
    }
 
    CAircraftModelList CAircraftModelList::findByAircraftAndAirline(const CAircraftIcaoCode &aircraftIcaoCode,
                                                                    const CAirlineIcaoCode &airlineIcaoCode) const
    {
        return this->findBy(&CAircraftModel::getAircraftIcaoCode, aircraftIcaoCode, &CAircraftModel::getAirlineIcaoCode,
                            airlineIcaoCode);
    }
 
    CAircraftModelList
    CAircraftModelList::findByAircraftDesignatorAndLiveryCombinedCode(const QString &aircraftDesignator,
                                                                      const QString &combinedCode) const
    {
        if (aircraftDesignator.isEmpty()) { return {}; }
        return this->findBy([&](const CAircraftModel &model) {
            if (!model.getAircraftIcaoCode().matchesDesignator(aircraftDesignator)) { return false; }
            return model.getLivery().matchesCombinedCode(combinedCode);
        });
    }
 
    CAircraftModelList CAircraftModelList::findByAircraftAndLivery(const CAircraftIcaoCode &aircraftIcaoCode,
                                                                   const CLivery &livery) const
    {
        return this->findBy(&CAircraftModel::getAircraftIcaoCode, aircraftIcaoCode, &CAircraftModel::getLivery, livery);
    }
 
    CAircraftModelList CAircraftModelList::findByAirlineGroup(const CAirlineIcaoCode &airline) const
    {
        const int id = airline.getGroupId();
        if (id < 0) return {};
        return this->findBy([&](const CAircraftModel &model) { return model.getAirlineIcaoCode().getGroupId() == id; });
    }
 
    CAircraftModelList CAircraftModelList::findByAirlineNameAndTelephonyDesignator(const QString &name,
                                                                                   const QString &telephony,
                                                                                   bool onlyIfExistInModel) const
    {
        return this->findBy([&](const CAircraftModel &model) {
            if (!model.hasAirlineDesignator() || !model.hasValidDbKey()) { return false; }
            const CAirlineIcaoCode &icao = model.getAirlineIcaoCode();
            if (!name.isEmpty() && (icao.hasName() || !onlyIfExistInModel))
            {
                if (!icao.getName().contains(name, Qt::CaseInsensitive)) { return false; }
            }
 
            if (!telephony.isEmpty() && (icao.hasTelephonyDesignator() || !onlyIfExistInModel))
            {
                if (!icao.getTelephonyDesignator().contains(name, Qt::CaseInsensitive)) { return false; }
            }
            return true;
        });
    }
 
    CAircraftModelList CAircraftModelList::findByAirlineNamesOrTelephonyDesignator(const QString &name) const
    {
        return this->findBy([&](const CAircraftModel &model) {
            if (!model.hasAirlineDesignator() || !model.hasValidDbKey()) { return false; }
            const CAirlineIcaoCode &icao = model.getAirlineIcaoCode();
            return icao.matchesNamesOrTelephonyDesignator(name);
        });
    }
 
    CAircraftModelList CAircraftModelList::findByLiveryCode(const CLivery &livery) const
    {
        if (!livery.hasCombinedCode()) { return {}; }
        const QString code(livery.getCombinedCode());
        return this->findBy([&](const CAircraftModel &model) {
            if (!model.getLivery().hasCombinedCode()) return false;
            return model.getLivery().getCombinedCode() == code;
        });
    }
 
    CAircraftModelList CAircraftModelList::findWithFileName() const
    {
        return this->findBy([](const CAircraftModel &model) { return model.hasFileName(); });
    }
 
    CAircraftModelList CAircraftModelList::findByDistributor(const CDistributor &distributor) const
    {
        return this->findBy([&](const CAircraftModel &model) { return model.getDistributor() == distributor; });
    }
 
    CAircraftModelList CAircraftModelList::findWithAircraftDesignator() const
    {
        return this->findBy([](const CAircraftModel &model) { return model.hasAircraftDesignator(); });
    }
 
    CAircraftModelList CAircraftModelList::findWithAircraftDesignator(const QSet<QString> &designators) const
    {
        if (designators.isEmpty()) { return {}; }
        return this->findBy(
            [&](const CAircraftModel &model) { return designators.contains(model.getAircraftIcaoCodeDesignator()); });
    }
 
    CAircraftModelList CAircraftModelList::findWithKnownAircraftDesignator() const
    {
        return this->findBy([](const CAircraftModel &model) { return model.hasKnownAircraftDesignator(); });
    }
 
    CAircraftModelList CAircraftModelList::findByManufacturer(const QString &manufacturer) const
    {
        if (manufacturer.isEmpty()) { return {}; }
        const QString m(manufacturer.toUpper().trimmed());
        return this->findBy(
            [&](const CAircraftModel &model) { return model.getAircraftIcaoCode().getManufacturer() == m; });
    }
 
    CAircraftModelList CAircraftModelList::findByFamily(const QString &family) const
    {
        if (family.isEmpty()) { return {}; }
        const QString f(family.toUpper().trimmed());
        return this->findBy([&](const CAircraftModel &model) {
            const CAircraftIcaoCode icao(model.getAircraftIcaoCode());
            if (!icao.hasFamily()) { return false; }
            return icao.getFamily() == f;
        });
    }
 
    CAircraftModelList CAircraftModelList::findByFamilyWithColorLivery(const QString &family) const
    {
        if (family.isEmpty()) { return {}; }
        const QString f(family.toUpper().trimmed());
        return this->findBy([&](const CAircraftModel &model) {
            if (!model.getLivery().isColorLivery()) { return false; }
            const CAircraftIcaoCode icao(model.getAircraftIcaoCode());
            if (!icao.hasFamily()) { return false; }
            return icao.getFamily() == f;
        });
    }
 
    CAircraftModelList CAircraftModelList::findByDesignatorOrFamilyWithColorLivery(const CAircraftIcaoCode &icao) const
    {
        return this->findBy([&](const CAircraftModel &model) {
            if (!model.getLivery().isColorLivery()) { return false; }
            const CAircraftIcaoCode modelIcao(model.getAircraftIcaoCode());
            if (modelIcao.getDesignator() == icao.getDesignator()) { return true; }
            return icao.hasFamily() && modelIcao.getFamily() == icao.getFamily();
        });
    }
 
    CAircraftModelList
    CAircraftModelList::findByDesignatorsOrFamilyWithColorLivery(const QStringList &designators) const
    {
        return this->findBy([&](const CAircraftModel &model) {
            if (!model.getLivery().isColorLivery()) { return false; }
            const CAircraftIcaoCode modelIcao(model.getAircraftIcaoCode());
            if (designators.contains(modelIcao.getDesignator())) { return true; }
            return modelIcao.hasFamily() && designators.contains(modelIcao.getFamily());
        });
    }
 
    CAircraftModelList CAircraftModelList::findByCombinedType(const QString &combinedType) const
    {
        const QString cc(combinedType.trimmed().toUpper());
        if (combinedType.length() != 3) { return {}; }
        return this->findBy([&](const CAircraftModel &model) {
            const CAircraftIcaoCode icao(model.getAircraftIcaoCode());
            return icao.matchesCombinedType(cc);
        });
    }
 
    CAircraftModelList CAircraftModelList::findByCombinedTypeAndWtc(const QString &combinedType,
                                                                    const QString &wtc) const
    {
        const CAircraftModelList ml = this->findByCombinedType(combinedType);
        if (ml.isEmpty()) { return ml; }
        const CWakeTurbulenceCategory wtcUc =
            wtc.isEmpty() ? CWakeTurbulenceCategory() : CWakeTurbulenceCategory(wtc.toUpper().trimmed().at(0));
        return this->findBy([&](const CAircraftModel &model) {
            const CAircraftIcaoCode icao(model.getAircraftIcaoCode());
            return icao.getWtc() == wtcUc;
        });
    }
 
    CAircraftModelList CAircraftModelList::findByCombinedTypeWithColorLivery(const QString &combinedType) const
    {
        return this->findByCombinedType(combinedType).findColorLiveries();
    }
 
    CAircraftModelList CAircraftModelList::findByCombinedTypeAndWtcWithColorLivery(const QString &combinedType,
                                                                                   const QString &wtc) const
    {
        return this->findByCombinedTypeAndWtc(combinedType, wtc).findColorLiveries();
    }
 
    CAircraftModelList CAircraftModelList::findByCombinedAndManufacturer(const CAircraftIcaoCode &icao) const
    {
        return this->findByCombinedAndManufacturer(icao.getCombinedType(), icao.getManufacturer());
    }
 
    CAircraftModelList CAircraftModelList::findByCombinedAndManufacturer(const QString &combinedType,
                                                                         const QString &manufacturer) const
    {
        if (manufacturer.isEmpty()) { return this->findByCombinedType(combinedType); }
        if (combinedType.isEmpty()) { return this->findByManufacturer(manufacturer); }
        return this->findBy([&](const CAircraftModel &model) {
            return model.getAircraftIcaoCode().matchesCombinedTypeAndManufacturer(combinedType, manufacturer);
        });
    }
 
    CAircraftModelList CAircraftModelList::findClosestColorDistance(const CRgbColor &fuselage,
                                                                    const CRgbColor &tail) const
    {
        double distance = 2.0;
        CAircraftModelList models;
        for (const CAircraftModel &m : (*this))
        {
            const CLivery &l = m.getLivery();
            if (!l.hasColorTail() || !l.hasColorFuselage()) { continue; }
            const double d = l.getColorDistance(fuselage, tail);
            if (qFuzzyCompare(d, distance)) { models.push_back(m); }
            else if (distance > d)
            {
                models.clear();
                models.push_back(m);
                distance = d;
            }
        }
        return models;
    }
 
    CAircraftModelList CAircraftModelList::findClosestFuselageColorDistance(const CRgbColor &color) const
    {
        return this->findClosestColorDistance(color, color);
    }
 
    CAircraftModelList CAircraftModelList::findColorLiveries() const
    {
        return this->findBy([=](const CAircraftModel &model) { return model.getLivery().isColorLivery(); });
    }
 
    CAircraftModelList CAircraftModelList::findByMilitaryFlag(bool military) const
    {
        return this->findBy([=](const CAircraftModel &model) { return (model.isMilitary() == military); });
    }
 
    CAircraftModelList CAircraftModelList::findByVtolFlag(bool vtol) const
    {
        return this->findBy([=](const CAircraftModel &model) { return (model.isVtol() == vtol); });
    }
 
    CAircraftModelList CAircraftModelList::findByModelMode(CAircraftModel::ModelMode mode) const
    {
        return this->findBy([=](const CAircraftModel &model) { return (model.getModelMode() == mode); });
    }
 
    CAircraftModelList CAircraftModelList::findByCategoryFirstLevel(int firstLevel) const
    {
        if (firstLevel < 0) { return {}; }
        return this->findBy([=](const CAircraftModel &model) {
            return (model.hasCategory() && model.getAircraftIcaoCode().getCategory().getFirstLevel() == firstLevel);
        });
    }
 
    CAircraftModelList CAircraftModelList::findByCategory(const CAircraftCategory &category) const
    {
        if (category.isNull()) { return {}; }
        return this->findBy([=](const CAircraftModel &model) {
            return (model.hasCategory() && model.getAircraftIcaoCode().getCategory() == category);
        });
    }
 
    CAircraftModelList CAircraftModelList::findByCategories(const CAircraftCategoryList &categories) const
    {
        if (categories.isEmpty()) { return {}; }
        return this->findBy([=](const CAircraftModel &model) {
            return (model.hasCategory() && categories.contains(model.getAircraftIcaoCode().getCategory()));
        });
    }
 
    CAircraftModelList CAircraftModelList::findFsFamilyModels() const
    {
        return this->findBy(
            [](const CAircraftModel &model) { return model.getSimulator().isMicrosoftOrPrepare3DSimulator(); });
    }
 
    CAircraftModelList CAircraftModelList::findNonFsFamilyModels() const
    {
        return this->findBy(
            [](const CAircraftModel &model) { return !model.getSimulator().isMicrosoftOrPrepare3DSimulator(); });
    }
 
    CAircraftModelList CAircraftModelList::findWithValidDbKey() const
    {
        return this->findBy([](const CAircraftModel &model) { return model.hasValidDbKey(); });
    }
 
    CAircraftModelList CAircraftModelList::findWithoutValidDbKey() const
    {
        return this->findBy([](const CAircraftModel &model) { return !model.hasValidDbKey(); });
    }
 
    CAircraftModelList CAircraftModelList::findWithoutValidDbKey(int maxElements) const
    {
        CAircraftModelList ml = this->findWithoutValidDbKey();
        ml.truncate(maxElements);
        return ml;
    }
 
    CAircraftModelList CAircraftModelList::findNonDbModelsForAirline(const QString &airline) const
    {
        const CAircraftModelList noDb = this->findWithoutValidDbKey();
        return noDb.findBy(
            [&](const CAircraftModel &model) { return model.getAirlineIcaoCode().matchesDesignator(airline); });
    }
 
    CAircraftModelList CAircraftModelList::findNonDbModelsForAircraft(const QString &airline) const
    {
        const CAircraftModelList noDb = this->findWithoutValidDbKey();
        return noDb.findBy(
            [&](const CAircraftModel &model) { return model.getAircraftIcaoCode().matchesDesignator(airline); });
    }
 
    CAircraftModelList CAircraftModelList::findNonDbModelsForModelString(const QString &modelString) const
    {
        const CAircraftModelList noDb = this->findWithoutValidDbKey();
        return noDb.findBy(
            [&](const CAircraftModel &model) { return model.matchesModelString(modelString, Qt::CaseInsensitive); });
    }
 
    CAircraftModelList CAircraftModelList::findAllIncludedModels() const
    {
        return this->findBy(
            [](const CAircraftModel &model) { return model.getModelMode() == CAircraftModel::Include; });
    }
 
    CAircraftModelList CAircraftModelList::findAllIncludedModels(int maxElements) const
    {
        CAircraftModelList ml = this->findAllIncludedModels();
        ml.truncate(maxElements);
        return ml;
    }
 
    CAircraftModelList CAircraftModelList::findAllExcludedModels() const
    {
        return this->findBy(
            [](const CAircraftModel &model) { return model.getModelMode() == CAircraftModel::Exclude; });
    }
 
    CAircraftModelList CAircraftModelList::findAllExcludedModels(int maxElements) const
    {
        CAircraftModelList ml = this->findAllExcludedModels();
        ml.truncate(maxElements);
        return ml;
    }
 
    CAircraftModelList CAircraftModelList::findDuplicateModelStrings() const
    {
        const QMap<QString, int> modelStrings = this->countPerModelString();
        CAircraftModelList duplicates;
        for (const auto [string, count] : makePairsRange(modelStrings))
        {
            if (count > 1) { duplicates.push_back(this->findByModelString(string, Qt::CaseInsensitive)); }
        }
        return duplicates;
    }
 
    QMap<QString, int> CAircraftModelList::countPerModelString() const
    {
        QMap<QString, int> modelStrings;
        for (const CAircraftModel &model : *this)
        {
            if (modelStrings.contains(model.getModelString())) { modelStrings[model.getModelModeAsString()]++; }
            else { modelStrings[model.getModelModeAsString()] = 1; }
        }
        return modelStrings;
    }
 
    QMap<CDistributor, int> CAircraftModelList::countPerDistributor() const
    {
        QMap<CDistributor, int> distributors;
        for (const CAircraftModel &model : *this)
        {
            if (!model.hasDistributor()) { continue; }
            if (distributors.contains(model.getDistributor())) { distributors[model.getDistributor()]++; }
            else { distributors[model.getDistributor()] = 1; }
        }
        return distributors;
    }
 
    QMap<CAircraftIcaoCode, int> CAircraftModelList::countPerAircraftIcao() const
    {
        QMap<CAircraftIcaoCode, int> icaos;
        for (const CAircraftModel &model : *this)
        {
            if (!model.hasAircraftDesignator()) { continue; }
            if (icaos.contains(model.getAircraftIcaoCode())) { icaos[model.getAircraftIcaoCode()]++; }
            else { icaos[model.getAircraftIcaoCode()] = 1; }
        }
        return icaos;
    }
 
    QMap<CAirlineIcaoCode, int> CAircraftModelList::countPerAirlineIcao() const
    {
        QMap<CAirlineIcaoCode, int> icaos;
        for (const CAircraftModel &model : *this)
        {
            if (!model.hasAirlineDesignator()) { continue; }
            if (icaos.contains(model.getAirlineIcaoCode())) { icaos[model.getAirlineIcaoCode()]++; }
            else { icaos[model.getAirlineIcaoCode()] = 1; }
        }
        return icaos;
    }
 
    CAirlineIcaoCode CAircraftModelList::getAirlineWithMaxCount() const
    {
        const QMap<CAirlineIcaoCode, int> ac = this->countPerAirlineIcao();
        if (ac.isEmpty()) { return {}; }
        if (ac.size() == 1) { return ac.firstKey(); }
        const QList<int> values = ac.values();
        const int max = *std::max_element(values.begin(), values.end());
        return ac.key(max);
    }
 
    CAircraftModelList CAircraftModelList::findModelsWithoutExistingFile() const
    {
        return this->findBy([](const CAircraftModel &model) { return !model.hasExistingCorrespondingFile(); });
    }
 
    CAircraftModelList CAircraftModelList::findModelsWithExistingFile() const
    {
        return this->findBy([](const CAircraftModel &model) { return model.hasExistingCorrespondingFile(); });
    }
 
    QString CAircraftModelList::designatorToFamily(const CAircraftIcaoCode &aircraftIcaoCode) const
    {
        if (aircraftIcaoCode.hasFamily()) { return aircraftIcaoCode.getFamily(); }
        for (const CAircraftModel &model : (*this))
        {
            const CAircraftIcaoCode icao(model.getAircraftIcaoCode());
            if (!icao.hasFamily()) continue;
            if (icao.matchesDesignator(aircraftIcaoCode.getDesignator())) { return icao.getFamily(); }
        }
        return {};
    }
 
    CAircraftModelList CAircraftModelList::matchesSimulator(const CSimulatorInfo &simulator) const
    {
        return this->findBy([&](const CAircraftModel &model) { return model.matchesSimulator(simulator); });
    }
 
    bool CAircraftModelList::containsMatchingSimulator(const CSimulatorInfo &simulators) const
    {
        return this->containsBy([&](const CAircraftModel &model) { return model.matchesSimulator(simulators); });
    }
 
    bool CAircraftModelList::containsNotMatchingSimulator(const CSimulatorInfo &simulators) const
    {
        return this->containsBy([&](const CAircraftModel &model) { return !model.matchesSimulator(simulators); });
    }
 
    bool CAircraftModelList::containsMilitary() const
    {
        return this->containsBy([&](const CAircraftModel &model) { return model.isMilitary(); });
    }
 
    bool CAircraftModelList::containsCivilian() const
    {
        return this->containsBy([&](const CAircraftModel &model) { return model.isCivilian(); });
    }
 
    bool CAircraftModelList::containsCivilianAndMilitary() const
    {
        return this->containsMilitary() && this->containsCivilian();
    }
 
    bool CAircraftModelList::containsVtol() const
    {
        return this->containsBy([&](const CAircraftModel &model) { return model.isVtol(); });
    }
 
    bool CAircraftModelList::containsCategory() const
    {
        return this->containsBy([&](const CAircraftModel &model) { return model.hasCategory(); });
    }
 
    bool CAircraftModelList::containsCategory(int firstLevel) const
    {
        if (firstLevel < 0) { return false; }
        return this->containsBy([&](const CAircraftModel &model) {
            return model.hasCategory() && model.getAircraftIcaoCode().getCategory().getFirstLevel() == firstLevel;
        });
    }
 
    CAircraftModelList CAircraftModelList::findByDistributors(const CDistributorList &distributors) const
    {
        if (distributors.isEmpty()) { return {}; }
        return this->findBy([&](const CAircraftModel &model) { return model.matchesAnyDbDistributor(distributors); });
    }
 
    int CAircraftModelList::setSimulatorInfo(const CSimulatorInfo &info)
    {
        int c = 0;
        const CSimulatorInfo::Simulator s = info.getSimulator();
        for (CAircraftModel &model : (*this))
        {
            if (model.getSimulator().getSimulator() == s) { continue; }
            model.setSimulator(info);
            c++;
        }
        return c;
    }
 
    CSimulatorInfo CAircraftModelList::simulatorsSupported() const
    {
        CSimulatorInfo::Simulator s = CSimulatorInfo::None;
        for (const CAircraftModel &model : (*this))
        {
            s |= model.getSimulator().getSimulator();
            if (s == CSimulatorInfo::All) { break; }
        }
        return { s };
    }
 
    namespace private_ns
    {
        bool isLikelyImpl(double count, double total)
        {
            if (total < 1) { return false; }
            const double fsRatio = count / total;
            return fsRatio > 0.95;
        }
    } // namespace private_ns
 
    bool CAircraftModelList::isLikelyFsFamilyModelList() const
    {
        if (this->isEmpty()) { return false; } // avoid DIV 0
        return private_ns::isLikelyImpl(this->countPerSimulator().getCountForFsFamilySimulators(), this->size());
    }
 
    bool CAircraftModelList::isLikelyFsxFamilyModelList() const
    {
        if (this->isEmpty()) { return false; } // avoid DIV 0
        return private_ns::isLikelyImpl(this->countPerSimulator().getCountForFsxFamilySimulators(), this->size());
    }
 
    bool CAircraftModelList::isLikelyXPlaneModelList() const
    {
        if (this->isEmpty()) { return false; } // avoid DIV 0
        return private_ns::isLikelyImpl(this->countPerSimulator().getCount(CSimulatorInfo::xplane()), this->size());
    }
 
    int CAircraftModelList::setModelMode(CAircraftModel::ModelMode mode)
    {
        int c = 0;
        for (CAircraftModel &model : (*this))
        {
            if (model.getModelMode() == mode) { continue; }
            model.setModelMode(mode);
            c++;
        }
        return c;
    }
 
    int CAircraftModelList::setModelType(CAircraftModel::ModelType type)
    {
        int c = 0;
        for (CAircraftModel &model : (*this))
        {
            if (model.getModelType() == type) { continue; }
            model.setModelType(type);
            c++;
        }
        return c;
    }
 
    int CAircraftModelList::setCG(const CLength &cg)
    {
        int c = 0;
        for (CAircraftModel &model : (*this))
        {
            if (model.getCG() == cg) { continue; }
            model.setCG(cg);
            c++;
        }
        return c;
    }
 
    int CAircraftModelList::keepModelsWithString(const QStringList &modelStrings, Qt::CaseSensitivity sensitivity)
    {
        const int cs = this->size();
        (*this) = (findByModelStrings(modelStrings, sensitivity));
        const int d = cs - this->size();
        return d;
    }
 
    bool CAircraftModelList::removeModelWithString(const QString &modelString, Qt::CaseSensitivity sensitivity)
    {
        if (modelString.isEmpty()) { return false; }
        if (this->isEmpty()) { return false; }
        const int r = this->removeIf(
            [&](const CAircraftModel &model) { return model.matchesModelString(modelString, sensitivity); });
        return r > 0;
    }
 
    int CAircraftModelList::removeModelsWithString(const CAircraftModelList &models, Qt::CaseSensitivity sensitivity)
    {
        if (models.isEmpty()) { return 0; }
        return this->removeModelsWithString(models.getModelStringList(false), sensitivity);
    }
 
    int CAircraftModelList::removeModelsWithString(const QStringList &modelStrings, Qt::CaseSensitivity sensitivity)
    {
        if (modelStrings.isEmpty()) { return 0; }
        const int cs = this->size();
        (*this) = (this->findByNotInModelStrings(modelStrings, sensitivity));
        const int d = cs - this->size();
        return d;
    }
 
    int CAircraftModelList::removeIfNotMatchingSimulator(const CSimulatorInfo &needToMatch)
    {
        if (this->isEmpty()) { return 0; }
        const int oldSize = this->size();
        CAircraftModelList models;
        for (const CAircraftModel &model : *this)
        {
            if (model.matchesSimulator(needToMatch)) { models.push_back(model); }
        }
        const int diff = models.size() - oldSize;
        if (diff > 0) { *this = models; }
        return diff;
    }
 
    int CAircraftModelList::removeAllWithoutModelString()
    {
        if (this->isEmpty()) { return 0; }
        const int s = this->size();
        CAircraftModelList withModelStr;
        for (const CAircraftModel &model : *this)
        {
            if (!model.hasModelString()) { continue; }
            withModelStr.push_back(model);
        }
        const int diff = s - withModelStr.size();
        if (diff < 1) { return 0; }
        *this = withModelStr;
        return diff;
    }
 
    int CAircraftModelList::removeIfExcluded()
    {
        if (this->isEmpty()) { return 0; }
        const int s = this->size();
        CAircraftModelList onlyIncluded;
        for (const CAircraftModel &model : *this)
        {
            if (model.getModelMode() == CAircraftModel::Exclude) { continue; }
            onlyIncluded.push_back(model);
        }
        const int diff = s - onlyIncluded.size();
        if (diff < 1) { return 0; }
        *this = onlyIncluded;
        return diff;
    }
 
    int CAircraftModelList::removeXPlaneFlyablePlanes() { return this->removeIfExcluded(); }
 
    int CAircraftModelList::removeByDistributor(const CDistributor &distributor)
    {
        return this->removeIf(&CAircraftModel::getDistributor, distributor);
    }
 
    int CAircraftModelList::removeByAircraftAndLivery(const CAircraftIcaoCode &aircraftIcao, const CLivery &livery)
    {
        return this->removeIf(&CAircraftModel::getAircraftIcaoCode, aircraftIcao, &CAircraftModel::getLivery, livery);
    }
 
    int CAircraftModelList::removeByAircraftAndAirline(const CAircraftIcaoCode &aircraftIcao,
                                                       const CAirlineIcaoCode &airline)
    {
        return this->removeIf(&CAircraftModel::getAircraftIcaoCode, aircraftIcao, &CAircraftModel::getAirlineIcaoCode,
                              airline);
    }
 
    int CAircraftModelList::removeIfNotFsFamily()
    {
        if (this->isEmpty()) { return 0; }
        CAircraftModelList fsOnly = this->findFsFamilyModels();
        if (fsOnly.size() == this->size()) { return 0; }
        const int delta = this->size() - fsOnly.size();
        *this = fsOnly;
        return delta;
    }
 
    CAircraftModelList CAircraftModelList::removeIfFileButNotInSet(const QString &fileName,
                                                                   const QSet<QString> &modelStrings)
    {
        CAircraftModelList removed;
        for (const CAircraftModel &model : *this)
        {
            if (!model.matchesFileName(fileName)) { continue; }
            if (modelStrings.contains(model.getModelString())) { continue; }
            removed.push_back(model);
        }
 
        this->removeIfIn(removed);
        return removed;
    }
 
    bool CAircraftModelList::replaceOrAddModelWithString(const CAircraftModel &addOrReplaceModel,
                                                         Qt::CaseSensitivity sensitivity)
    {
        bool r = false;
        if (!this->isEmpty()) { r = this->removeModelWithString(addOrReplaceModel.getModelString(), sensitivity); }
        this->push_back(addOrReplaceModel);
        return r;
    }
 
    int CAircraftModelList::replaceOrAddModelsWithString(const CAircraftModelList &addOrReplaceList,
                                                         Qt::CaseSensitivity sensitivity)
    {
        if (addOrReplaceList.isEmpty()) { return 0; }
        if (this->isEmpty())
        {
            *this = addOrReplaceList;
            return addOrReplaceList.size();
        }
        CAircraftModelList newModels(*this);
        const QStringList keys(addOrReplaceList.getModelStringList(false));
        newModels.removeModelsWithString(keys, sensitivity);
        int removed = newModels.size(); // size after removing
        newModels.push_back(addOrReplaceList);
        *this = newModels;
        return this->size() - removed;
    }
 
    CAircraftModelList CAircraftModelList::findModelsStartingWith(const QString &modelString,
                                                                  Qt::CaseSensitivity sensitivity) const
    {
        return this->findBy(
            [&](const CAircraftModel &model) { return model.getModelString().startsWith(modelString, sensitivity); });
    }
 
    CAircraftModelList CAircraftModelList::findByModelStrings(const QStringList &modelStrings,
                                                              Qt::CaseSensitivity sensitivity) const
    {
        return this->findBy(
            [&](const CAircraftModel &model) { return modelStrings.contains(model.getModelString(), sensitivity); });
    }
 
    CAircraftModelList CAircraftModelList::findByNotInModelStrings(const QStringList &modelStrings,
                                                                   Qt::CaseSensitivity sensitivity) const
    {
        return this->findBy([&](const CAircraftModel &model) {
            const bool c = modelStrings.contains(model.getModelString(), sensitivity);
            return !c;
        });
    }
 
    QStringList CAircraftModelList::getModelStringList(bool sort) const
    {
        QStringList ms;
        for (const CAircraftModel &model : *this)
        {
            if (!model.hasModelString()) { continue; }
            ms.append(model.getModelString());
        }
        if (sort) { ms.sort(Qt::CaseInsensitive); }
        return ms;
    }
 
    QSet<QString> CAircraftModelList::getModelStringSet() const
    {
        CSetBuilder<QString> ms;
        for (const CAircraftModel &model : *this)
        {
            if (!model.hasModelString()) { continue; }
            ms.insert(model.getModelString());
        }
        return ms;
    }
 
    CCountPerSimulator CAircraftModelList::countPerSimulator() const
    {
        CCountPerSimulator count;
        for (const CAircraftModel &model : *this) { count.increaseSimulatorCounts(model.getSimulator()); }
        return count;
    }
 
    CSimulatorInfo CAircraftModelList::simulatorsWithMaxEntries() const
    {
        if (this->isEmpty()) { return {}; } // not known
        const CCountPerSimulator counts(this->countPerSimulator());
        const int simulatorsRepresented = counts.simulatorsRepresented();
        if (simulatorsRepresented < 1) { return {}; }
        const QMultiMap<int, CSimulatorInfo> cps(counts.countPerSimulator());
        CSimulatorInfo maxSim = cps.last();
        const int count = cps.lastKey(); // how many elements
        const QList<CSimulatorInfo> infoWithMaxValues = cps.values(count); // all with the same counts
        for (const CSimulatorInfo &info : infoWithMaxValues) { maxSim.addSimulator(info); }
        return maxSim;
    }
 
    int CAircraftModelList::countModelsWithColorLivery() const
    {
        int count = 0;
        for (const CAircraftModel &model : *this)
        {
            if (model.getLivery().isColorLivery()) { count++; }
        }
        return count;
    }
 
    int CAircraftModelList::countModelsWithAirlineLivery() const
    {
        int count = 0;
        for (const CAircraftModel &model : *this)
        {
            if (model.getLivery().isAirlineLivery()) { count++; }
        }
        return count;
    }
 
    int CAircraftModelList::countVtolAircraft() const
    {
        int count = 0;
        for (const CAircraftModel &model : *this)
        {
            if (model.isVtol()) { count++; }
        }
        return count;
    }
 
    int CAircraftModelList::countByMode(CAircraftModel::ModelMode mode) const
    {
        int count = 0;
        for (const CAircraftModel &model : *this)
        {
            if (model.matchesMode(mode)) { count++; }
        }
        return count;
    }
 
    int CAircraftModelList::countMilitaryAircraft() const
    {
        int count = 0;
        for (const CAircraftModel &model : *this)
        {
            if (model.isMilitary()) { count++; }
        }
        return count;
    }
 
    int CAircraftModelList::countCivilianAircraft() const
    {
        int count = 0;
        for (const CAircraftModel &model : (*this))
        {
            if (model.isCivilian()) { count++; }
        }
        return count;
    }
 
    int CAircraftModelList::countDifferentAirlines() const { return this->getAirlineVDesignators().size(); }
 
    int CAircraftModelList::countCombinedTypes() const { return this->getCombinedTypes().size(); }
 
    int CAircraftModelList::countAliases() const
    {
        int count = 0;
        for (const CAircraftModel &model : (*this))
        {
            if (model.hasModelStringAlias()) { count++; }
        }
        return count;
    }
 
    void CAircraftModelList::sortByFileName()
    {
        if (CFileUtils::isFileNameCaseSensitive()) { this->sortBy(&CAircraftModel::getFileName); }
        else { this->sortBy(&CAircraftModel::getFileNameLowerCase); }
    }
 
    void CAircraftModelList::updateDistributor(const CDistributor &distributor)
    {
        for (CAircraftModel &model : *this) { model.setDistributor(distributor); }
    }
 
    CDistributorList CAircraftModelList::getDistributors(bool onlyDbDistributors) const
    {
        if (this->isEmpty()) { return {}; }
        CDistributorList distributors;
        for (const CAircraftModel &model : *this)
        {
            const CDistributor d(model.getDistributor());
            if (onlyDbDistributors && !d.hasValidDbKey()) { continue; }
            if (distributors.contains(d)) { continue; }
            distributors.push_back(d);
        }
        return distributors;
    }
 
    CAircraftIcaoCodeList CAircraftModelList::getAircraftIcaoCodesFromDb() const
    {
        if (this->isEmpty()) { return {}; }
        QSet<int> keys;
        CAircraftIcaoCodeList icaos;
        for (const CAircraftModel &model : *this)
        {
            const CAircraftIcaoCode icao = model.getAircraftIcaoCode();
            if (!icao.hasValidDbKey()) { continue; }
 
            const int key = icao.getDbKey();
            if (keys.contains(key)) { continue; }
            icaos.push_back(icao);
            keys.insert(key);
        }
        return icaos;
    }
 
    QSet<QString> CAircraftModelList::getAircraftDesignators() const
    {
        CSetBuilder<QString> designators;
        for (const CAircraftModel &model : *this)
        {
            if (!model.hasAircraftDesignator()) { continue; }
            designators.insert(model.getAircraftIcaoCodeDesignator());
        }
        return designators;
    }
 
    QSet<QString> CAircraftModelList::getAircraftDesignatorsForAirline(const CAirlineIcaoCode &airlineCode) const
    {
        CSetBuilder<QString> designators;
        if (!airlineCode.hasValidDesignator()) { return {}; }
        for (const CAircraftModel &model : *this)
        {
            if (model.getAirlineIcaoCode() != airlineCode) { continue; }
            designators.insert(model.getAircraftIcaoCodeDesignator());
        }
        return designators;
    }
 
    CAircraftIcaoCodeList CAircraftModelList::getAicraftIcaoCodesForAirline(const CAirlineIcaoCode &airlineCode) const
    {
        CAircraftIcaoCodeList icaos;
        if (!airlineCode.hasValidDesignator()) { return icaos; }
        for (const CAircraftModel &model : *this)
        {
            if (model.getAirlineIcaoCode() != airlineCode) { continue; }
            icaos.push_back(model.getAircraftIcaoCode());
        }
        return icaos;
    }
 
    CAirlineIcaoCodeList CAircraftModelList::getAirlineIcaoCodesFromDb() const
    {
        if (this->isEmpty()) { return {}; }
        QSet<int> keys;
        CAirlineIcaoCodeList icaos;
        for (const CAircraftModel &model : *this)
        {
            const CAirlineIcaoCode icao = model.getAirlineIcaoCode();
            if (!icao.hasValidDbKey()) { continue; }
 
            const int key = icao.getDbKey();
            if (keys.contains(key)) { continue; }
            icaos.push_back(icao);
            keys.insert(key);
        }
        return icaos;
    }
 
    QSet<QString> CAircraftModelList::getAirlineDesignators() const
    {
        CSetBuilder<QString> designators;
        for (const CAircraftModel &model : *this)
        {
            if (!model.hasAirlineDesignator()) { continue; }
            designators.insert(model.getAirlineIcaoCodeDesignator());
        }
        return designators;
    }
 
    QSet<QString> CAircraftModelList::getAirlineVDesignators() const
    {
        CSetBuilder<QString> designators;
        for (const CAircraftModel &model : *this)
        {
            if (!model.hasAirlineDesignator()) { continue; }
            designators.insert(model.getAirlineIcaoCodeVDesignator());
        }
        return designators;
    }
 
    CAirlineIcaoCodeList CAircraftModelList::getAirlineIcaoCodesForGroup(int groupId) const
    {
        if (groupId < 0) { return {}; }
        CAirlineIcaoCodeList icaos;
        for (const CAircraftModel &model : *this)
        {
            if (model.getAirlineIcaoCode().getGroupId() == groupId) { icaos.push_back(model.getAirlineIcaoCode()); }
        }
        return icaos;
    }
 
    QSet<QString> CAircraftModelList::getAirlineDesignatorsForGroup(int groupId) const
    {
        return this->getAirlineIcaoCodesForGroup(groupId).allDesignators();
    }
 
    QSet<QString> CAircraftModelList::getAirlineVDesignatorsForGroup(int groupId) const
    {
        return this->getAirlineIcaoCodesForGroup(groupId).allVDesignators();
    }
 
    QSet<QString> CAircraftModelList::getCombinedTypes() const
    {
        CSetBuilder<QString> combinedCodes;
        for (const CAircraftModel &model : *this)
        {
            const QString ct = model.getAircraftIcaoCode().getCombinedType();
            if (ct.isEmpty()) { continue; }
            combinedCodes.insert(ct);
        }
        return combinedCodes;
    }
 
    QSet<QString> CAircraftModelList::getAllFileNames() const
    {
        const bool cs = CFileUtils::isFileNameCaseSensitive();
        CSetBuilder<QString> files;
        for (const CAircraftModel &model : *this)
        {
            if (!model.hasFileName()) { continue; }
            files.insert(cs ? model.getFileName() : model.getFileNameLowerCase());
        }
        return files;
    }
 
    QSet<QString> CAircraftModelList::getAllUNCFileNames() const
    {
        const bool cs = CFileUtils::isFileNameCaseSensitive();
        CSetBuilder<QString> files;
        for (const CAircraftModel &model : *this)
        {
            if (!model.hasFileName()) { continue; }
            const QString fn = (cs ? model.getFileName() : model.getFileNameLowerCase());
            if (CFileUtils::isWindowsUncPath(fn)) { files.insert(fn); }
        }
        return files;
    }
 
    QString CAircraftModelList::getCombinedTypesAsString(const QString &separator) const
    {
        if (this->isEmpty()) { return {}; }
        return joinStringSet(this->getCombinedTypes(), separator);
    }
 
    QSet<QString> CAircraftModelList::getAicraftAndAirlineDesignators(bool withDbId) const
    {
        CSetBuilder<QString> str;
        for (const CAircraftModel &model : *this)
        {
            const QString s =
                (model.hasAircraftDesignator() ? (withDbId ? model.getAircraftIcaoCode().getDesignatorDbKey() :
                                                             model.getAircraftIcaoCodeDesignator()) :
                                                 "no aircraft") %
                u"/" %
                (model.hasAircraftDesignator() ? (withDbId ? model.getAirlineIcaoCode().getDesignatorDbKey() :
                                                             model.getAirlineIcaoCodeVDesignator()) :
                                                 "no airline");
            str.insert(s);
        }
        return str;
    }
 
    QString CAircraftModelList::getAicraftAndAirlineDesignatorsAsString(bool withDbId, const QString &separator) const
    {
        if (this->isEmpty()) { return {}; }
        return joinStringSet(this->getAicraftAndAirlineDesignators(withDbId), separator);
    }
 
    void CAircraftModelList::updateAircraftIcao(const CAircraftIcaoCode &icao)
    {
        for (CAircraftModel &model : *this) { model.setAircraftIcaoCode(icao); }
    }
 
    void CAircraftModelList::updateLivery(const CLivery &livery)
    {
        for (CAircraftModel &model : *this) { model.setLivery(livery); }
    }
 
    int CAircraftModelList::updateDistributorOrder(const CDistributorList &distributors)
    {
        if (distributors.isEmpty()) { return 0; }
        int found = 0;
        for (CAircraftModel &model : *this)
        {
            if (model.setDistributorOrder(distributors)) { found++; }
        }
        return found;
    }
 
    void CAircraftModelList::normalizeFileNamesForDb()
    {
        for (CAircraftModel &model : *this) { model.normalizeFileNameForDb(); }
    }
 
    ScoredModels CAircraftModelList::scoreFull(const CAircraftModel &remoteModel, bool preferColorLiveries,
                                               bool ignoreZeroScores, CStatusMessageList *log) const
    {
        ScoredModels scoreMap;
 
        // normally prefer colors if there is no airline
        CCallsign::addLogDetailsToList(
            log, remoteModel.getCallsign(),
            QStringLiteral("Prefer color liveries: '%1', airline: '%2', ignore zero scores: '%3'")
                .arg(boolToYesNo(preferColorLiveries), remoteModel.getAirlineIcaoCodeDesignator(),
                     boolToYesNo(ignoreZeroScores)));
        CCallsign::addLogDetailsToList(log, remoteModel.getCallsign(),
                                       QStringLiteral("--- Start scoring in list with %1 models").arg(this->size()));
        CCallsign::addLogDetailsToList(log, remoteModel.getCallsign(), this->coverageSummaryForModel(remoteModel));
 
        int c = 1;
        for (const CAircraftModel &model : *this)
        {
            CStatusMessageList subMsgs;
            const int score = model.calculateScore(remoteModel, preferColorLiveries, log ? &subMsgs : nullptr);
            if (ignoreZeroScores && score < 1) { continue; }
 
            CCallsign::addLogDetailsToList(
                log, remoteModel.getCallsign(),
                QStringLiteral("--- Calculating #%1 '%2'---").arg(c).arg(model.getModelStringAndDbKey()));
            if (log) { log->push_back(subMsgs); }
            CCallsign::addLogDetailsToList(log, remoteModel.getCallsign(),
                                           QStringLiteral("--- End calculating #%1 ---").arg(c));
            c++;
            scoreMap.insert(score, model);
        }
        CCallsign::addLogDetailsToList(log, remoteModel.getCallsign(), QStringLiteral("--- End scoring ---"));
        return scoreMap;
    }
 
    QStringList CAircraftModelList::toCompleterStrings(bool sorted, const CSimulatorInfo &simulator) const
    {
        QStringList c;
        for (const CAircraftModel &model : *this)
        {
            if (model.getSimulator().matchesAny(simulator)) { c.append(model.getModelString()); }
        }
        if (sorted) { c.sort(); }
        return c;
    }
 
    CStatusMessageList CAircraftModelList::validateForPublishing() const
    {
        CAircraftModelList invalidModels;
        CAircraftModelList validModels;
        return this->validateForPublishing(validModels, invalidModels);
    }
 
    CStatusMessageList CAircraftModelList::validateForPublishing(CAircraftModelList &validModels,
                                                                 CAircraftModelList &invalidModels) const
    {
        if (this->isEmpty()) { return {}; }
        CStatusMessageList msgs;
        for (const CAircraftModel &model : *this)
        {
            const CStatusMessageList msgsModel(model.validate(false));
            const CStatusMessage msgModel(msgsModel.toSingleMessage());
 
            QStringList subMsgs;
            if (!model.getDistributor().hasValidDbKey()) { subMsgs << "No distributor from DB"; }
            if (!model.getAircraftIcaoCode().hasValidDbKey()) { subMsgs << "No aircraft ICAO from DB"; }
            if (!model.getLivery().hasValidDbKey()) { subMsgs << "No livery from DB"; }
            if (model.getLivery().isAirlineLivery())
            {
                // for color codes we do not need to check
                if (!model.getLivery().getAirlineIcaoCode().hasValidDbKey()) { subMsgs << "No airline ICAO from DB"; }
            }
 
            const CStatusMessage msgDb(CStatusMessage::SeverityError, subMsgs.join(", "));
            CStatusMessage singleMsg(CStatusMessageList({ msgModel, msgDb }).toSingleMessage());
            if (!singleMsg.isWarningOrAbove())
            {
                CAircraftModelList::addAsValidOrInvalidModel(model, true, validModels, invalidModels);
                continue;
            }
            if (model.hasModelString()) { singleMsg.prependMessage(model.getModelString() % u": "); }
            msgs.push_back(singleMsg);
            CAircraftModelList::addAsValidOrInvalidModel(model, false, validModels, invalidModels);
        }
        return msgs;
    }
 
    CStatusMessageList CAircraftModelList::validateDistributors(const CDistributorList &distributors,
                                                                CAircraftModelList &validModels,
                                                                CAircraftModelList &invalidModels) const
    {
        CStatusMessageList msgs;
        CDistributorList distributorsFromDb(distributors);
        distributorsFromDb.removeIfNotLoadedFromDb();
 
        // Any DB distributors?
        if (distributorsFromDb.isEmpty())
        {
            const CStatusMessage msg = CStatusMessage(this).validationError(u"No DB distributors for validation");
            msgs.push_back(msg);
            CAircraftModelList::addAsValidOrInvalidModels(*this, false, validModels, invalidModels);
            return msgs;
        }
 
        for (const CAircraftModel &model : *this)
        {
            const bool valid = (model.hasDbDistributor() || model.matchesAnyDbDistributor(distributorsFromDb));
            CAircraftModelList::addAsValidOrInvalidModel(model, valid, validModels, invalidModels);
            if (!valid)
            {
                const CStatusMessage msg =
                    CStatusMessage(this).validationError(u"No valid distributor for '%1', was '%2'")
                    << model.getModelString() << model.getDistributor().getDbKey();
                msgs.push_back(msg);
            }
        }
        return msgs;
    }
 
    CStatusMessageList CAircraftModelList::validateFiles(CAircraftModelList &validModels,
                                                         CAircraftModelList &invalidModels, bool ignoreEmptyFileNames,
                                                         int stopAtFailedFiles, std::atomic_bool &wasStopped,
                                                         const QString &simRootDirectory, bool alreadySortedByFn) const
    {
        wasStopped = false;
 
        CStatusMessageList msgs;
        QSet<QString> failedFiles;
        QSet<QString> workingFiles;
        int failedFilesCount = 0;
 
        // sorting allows to skip multiple files as once when a file fails
        CAircraftModelList sorted(*this);
        if (!alreadySortedByFn) { sorted.sortByFileName(); }
 
        // avoid hanging if UNC paths are not available
        if (CBuildConfig::isRunningOnWindowsNtPlatform())
        {
            const CStatusMessageList uncMsgs = this->validateUncFiles(sorted.getAllUNCFileNames());
            if (uncMsgs.hasErrorMessages()) { return uncMsgs; }
        }
 
        const bool caseSensitive = CFileUtils::isFileNameCaseSensitive();
        const QString simRootDir = CFileUtils::normalizeFilePathToQtStandard(
            CFileUtils::stripLeadingSlashOrDriveLetter(caseSensitive ? simRootDirectory : simRootDirectory.toLower()));
 
        for (const CAircraftModel &model : std::as_const(sorted))
        {
            if (wasStopped) { break; } // allow breaking from external
            bool ok = false;
            do {
                if (!model.hasModelString())
                {
                    msgs.push_back(CStatusMessage(this).validationError(u"No model string"));
                    break;
                }
 
                if (!model.hasFileName())
                {
                    if (ignoreEmptyFileNames) { break; }
                    msgs.push_back(CStatusMessage(this).validationError(u"'%1', no file name")
                                   << model.getModelStringAndDbKey());
                    break;
                }
 
                const QString fn(caseSensitive ? model.getFileName() : model.getFileNameLowerCase());
                if (failedFiles.contains(fn))
                {
                    msgs.push_back(CStatusMessage(this).validationError(u"'%1', known failed file '%2' skipped")
                                   << model.getModelStringAndDbKey() << model.getFileName());
                    break;
                }
 
                if (workingFiles.contains(fn) || model.hasExistingCorrespondingFile())
                {
                    if (!simRootDirectory.isEmpty() && !fn.contains(simRootDir))
                    {
                        // check if in root directory
                        msgs.push_back(
                            CStatusMessage(this).validationError(u"'%1', not in root directory '%2', '%3' skipped")
                            << model.getModelStringAndDbKey() << simRootDir << model.getFileName());
                        failedFiles.insert(fn);
                        failedFilesCount++;
                        break;
                    }
                    else
                    {
                        ok = true;
                        workingFiles.insert(fn);
                        // msgs.push_back(CStatusMessage(this).validationInfo(u"'%1', file '%2' existing") <<
                        // model.getModelStringAndDbKey() << model.getFileName());
                        break;
                    }
                }
 
                failedFiles.insert(fn);
                failedFilesCount++;
                msgs.push_back(CStatusMessage(this).validationError(u"'%1', file '%2' not existing")
                               << model.getModelStringAndDbKey() << model.getFileName());
            }
            while (false);
 
            CAircraftModelList::addAsValidOrInvalidModel(model, ok, validModels, invalidModels);
            if (stopAtFailedFiles > 0 && failedFilesCount >= stopAtFailedFiles)
            {
                wasStopped = true;
                msgs.push_back(CStatusMessage(this).validationWarning(u"Stopping after %1 failed files")
                               << failedFilesCount);
                break;
            }
        }
 
        // Summary
        if (!validModels.isEmpty())
        {
            msgs.push_back(CStatusMessage(this).validationInfo(u"File validation, valid models: %1")
                           << validModels.size());
        }
        if (!invalidModels.isEmpty())
        {
            msgs.push_back(CStatusMessage(this).validationWarning(u"File validation, invalid models: %1")
                           << invalidModels.size());
        }
 
        // done
        return msgs;
    }
 
    CStatusMessageList CAircraftModelList::validateUncFiles(const QSet<QString> &uncFiles) const
    {
        // check if UNC paths can be reached
        CStatusMessageList msgs;
        if (!CBuildConfig::isRunningOnWindowsNtPlatform()) { return msgs; }
        if (uncFiles.isEmpty()) { return msgs; }
 
        const QSet<QString> uncMachines = CFileUtils::windowsUncMachines(uncFiles);
        if (uncMachines.isEmpty())
        {
            msgs.push_back(CStatusMessage(this).validationInfo(u"Found NO UNC machines for %1 files, odd...?")
                           << uncFiles.size());
        }
        else
        {
            const QString machines = joinStringSet(uncMachines, ", ");
            msgs.push_back(CStatusMessage(this).validationInfo(u"Found %1 UNC files on machines: %2")
                           << uncFiles.size() << machines);
        }
 
        for (const QString &m : uncMachines)
        {
            const bool ping = canPing(m);
            if (!ping)
            {
                msgs.push_back(CStatusMessage(this).validationError(u"Cannot ping UNC machine(s): %1. UNC files: %2")
                               << m << uncFiles.size());
            }
        }
        return msgs;
    }
 
    QJsonObject CAircraftModelList::toMemoizedJson() const
    {
        CAircraftModel::MemoHelper::CMemoizer helper;
        QJsonArray array;
        for (const auto &it : *this) { array << it.toMemoizedJson(helper); }
        QJsonObject json;
        json.insert("containerbase", array);
        json.insert("aircraftIcaos", helper.getTable<CAircraftIcaoCode>().toJson());
        json.insert("liveries", helper.getTable<CLivery>().toJson());
        json.insert("distributors", helper.getTable<CDistributor>().toJson());
        return json;
    }
 
    void CAircraftModelList::convertFromMemoizedJson(const QJsonObject &json, bool fallbackToConvertToJson)
    {
        clear();
        QJsonValue value = json.value("containerbase");
        if (value.isUndefined()) { throw CJsonException("Missing 'containerbase'"); }
        QJsonArray array = value.toArray();
 
        CAircraftModel::MemoHelper::CUnmemoizer helper;
        const QJsonValue aircraftIcaos = json.value("aircraftIcaos");
        const QJsonValue liveries = json.value("liveries");
        const QJsonValue distributors = json.value("distributors");
 
        const bool undefAc = aircraftIcaos.isUndefined();
        const bool undefLiv = liveries.isUndefined();
        const bool undefDist = distributors.isUndefined();
        const bool undefAll = undefAc && undefDist && undefLiv;
 
        if (fallbackToConvertToJson && undefAll)
        {
            this->convertFromJson(json);
            return;
        }
        else
        {
            if (undefAc) { throw CJsonException("Missing 'aircraftIcaos'"); }
            if (undefLiv) { throw CJsonException("Missing 'liveries'"); }
            if (undefDist) { throw CJsonException("Missing 'distributors'"); }
        }
 
        // convert
        {
            CJsonScope scope("aircraftIcaos");
            Q_UNUSED(scope)
            helper.getTable<CAircraftIcaoCode>().convertFromJson(aircraftIcaos.toObject());
        }
        {
            CJsonScope scope("liveries");
            Q_UNUSED(scope)
            helper.getTable<CLivery>().convertFromJson(liveries.toObject());
        }
        {
            CJsonScope scope("distributors");
            Q_UNUSED(scope)
            helper.getTable<CDistributor>().convertFromJson(distributors.toObject());
        }
 
        int index = 0;
        for (auto &&i : array)
        {
            CJsonScope scope("containerbase", index++);
            Q_UNUSED(scope)
            CAircraftModel value;
            value.convertFromMemoizedJson(i.toObject(), helper);
            this->push_back(value);
        }
    }
 
    QJsonArray CAircraftModelList::toDatabaseJson() const
    {
        QJsonArray array;
        for (const CAircraftModel &model : *this)
        {
            CAircraftModel copy(model);
            copy.normalizeFileNameForDb(); // strip full path
            QJsonValue v(copy.toDatabaseJson());
            array.append(v);
        }
        return array;
    }
 
    QString CAircraftModelList::toDatabaseJsonString(QJsonDocument::JsonFormat format) const
    {
        return QJsonDocument(toDatabaseJson()).toJson(format);
    }
 
    QString CAircraftModelList::asHtmlSummary() const
    {
        if (this->isEmpty()) { return {}; }
        QString html;
        for (const CAircraftModel &model : *this)
        {
            html += html.isEmpty() ? model.asHtmlSummary(" ") : u"<br>" % model.asHtmlSummary(" ");
        }
        return html;
    }
 
    QString CAircraftModelList::coverageSummary(const QString &separator) const
    {
        if (this->isEmpty()) { return "no models"; } // avoid division by 0
 
        const int dbEntries = this->countWithValidDbKey();
        const double dbRatio = CMathUtils::round(static_cast<double>(100 * dbEntries) / this->size(), 1);
        return u"Entries: " % QString::number(this->size()) % u" | valid DB keys: " % QString::number(dbEntries) %
               u" (" % QString::number(dbRatio) % u"%)" % separator % u"color liveries: " %
               QString::number(this->countModelsWithColorLivery()) % u" | airline liveries: " %
               QString::number(this->countModelsWithAirlineLivery()) % separator % u"VTOL: " %
               QString::number(this->countVtolAircraft()) % u" | military: " %
               QString::number(this->countMilitaryAircraft()) % u" | civilian: " %
               QString::number(this->countCivilianAircraft()) % separator % u"Different airlines: " %
               QString::number(this->countDifferentAirlines()) % separator % u"Combined types: '" %
               this->getCombinedTypesAsString() % u'\'' % separator %
               (this->size() <= 25 ?
                    (u"Aircraft/airlines: " % this->getAicraftAndAirlineDesignatorsAsString(true) % separator) :
                    QString()) %
               u"Simulators: " % this->countPerSimulator().toQString();
    }
 
    QString CAircraftModelList::coverageSummaryForModel(const CAircraftModel &checkModel,
                                                        const QString &separator) const
    {
        const bool combinedCodeForModel =
            this->containsCombinedType(checkModel.getAircraftIcaoCode().getCombinedType());
        const bool airlineForModel =
            checkModel.hasAirlineDesignator() && this->containsAirlineLivery(checkModel.getAirlineIcaoCode());
        return coverageSummary(separator) % separator % u"Data for input model, has combined: " %
               boolToYesNo(combinedCodeForModel) %
               (checkModel.hasAirlineDesignator() ?
                    u" airline '" % checkModel.getAirlineIcaoCodeDesignator() % u"': " % boolToYesNo(airlineForModel) :
                    QString());
    }
 
    QString CAircraftModelList::htmlStatistics(bool aircraftStats, bool airlineStats) const
    {
        static const QString sep("<br>");
        const bool notOnlyDb = this->containsAnyObjectWithoutKey();
        QString stats = this->coverageSummary(sep);
        if (aircraftStats)
        {
            const CAircraftIcaoCodeList icaos = this->getAircraftIcaoCodesFromDb();
            QStringList designators(icaos.allDesignators().values());
            designators.sort();
            stats += sep % sep % u"Aircraft ICAOs from DB: " % sep % designators.join(", ");
        }
 
        if (airlineStats)
        {
            const CAirlineIcaoCodeList icaos = this->getAirlineIcaoCodesFromDb();
            const QStringList designators = icaos.toIcaoDesignatorCompleterStrings();
            stats += sep % sep % u"Airline ICAOs from DB: " % sep % designators.join(", ");
        }
 
        if (notOnlyDb)
        {
            const CAircraftModelList dbModels = this->findObjectsWithDbKey();
            stats += sep % sep % u"DB objects:<br>---------" % sep % dbModels.htmlStatistics(false, false);
        }
        return stats;
    }
 
    CStatusMessage CAircraftModelList::saveInvalidModels() const
    {
        if (this->isEmpty()) { return CStatusMessage(this).info(u"No models"); }
        const QString json = this->toJsonString();
        const bool s = CFileUtils::writeStringToFile(json, invalidModelFileAndPath());
        if (!s)
        {
            return CStatusMessage(this).error(u"Unable to save %1 entries to '%2'")
                   << this->size() << invalidModelFileAndPath();
        }
        return CStatusMessage(this).info(u"Saved %1 entries to '%2'") << this->size() << invalidModelFileAndPath();
    }
 
    CStatusMessage CAircraftModelList::loadInvalidModels()
    {
        const QString json = CFileUtils::readFileToString(invalidModelFileAndPath());
        if (json.isEmpty())
        {
            return CStatusMessage(this).error(u"Unable to read from '%1'") << invalidModelFileAndPath();
        }
        *this = CAircraftModelList::fromJson(json, true);
        return CStatusMessage(this).info(u"Loaded %1 entries from '%2'") << this->size() << invalidModelFileAndPath();
    }
 
    CAircraftModelList CAircraftModelList::fromDatabaseJsonCaching(const QJsonArray &array,
                                                                   const CAircraftIcaoCodeList &icaos,
                                                                   const CAircraftCategoryList &categories,
                                                                   const CLiveryList &liveries,
                                                                   const CDistributorList &distributors)
    {
        AircraftIcaoIdMap aircraftIcaosMap = icaos.toDbKeyValueMap();
        LiveryIdMap liveriesMap = liveries.toDbKeyValueMap();
        DistributorIdMap distributorsMap = distributors.toDbKeyValueMap();
        const AircraftCategoryIdMap categoriesMap = categories.toDbKeyValueMap();
 
        CAircraftModelList models;
        for (const QJsonValue &value : array)
        {
            models.push_back(CAircraftModel::fromDatabaseJsonCaching(value.toObject(), aircraftIcaosMap, categoriesMap,
                                                                     liveriesMap, distributorsMap));
        }
        return models;
    }
 
    const QString &CAircraftModelList::invalidModelFileAndPath()
    {
        static const QString f =
            CFileUtils::appendFilePathsAndFixUnc(CSwiftDirectories::logDirectory(), "invalidmodels.json");
        return f;
    }
 
    bool CAircraftModelList::hasInvalidModelFile()
    {
        const QFileInfo fi(invalidModelFileAndPath());
        return fi.exists();
    }
 
    void CAircraftModelList::addAsValidOrInvalidModel(const CAircraftModel &model, bool valid,
                                                      CAircraftModelList &validModels,
                                                      CAircraftModelList &invalidModels)
    {
        if (valid)
        {
            validModels.push_back(model);
            invalidModels.removeModelWithString(model.getModelString(), Qt::CaseInsensitive);
        }
        else
        {
            invalidModels.push_back(model);
            validModels.removeModelWithString(model.getModelString(), Qt::CaseInsensitive);
        }
    }
 
    void CAircraftModelList::addAsValidOrInvalidModels(const CAircraftModelList &models, bool valid,
                                                       CAircraftModelList &validModels,
                                                       CAircraftModelList &invalidModels)
    {
        for (const CAircraftModel &model : models)
        {
            CAircraftModelList::addAsValidOrInvalidModel(model, valid, validModels, invalidModels);
        }
    }
} // namespace swift::misc::simulation