File indexing completed on 2024-11-24 04:15:37

 /*
     SPDX-FileCopyrightText: 2020 Volker Krause <vkrause@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "platformmodel.h"
 #include "platformfinder_p.h"
 
 #include <QPointF>
 #include <QRegularExpression>
 
 #include <limits>
 
 using namespace KOSMIndoorMap;
 
 static constexpr auto TOP_PARENT = std::numeric_limits<quintptr>::max();
 
 PlatformModel::PlatformModel(QObject* parent) :
     QAbstractItemModel(parent)
 {
     m_matchTimer.setSingleShot(true);
     m_matchTimer.setInterval(0);
     connect(&m_matchTimer, &QTimer::timeout, this, &PlatformModel::matchPlatforms);
 
     connect(this, &PlatformModel::mapDataChanged, &m_matchTimer, qOverload<>(&QTimer::start));
     connect(this, &PlatformModel::arrivalPlatformChanged, &m_matchTimer, qOverload<>(&QTimer::start));
     connect(this, &PlatformModel::departurePlatformChanged, &m_matchTimer, qOverload<>(&QTimer::start));
 }
 
 PlatformModel::~PlatformModel() = default;
 
 MapData PlatformModel::mapData() const
 {
     return m_data;
 }
 
 void PlatformModel::setMapData(const MapData &data)
 {
     if (m_data == data) {
         return;
     }
 
     beginResetModel();
     m_platforms.clear();
     m_platformLabels.clear();
     m_sectionsLabels.clear();
     m_arrivalPlatformRow = -1;
     m_departurePlatformRow = -1;
 
     m_data = data;
     if (!m_data.isEmpty()) {
         PlatformFinder finder;
         m_platforms = finder.find(m_data);
 
         m_tagKeys.arrival = m_data.dataSet().makeTagKey("mx:arrival");
         m_tagKeys.departure = m_data.dataSet().makeTagKey("mx:departure");
         createLabels();
     }
     endResetModel();
     Q_EMIT mapDataChanged();
     Q_EMIT platformIndexChanged();
 }
 
 bool PlatformModel::isEmpty() const
 {
     return rowCount() == 0;
 }
 
 int PlatformModel::columnCount(const QModelIndex& parent) const
 {
     Q_UNUSED(parent);
     return 1;
 }
 
 int PlatformModel::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid()) {
         return parent.internalId() == TOP_PARENT ? m_platforms[parent.row()].sections().size() : 0;
     }
 
     return m_platforms.size();
 }
 
 QVariant PlatformModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return {};
     }
 
     if (index.internalId() == TOP_PARENT) {
         const auto &platform = m_platforms[index.row()];
         switch (role) {
             case Qt::DisplayRole:
                 return platform.name();
             case CoordinateRole:
                 return QPointF(platform.position().lonF(), platform.position().latF());
             case ElementRole:
                 return QVariant::fromValue(OSM::Element(m_platformLabels[index.row()]));
             case LevelRole:
                 return platform.level();
             case TransportModeRole:
                 return platform.mode();
             case LinesRole:
                 return platform.lines();
             case ArrivalPlatformRole:
                 return index.row() == m_arrivalPlatformRow;
             case DeparturePlatformRole:
                 return index.row() == m_departurePlatformRow;
         }
     } else {
         const auto &platform = m_platforms[index.internalId()];
         const auto &section = platform.sections()[index.row()];
         switch (role) {
             case Qt::DisplayRole:
                 return section.name();
             case CoordinateRole:
                 return QPointF(section.position().center().lonF(), section.position().center().latF());
             case ElementRole:
                 return QVariant::fromValue(OSM::Element(m_sectionsLabels[index.internalId()][index.row()]));
             case LevelRole:
                 return platform.level();
         }
     }
 
     return {};
 }
 
 QModelIndex PlatformModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         return createIndex(row, column, TOP_PARENT);
     }
     return createIndex(row, column, parent.row());
 }
 
 QModelIndex PlatformModel::parent(const QModelIndex &child) const
 {
     if (!child.isValid() || child.internalId() == TOP_PARENT) {
         return {};
     }
     return createIndex(child.internalId(), 0, TOP_PARENT);
 }
 
 QHash<int, QByteArray> PlatformModel::roleNames() const
 {
     auto n = QAbstractItemModel::roleNames();
     n.insert(CoordinateRole, "coordinate");
     n.insert(ElementRole, "osmElement");
     n.insert(LevelRole, "level");
     n.insert(TransportModeRole, "mode");
     n.insert(LinesRole, "lines");
     n.insert(ArrivalPlatformRole, "isArrivalPlatform");
     n.insert(DeparturePlatformRole, "isDeparturePlatform");
     return n;
 }
 
 Platform PlatformModel::arrivalPlatform() const
 {
     return m_arrivalPlatform;
 }
 
 void PlatformModel::setArrivalPlatform(const Platform &platform)
 {
     m_arrivalPlatform = platform;
     Q_EMIT arrivalPlatformChanged();
 }
 
 void PlatformModel::setArrivalPlatform(const QString &name, Platform::Mode mode)
 {
     m_arrivalPlatform.setName(name);
     m_arrivalPlatform.setMode(mode);
     Q_EMIT arrivalPlatformChanged();
 }
 
 Platform PlatformModel::departurePlatform() const
 {
     return m_departurePlatform;
 }
 
 void PlatformModel::setDeparturePlatform(const Platform &platform)
 {
     m_departurePlatform = platform;
     Q_EMIT departurePlatformChanged();
 }
 
 void PlatformModel::setDeparturePlatform(const QString &name, Platform::Mode mode)
 {
     m_departurePlatform.setName(name);
     m_departurePlatform.setMode(mode);
     Q_EMIT departurePlatformChanged();
 }
 
 int PlatformModel::arrivalPlatformRow() const
 {
     return m_arrivalPlatformRow;
 }
 
 int PlatformModel::departurePlatformRow() const
 {
     return m_departurePlatformRow;
 }
 
 void PlatformModel::matchPlatforms()
 {
     setPlatformTag(m_arrivalPlatformRow, m_tagKeys.arrival, false);
     applySectionSelection(m_arrivalPlatformRow, m_tagKeys.arrival, {});
     m_arrivalPlatformRow = matchPlatform(m_arrivalPlatform);
     setPlatformTag(m_arrivalPlatformRow, m_tagKeys.arrival, true);
     setPlatformTag(m_departurePlatformRow, m_tagKeys.departure, false);
     applySectionSelection(m_departurePlatformRow, m_tagKeys.departure, {});
     m_departurePlatformRow = matchPlatform(m_departurePlatform);
     setPlatformTag(m_departurePlatformRow, m_tagKeys.departure, true);
     Q_EMIT platformIndexChanged();
 
     if (m_arrivalPlatformRow >= 0) {
         const auto idx = index(m_arrivalPlatformRow, 0);
         Q_EMIT dataChanged(idx, idx);
         applySectionSelection(m_arrivalPlatformRow, m_tagKeys.arrival, effectiveArrivalSections());
         Q_EMIT dataChanged(index(0, 0, idx), index(rowCount(idx) - 1, 0, idx));
     }
     if (m_departurePlatformRow >= 0) {
         const auto idx = index(m_departurePlatformRow, 0);
         Q_EMIT dataChanged(idx, idx);
         applySectionSelection(m_departurePlatformRow, m_tagKeys.departure, effectiveDepartureSections());
         Q_EMIT dataChanged(index(0, 0, idx), index(rowCount(idx) - 1, 0, idx));
     }
 }
 
 static bool isPossiblySamePlatformName(const QString &name, const QString &platform)
 {
     // <platform>\w?<section(s)>
     if (name.size() > platform.size()) {
         QRegularExpression exp(QStringLiteral("(\\d+)\\s?[A-Z-]+"));
         const auto match = exp.match(name);
         return match.hasMatch() && match.captured(1) == platform;
     }
 
     return false;
 }
 
 int PlatformModel::matchPlatform(const Platform &platform) const
 {
     if (!platform.ifopt().isEmpty()) { // try IFOPT first, if we have that
         const auto it = std::find_if(m_platforms.begin(), m_platforms.end(), [platform](const auto &p) {
             return p.ifopt() == platform.ifopt();
         });
         if (it != m_platforms.end()) {
             return std::distance(m_platforms.begin(), it);
         }
     }
 
     if (platform.name().isEmpty()) {
         return -1;
     }
 
     // exact match
     int i = 0;
     for (const auto &p : m_platforms) {
         if (p.name() == platform.name() && p.mode() == platform.mode()) {
             return i;
         }
         ++i;
     }
 
     // fuzzy match
     // TODO this likely will need to handle more scenarios
     // TODO when we get section ranges here, we might want to use those as well?
     i = 0;
     for (const auto &p : m_platforms) {
         if (p.mode() == platform.mode() && isPossiblySamePlatformName(platform.name(), p.name())) {
             return i;
         }
         ++i;
     }
 
     return -1;
 }
 
 void PlatformModel::createLabels()
 {
     const auto platformTag = m_data.dataSet().makeTagKey("mx:platform");
     const auto sectionTag = m_data.dataSet().makeTagKey("mx:platform_section");
 
     m_platformLabels.reserve(m_platforms.size());
     m_sectionsLabels.resize(m_platforms.size());
     for (std::size_t i = 0; i < m_platforms.size(); ++i) {
         const auto &p = m_platforms[i];
 
         // TODO using the full edge/track path here might be better for layouting
         auto node = new OSM::Node;
         node->id = m_data.dataSet().nextInternalId();
         node->coordinate = p.position();
         OSM::setTagValue(*node, platformTag, p.name().toUtf8());
         m_platformLabels.push_back(OSM::UniqueElement(node));
 
         m_sectionsLabels[i].reserve(p.sections().size());
         for (const auto &sec : p.sections()) {
             auto node = new OSM::Node;
             node->id = m_data.dataSet().nextInternalId();
             node->coordinate = sec.position().center();
             OSM::setTagValue(*node, sectionTag, sec.name().toUtf8());
             m_sectionsLabels[i].push_back(OSM::UniqueElement(node));
         }
     }
 }
 
 void PlatformModel::setPlatformTag(int idx, OSM::TagKey key, bool enabled)
 {
     if (idx < 0) {
         return;
     }
 
     m_platformLabels[idx].setTagValue(key, enabled ? "1" : "0");
 }
 
 static QStringView stripPlatform(QStringView p)
 {
     while (!p.empty() && (p[0].isDigit() || p[0].isSpace())) {
         p = p.mid(1);
     }
     return p;
 }
 
 QStringView PlatformModel::effectiveArrivalSections() const
 {
     // TODO prefer explicit section selectors once implemented/when present
     return stripPlatform(m_arrivalPlatform.name());
 }
 
 QStringView PlatformModel::effectiveDepartureSections() const
 {
     // TODO prefer explicit section selectors once implemented/when present
     return stripPlatform(m_departurePlatform.name());
 }
 
 static std::vector<QChar> parseSectionSet(QStringView sections)
 {
     std::vector<QChar> result;
     const auto ranges = sections.split(QLatin1Char(','));
     for (const auto &r : ranges) {
         if (r.size() == 1) {
             result.push_back(r[0]);
             continue;
         }
         if (r.size() == 3 && r[1] == QLatin1Char('-') && r[0] < r[2]) {
             for (QChar c = r[0]; c <= r[2]; c = QChar(c.unicode() + 1)) {
                 result.push_back(c);
             }
             continue;
         }
         qDebug() << "failed to parse platform section expression:" << r;
     }
     return result;
 }
 
 void PlatformModel::applySectionSelection(int platformIdx, OSM::TagKey key, QStringView sections)
 {
     if (platformIdx < 0) {
         return;
     }
 
     const auto sectionSet = parseSectionSet(sections);
 
     std::size_t totalSelected = 0;
     for (std::size_t i = 0; i < m_platforms[platformIdx].sections().size(); ++i) {
         if (std::any_of(sectionSet.begin(), sectionSet.end(), [this, i, platformIdx](const QChar s) {
             return s == m_platforms[platformIdx].sections()[i].name();
         })) {
             m_sectionsLabels[platformIdx][i].setTagValue(key, "1");
             ++totalSelected;
         } else {
             m_sectionsLabels[platformIdx][i].setTagValue(key, "0");
         }
     }
 
     // if we enabled all sections, disable them again, highlighting adds no value then
     if (totalSelected == m_sectionsLabels[platformIdx].size()) {
         for (auto &s : m_sectionsLabels[platformIdx]) {
             s.setTagValue(key, "0");
         }
     }
 }
 
 #include "moc_platformmodel.cpp"