Turn things in common into separate libs.

Took 2 hours 27 minutes

libs/card/include/card/card_database/card_database.h

@@ -0,0 +1,102 @@
+/**
+ * @file card_database.h
+ * @ingroup CardDatabase
+ * @brief The CardDatabase is responsible for holding the card and set maps.
+ */
+
+#ifndef CARDDATABASE_H
+#define CARDDATABASE_H
+
+#include "card/card_database/card_database_loader.h"
+#include "card/card_set/card_set_list.h"
+#include "card_database_querier.h"
+#include "utility/card_ref.h"
+
+#include <QBasicMutex>
+#include <QDate>
+#include <QHash>
+#include <QList>
+#include <QLoggingCategory>
+#include <QStringList>
+#include <QVector>
+#include <utility>
+
+inline Q_LOGGING_CATEGORY(CardDatabaseLog, "card_database");
+
+class CardDatabase : public QObject
+{
+    Q_OBJECT
+protected:
+    /*
+     * The cards, indexed by name.
+     */
+    CardNameMap cards;
+
+    /**
+     * The cards, indexed by their simple name.
+     */
+    CardNameMap simpleNameCards;
+
+    /*
+     * The sets, indexed by short name.
+     */
+    SetNameMap sets;
+
+    // loader responsible for file discovery & parsing
+    CardDatabaseLoader *loader;
+
+    LoadStatus loadStatus;
+
+    CardDatabaseQuerier *querier;
+
+private:
+    void checkUnknownSets();
+    void refreshCachedReverseRelatedCards();
+
+    QBasicMutex *clearDatabaseMutex = new QBasicMutex(), *addCardMutex = new QBasicMutex(),
+                *removeCardMutex = new QBasicMutex();
+
+public:
+    explicit CardDatabase(QObject *parent = nullptr);
+    ~CardDatabase() override;
+
+    void removeCard(CardInfoPtr card);
+    void clear();
+
+    const CardNameMap &getCardList() const
+    {
+        return cards;
+    }
+    CardSetPtr getSet(const QString &setName);
+    CardSetList getSetList() const;
+    LoadStatus getLoadStatus() const
+    {
+        return loadStatus;
+    }
+    CardDatabaseQuerier *query() const
+    {
+        return querier;
+    }
+    void enableAllUnknownSets();
+    void markAllSetsAsKnown();
+    void notifyEnabledSetsChanged();
+
+public slots:
+    void addCard(CardInfoPtr card);
+    void addSet(CardSetPtr set);
+    void loadCardDatabases();
+    bool saveCustomTokensToFile();
+signals:
+    void cardDatabaseLoadingFinished();
+    void cardDatabaseLoadingFailed();
+    void cardDatabaseNewSetsFound(int numUnknownSets, QStringList unknownSetsNames);
+    void cardDatabaseAllNewSetsEnabled();
+    void cardDatabaseEnabledSetsChanged();
+    void cardAdded(CardInfoPtr card);
+    void cardRemoved(CardInfoPtr card);
+
+    friend class CardDatabaseLoader;
+    friend class CardDatabaseQuerier;
+};
+
+#endif

libs/card/include/card/card_database/card_database_loader.h

@@ -0,0 +1,63 @@
+/**
+ * @file card_database_loader.h
+ * @ingroup CardDatabase
+ * @brief The CardDatabaseLoader is responsible for populating the card database from files on disk.
+ */
+
+#ifndef COCKATRICE_CARD_DATABASE_LOADER_H
+#define COCKATRICE_CARD_DATABASE_LOADER_H
+
+#include <QBasicMutex>
+#include <QList>
+#include <QLoggingCategory>
+#include <QObject>
+
+inline Q_LOGGING_CATEGORY(CardDatabaseLoadingLog, "card_database.loading");
+inline Q_LOGGING_CATEGORY(CardDatabaseLoadingSuccessOrFailureLog, "card_database.loading.success_or_failure");
+
+class CardDatabase;
+class ICardDatabaseParser;
+
+enum LoadStatus
+{
+    Ok,
+    VersionTooOld,
+    Invalid,
+    NotLoaded,
+    FileError,
+    NoCards
+};
+
+class CardDatabaseLoader : public QObject
+{
+    Q_OBJECT
+public:
+    explicit CardDatabaseLoader(QObject *parent, CardDatabase *db);
+    ~CardDatabaseLoader() override;
+
+public slots:
+    LoadStatus loadCardDatabases();                   // discover & load the configured databases
+    LoadStatus loadCardDatabase(const QString &path); // load a single file
+    bool saveCustomTokensToFile();                    // write tokens to custom DB path
+
+signals:
+    void loadingStarted();
+    void loadingFinished();
+    void loadingFailed();
+    void newSetsFound(int numSets, const QStringList &setNames);
+    void allNewSetsEnabled();
+
+private:
+    LoadStatus loadFromFile(const QString &fileName); // internal helper
+    QStringList collectCustomDatabasePaths() const;
+
+    CardDatabase *database; // non-owning pointer to the container
+
+    // parsers
+    QList<ICardDatabaseParser *> availableParsers;
+
+    QBasicMutex *loadFromFileMutex = new QBasicMutex();
+    QBasicMutex *reloadDatabaseMutex = new QBasicMutex();
+};
+
+#endif // COCKATRICE_CARD_DATABASE_LOADER_H

libs/card/include/card/card_database/card_database_manager.h

@@ -0,0 +1,29 @@
+/**
+ * @file card_database_manager.h
+ * @ingroup CardDatabase
+ * @brief The CardDatabaseManager is responsible for managing the global database singleton.
+ */
+
+#ifndef CARD_DATABASE_ACCESSOR_H
+#define CARD_DATABASE_ACCESSOR_H
+
+#pragma once
+#include "card_database.h"
+
+class CardDatabaseManager
+{
+public:
+    // Delete copy constructor and assignment operator to enforce singleton
+    CardDatabaseManager(const CardDatabaseManager &) = delete;
+    CardDatabaseManager &operator=(const CardDatabaseManager &) = delete;
+
+    // Static method to access the singleton instance
+    static CardDatabase *getInstance();
+    static CardDatabaseQuerier *query();
+
+private:
+    CardDatabaseManager() = default; // Private constructor
+    ~CardDatabaseManager() = default;
+};
+
+#endif // CARD_DATABASE_ACCESSOR_H

libs/card/include/card/card_database/card_database_querier.h

@@ -0,0 +1,61 @@
+/**
+ * @file card_database_querier.h
+ * @ingroup CardDatabase
+ * @brief The CardDatabaseQuerier is responsible for querying the database and returning data.
+ */
+
+#ifndef COCKATRICE_CARD_DATABASE_QUERIER_H
+#define COCKATRICE_CARD_DATABASE_QUERIER_H
+
+#include "card/card_info.h"
+#include "card/card_printing/exact_card.h"
+#include "utility/card_ref.h"
+
+#include <QObject>
+
+class CardDatabase;
+class CardDatabaseQuerier : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit CardDatabaseQuerier(QObject *parent, const CardDatabase *db);
+
+    [[nodiscard]] CardInfoPtr getCardInfo(const QString &cardName) const;
+    [[nodiscard]] QList<CardInfoPtr> getCardInfos(const QStringList &cardNames) const;
+
+    /*
+     * Get a card by its simple name. The name will be simplified in this
+     * function, so you don't need to simplify it beforehand.
+     */
+    [[nodiscard]] CardInfoPtr getCardBySimpleName(const QString &cardName) const;
+
+    [[nodiscard]] ExactCard guessCard(const CardRef &cardRef) const;
+    [[nodiscard]] ExactCard getCard(const CardRef &cardRef) const;
+    [[nodiscard]] QList<ExactCard> getCards(const QList<CardRef> &cardRefs) const;
+
+    [[nodiscard]] ExactCard getRandomCard() const;
+    [[nodiscard]] ExactCard getCardFromSameSet(const QString &cardName, const PrintingInfo &otherPrinting) const;
+
+    [[nodiscard]] ExactCard getPreferredCard(const CardInfoPtr &card) const;
+    [[nodiscard]] bool isPreferredPrinting(const CardRef &cardRef) const;
+    [[nodiscard]] PrintingInfo getPreferredPrinting(const CardInfoPtr &card) const;
+    [[nodiscard]] PrintingInfo getPreferredPrinting(const QString &cardName) const;
+    [[nodiscard]] QString getPreferredPrintingProviderId(const QString &cardName) const;
+
+    [[nodiscard]] PrintingInfo getSpecificPrinting(const CardRef &cardRef) const;
+    [[nodiscard]] PrintingInfo
+    getSpecificPrinting(const QString &cardName, const QString &setCode, const QString &collectorNumber) const;
+    [[nodiscard]] PrintingInfo findPrintingWithId(const CardInfoPtr &card, const QString &providerId) const;
+
+    [[nodiscard]] QStringList getAllMainCardTypes() const;
+    [[nodiscard]] QMap<QString, int> getAllMainCardTypesWithCount() const;
+    [[nodiscard]] QMap<QString, int> getAllSubCardTypesWithCount() const;
+
+private:
+    const CardDatabase *db;
+
+    CardInfoPtr lookupCardByName(const QString &name) const;
+};
+
+#endif // COCKATRICE_CARD_DATABASE_QUERIER_H

libs/card/include/card/card_database/model/card/card_completer_proxy_model.h

@@ -0,0 +1,22 @@
+/**
+ * @file card_completer_proxy_model.h
+ * @ingroup CardDatabaseModels
+ * @brief TODO: Document this.
+ */
+
+#ifndef CARD_COMPLETER_PROXY_MODEL_H
+#define CARD_COMPLETER_PROXY_MODEL_H
+
+#include <QSortFilterProxyModel>
+
+class CardCompleterProxyModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+public:
+    explicit CardCompleterProxyModel(QObject *parent = nullptr);
+
+protected:
+    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
+};
+
+#endif // CARD_COMPLETER_PROXY_MODEL_H

libs/card/include/card/card_database/model/card/card_search_model.h

@@ -0,0 +1,36 @@
+/**
+ * @file card_search_model.h
+ * @ingroup CardDatabaseModels
+ * @brief TODO: Document this.
+ */
+
+#ifndef CARD_SEARCH_MODEL_H
+#define CARD_SEARCH_MODEL_H
+
+#include "card/card_database/model/card_database_display_model.h"
+
+#include <QAbstractListModel>
+
+class CardSearchModel : public QAbstractListModel
+{
+    Q_OBJECT
+public:
+    explicit CardSearchModel(CardDatabaseDisplayModel *sourceModel, QObject *parent = nullptr);
+
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+
+    void updateSearchResults(const QString &query); // Update results based on input
+
+private:
+    struct SearchResult
+    {
+        CardInfoPtr card;
+        int distance;
+    };
+
+    CardDatabaseDisplayModel *sourceModel;
+    QList<SearchResult> searchResults;
+};
+
+#endif // CARD_SEARCH_MODEL_H

libs/card/include/card/card_database/model/card_database_display_model.h

@@ -0,0 +1,99 @@
+/**
+ * @file card_database_display_model.h
+ * @ingroup CardDatabaseModels
+ * @brief The CardDatabaseDisplayModel is a QSortFilterProxyModel that allows applying filters and sorting to a
+ * CardDatabaseModel.
+ */
+
+#ifndef COCKATRICE_CARD_DATABASE_DISPLAY_MODEL_H
+#define COCKATRICE_CARD_DATABASE_DISPLAY_MODEL_H
+
+#include "filter_string.h"
+
+#include <QList>
+#include <QSet>
+#include <QSortFilterProxyModel>
+#include <QTimer>
+
+class FilterTree;
+class CardDatabaseDisplayModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+public:
+    enum FilterBool
+    {
+        ShowTrue,
+        ShowFalse,
+        ShowAll
+    };
+
+private:
+    FilterBool isToken;
+    QString cardName, cardText;
+    QSet<QString> cardNameSet, cardTypes, cardColors;
+    FilterTree *filterTree;
+    FilterString *filterString;
+    int loadedRowCount;
+    QTimer dirtyTimer;
+
+    /** The translation table that will be used for sanitizeCardName. */
+    static QMap<wchar_t, wchar_t> characterTranslation;
+
+public:
+    explicit CardDatabaseDisplayModel(QObject *parent = nullptr);
+    void setFilterTree(FilterTree *_filterTree);
+    void setIsToken(FilterBool _isToken)
+    {
+        isToken = _isToken;
+        emit modelDirty();
+        dirty();
+    }
+
+    void setCardName(const QString &_cardName)
+    {
+        if (filterString != nullptr) {
+            delete filterString;
+            filterString = nullptr;
+        }
+        cardName = sanitizeCardName(_cardName, characterTranslation);
+        emit modelDirty();
+        dirty();
+    }
+    void setStringFilter(const QString &_src)
+    {
+        delete filterString;
+        filterString = new FilterString(_src);
+        emit modelDirty();
+        dirty();
+    }
+    void setCardNameSet(const QSet<QString> &_cardNameSet)
+    {
+        cardNameSet = _cardNameSet;
+        emit modelDirty();
+        dirty();
+    }
+
+    void dirty()
+    {
+        dirtyTimer.start(20);
+    }
+    void clearFilterAll();
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    bool canFetchMore(const QModelIndex &parent) const override;
+    void fetchMore(const QModelIndex &parent) override;
+signals:
+    void modelDirty();
+
+protected:
+    bool lessThan(const QModelIndex &left, const QModelIndex &right) const override;
+    static int lessThanNumerically(const QString &left, const QString &right);
+    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
+    bool rowMatchesCardName(CardInfoPtr info) const;
+
+private slots:
+    void filterTreeChanged();
+    /** Will translate all undesirable characters in DIRTYNAME according to the TABLE. */
+    const QString sanitizeCardName(const QString &dirtyName, const QMap<wchar_t, wchar_t> &table);
+};
+
+#endif // COCKATRICE_CARD_DATABASE_DISPLAY_MODEL_H

libs/card/include/card/card_database/model/card_database_model.h

@@ -0,0 +1,62 @@
+/**
+ * @file card_database_model.h
+ * @ingroup CardDatabaseModels
+ * @brief The CardDatabaseModel maps the cardList contained in the CardDatabase as a QAbstractListModel.
+ */
+
+#ifndef CARDDATABASEMODEL_H
+#define CARDDATABASEMODEL_H
+
+#include "card/card_database/card_database.h"
+
+#include <QAbstractListModel>
+#include <QList>
+#include <QSet>
+
+class CardDatabaseModel : public QAbstractListModel
+{
+    Q_OBJECT
+public:
+    enum Columns
+    {
+        NameColumn,
+        SetListColumn,
+        ManaCostColumn,
+        PTColumn,
+        CardTypeColumn,
+        ColorColumn
+    };
+    enum Role
+    {
+        SortRole = Qt::UserRole
+    };
+    CardDatabaseModel(CardDatabase *_db, bool _showOnlyCardsFromEnabledSets, QObject *parent = nullptr);
+    ~CardDatabaseModel() override;
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    int columnCount(const QModelIndex &parent = QModelIndex()) const override;
+    QVariant data(const QModelIndex &index, int role) const override;
+    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
+    CardDatabase *getDatabase() const
+    {
+        return db;
+    }
+    CardInfoPtr getCard(int index) const
+    {
+        return cardList[index];
+    }
+
+private:
+    QList<CardInfoPtr> cardList;
+    QSet<CardInfoPtr> cardListSet; // Supports faster lookups in cardDatabaseEnabledSetsChanged()
+    CardDatabase *db;
+    bool showOnlyCardsFromEnabledSets;
+
+    inline bool checkCardHasAtLeastOneEnabledSet(CardInfoPtr card);
+private slots:
+    void cardAdded(CardInfoPtr card);
+    void cardRemoved(CardInfoPtr card);
+    void cardInfoChanged(CardInfoPtr card);
+    void cardDatabaseEnabledSetsChanged();
+};
+
+#endif

libs/card/include/card/card_database/model/token/token_display_model.h

@@ -0,0 +1,23 @@
+/**
+ * @file token_display_model.h
+ * @ingroup CardDatabaseModels
+ * @brief TODO: Document this.
+ */
+
+#ifndef COCKATRICE_TOKEN_DISPLAY_MODEL_H
+#define COCKATRICE_TOKEN_DISPLAY_MODEL_H
+
+#include "card/card_database/model/card_database_display_model.h"
+
+class TokenDisplayModel : public CardDatabaseDisplayModel
+{
+    Q_OBJECT
+public:
+    explicit TokenDisplayModel(QObject *parent = nullptr);
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+
+protected:
+    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
+};
+
+#endif // COCKATRICE_TOKEN_DISPLAY_MODEL_H

libs/card/include/card/card_database/model/token/token_edit_model.h

@@ -0,0 +1,23 @@
+/**
+ * @file token_edit_model.h
+ * @ingroup CardDatabaseModels
+ * @brief TODO: Document this.
+ */
+
+#ifndef COCKATRICE_TOKEN_EDIT_MODEL_H
+#define COCKATRICE_TOKEN_EDIT_MODEL_H
+
+#include "card/card_database/model/card_database_display_model.h"
+
+class TokenEditModel : public CardDatabaseDisplayModel
+{
+    Q_OBJECT
+public:
+    explicit TokenEditModel(QObject *parent = nullptr);
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+
+protected:
+    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
+};
+
+#endif // COCKATRICE_TOKEN_EDIT_MODEL_H

libs/card/include/card/card_database/parser/card_database_parser.h

@@ -0,0 +1,51 @@
+/**
+ * @file card_database_parser.h
+ * @ingroup CardDatabaseParsers
+ * @brief The ICardDatabaseParser defines the base interface for parser sub-classes.
+ */
+
+#ifndef CARDDATABASE_PARSER_H
+#define CARDDATABASE_PARSER_H
+
+#include "card/card_info.h"
+
+#include <QIODevice>
+#include <QString>
+
+#define COCKATRICE_XML_XSI_NAMESPACE "http://www.w3.org/2001/XMLSchema-instance"
+
+class ICardDatabaseParser : public QObject
+{
+    Q_OBJECT
+public:
+    ~ICardDatabaseParser() override = default;
+
+    virtual bool getCanParseFile(const QString &name, QIODevice &device) = 0;
+    virtual void parseFile(QIODevice &device) = 0;
+    virtual bool saveToFile(SetNameMap sets,
+                            CardNameMap cards,
+                            const QString &fileName,
+                            const QString &sourceUrl = "unknown",
+                            const QString &sourceVersion = "unknown") = 0;
+    static void clearSetlist();
+
+protected:
+    /*
+     * A cached list of the available sets, needed to cross-reference sets from cards.
+     * Shared between all parsers
+     */
+    static SetNameMap sets;
+
+    CardSetPtr internalAddSet(const QString &setName,
+                              const QString &longName = "",
+                              const QString &setType = "",
+                              const QDate &releaseDate = QDate(),
+                              const CardSet::Priority priority = CardSet::PriorityFallback);
+signals:
+    void addCard(CardInfoPtr card);
+    void addSet(CardSetPtr set);
+};
+
+Q_DECLARE_INTERFACE(ICardDatabaseParser, "ICardDatabaseParser")
+
+#endif

libs/card/include/card/card_database/parser/cockatrice_xml_3.h

@@ -0,0 +1,37 @@
+/**
+ * @file cockatrice_xml_3.h
+ * @ingroup CardDatabaseParsers
+ * @brief The CockatriceXml3Parser is capable of parsing version 3 of the Cockatrice XML Schema.
+ */
+
+#ifndef COCKATRICE_XML3_H
+#define COCKATRICE_XML3_H
+
+#include "card/card_database/parser/card_database_parser.h"
+
+#include <QLoggingCategory>
+#include <QXmlStreamReader>
+
+inline Q_LOGGING_CATEGORY(CockatriceXml3Log, "cockatrice_xml.xml_3_parser");
+
+class CockatriceXml3Parser : public ICardDatabaseParser
+{
+    Q_OBJECT
+public:
+    CockatriceXml3Parser() = default;
+    ~CockatriceXml3Parser() override = default;
+    bool getCanParseFile(const QString &name, QIODevice &device) override;
+    void parseFile(QIODevice &device) override;
+    bool saveToFile(SetNameMap _sets,
+                    CardNameMap cards,
+                    const QString &fileName,
+                    const QString &sourceUrl = "unknown",
+                    const QString &sourceVersion = "unknown") override;
+
+private:
+    void loadCardsFromXml(QXmlStreamReader &xml);
+    void loadSetsFromXml(QXmlStreamReader &xml);
+    QString getMainCardType(QString &type);
+};
+
+#endif

libs/card/include/card/card_database/parser/cockatrice_xml_4.h

@@ -0,0 +1,37 @@
+/**
+ * @file cockatrice_xml_4.h
+ * @ingroup CardDatabaseParsers
+ * @brief The CockatriceXml4Parser is capable of parsing version 4 of the Cockatrice XML Schema.
+ */
+
+#ifndef COCKATRICE_XML4_H
+#define COCKATRICE_XML4_H
+
+#include "card/card_database/parser/card_database_parser.h"
+
+#include <QLoggingCategory>
+#include <QXmlStreamReader>
+
+inline Q_LOGGING_CATEGORY(CockatriceXml4Log, "cockatrice_xml.xml_4_parser");
+
+class CockatriceXml4Parser : public ICardDatabaseParser
+{
+    Q_OBJECT
+public:
+    CockatriceXml4Parser() = default;
+    ~CockatriceXml4Parser() override = default;
+    bool getCanParseFile(const QString &name, QIODevice &device) override;
+    void parseFile(QIODevice &device) override;
+    bool saveToFile(SetNameMap _sets,
+                    CardNameMap cards,
+                    const QString &fileName,
+                    const QString &sourceUrl = "unknown",
+                    const QString &sourceVersion = "unknown") override;
+
+private:
+    QVariantHash loadCardPropertiesFromXml(QXmlStreamReader &xml);
+    void loadCardsFromXml(QXmlStreamReader &xml);
+    void loadSetsFromXml(QXmlStreamReader &xml);
+};
+
+#endif

libs/card/include/card/card_info.h

@@ -0,0 +1,354 @@
+/**
+ * @file card_info.h
+ * @ingroup Cards
+ * @brief TODO: Document this.
+ */
+
+#ifndef CARD_INFO_H
+#define CARD_INFO_H
+
+#include "card_printing/printing_info.h"
+
+#include <QDate>
+#include <QHash>
+#include <QList>
+#include <QLoggingCategory>
+#include <QMap>
+#include <QMetaType>
+#include <QSharedPointer>
+#include <QStringList>
+#include <QVariant>
+#include <utility>
+
+inline Q_LOGGING_CATEGORY(CardInfoLog, "card_info");
+
+class CardInfo;
+class CardSet;
+class CardRelation;
+class ICardDatabaseParser;
+
+typedef QSharedPointer<CardInfo> CardInfoPtr;
+typedef QSharedPointer<CardSet> CardSetPtr;
+typedef QMap<QString, QList<PrintingInfo>> SetToPrintingsMap;
+
+typedef QHash<QString, CardInfoPtr> CardNameMap;
+typedef QHash<QString, CardSetPtr> SetNameMap;
+
+Q_DECLARE_METATYPE(CardInfoPtr)
+
+/**
+ * @class CardInfo
+ * @ingroup Cards
+ *
+ * @brief Represents a card and its associated metadata, properties, and relationships.
+ *
+ * CardInfo holds both static information (name, text, flags) and dynamic data
+ * (properties, set memberships, relationships). It also integrates with
+ * signals/slots, allowing observers to react to property or visual updates.
+ *
+ * Each CardInfo may belong to multiple sets through its printings, and can
+ * be related to other cards through defined relationships.
+ */
+class CardInfo : public QObject
+{
+    Q_OBJECT
+
+private:
+    CardInfoPtr smartThis;                         ///< Smart pointer to self for safe cross-references.
+    QString name;                                  ///< Full name of the card.
+    QString simpleName;                            ///< Simplified name for fuzzy matching.
+    QString text;                                  ///< Text description or rules text of the card.
+    bool isToken;                                  ///< Whether this card is a token or not.
+    QVariantHash properties;                       ///< Key-value store of dynamic card properties.
+    QList<CardRelation *> relatedCards;            ///< Forward references to related cards.
+    QList<CardRelation *> reverseRelatedCards;     ///< Cards that refer back to this card.
+    QList<CardRelation *> reverseRelatedCardsToMe; ///< Cards that consider this card as related.
+    SetToPrintingsMap setsToPrintings;             ///< Mapping from set names to printing variations.
+    QString setsNames;                             ///< Cached, human-readable list of set names.
+    bool cipt;                                     ///< Positioning flag used by UI.
+    bool landscapeOrientation;                     ///< Orientation flag for rendering.
+    int tableRow;                                  ///< Row index in a table or visual representation.
+    bool upsideDownArt;                            ///< Whether artwork is flipped for visual purposes.
+
+public:
+    /**
+     * @brief Constructs a CardInfo with full initialization.
+     *
+     * @param _name The name of the card.
+     * @param _text Rules text or description of the card.
+     * @param _isToken Flag indicating whether the card is a token.
+     * @param _properties Arbitrary key-value properties.
+     * @param _relatedCards Forward references to related cards.
+     * @param _reverseRelatedCards Backward references to related cards.
+     * @param _sets Map of set names to printing information.
+     * @param _cipt UI positioning flag.
+     * @param _landscapeOrientation UI rendering orientation.
+     * @param _tableRow Row index for table placement.
+     * @param _upsideDownArt Whether the artwork should be displayed upside down.
+     */
+    explicit CardInfo(const QString &_name,
+                      const QString &_text,
+                      bool _isToken,
+                      QVariantHash _properties,
+                      const QList<CardRelation *> &_relatedCards,
+                      const QList<CardRelation *> &_reverseRelatedCards,
+                      SetToPrintingsMap _sets,
+                      bool _cipt,
+                      bool _landscapeOrientation,
+                      int _tableRow,
+                      bool _upsideDownArt);
+
+    /**
+     * @brief Copy constructor for CardInfo.
+     *
+     * Performs a deep copy of properties, sets, and related card lists.
+     *
+     * @param other Another CardInfo to copy.
+     */
+    CardInfo(const CardInfo &other)
+        : QObject(other.parent()), name(other.name), simpleName(other.simpleName), text(other.text),
+          isToken(other.isToken), properties(other.properties), relatedCards(other.relatedCards),
+          reverseRelatedCards(other.reverseRelatedCards), reverseRelatedCardsToMe(other.reverseRelatedCardsToMe),
+          setsToPrintings(other.setsToPrintings), setsNames(other.setsNames), cipt(other.cipt),
+          landscapeOrientation(other.landscapeOrientation), tableRow(other.tableRow), upsideDownArt(other.upsideDownArt)
+    {
+    }
+
+    /**
+     * @brief Creates a new instance with only the card name.
+     *
+     * All other fields are set to defaults.
+     *
+     * @param _name The card name.
+     * @return Shared pointer to the new CardInfo instance.
+     */
+    static CardInfoPtr newInstance(const QString &_name);
+
+    /**
+     * @brief Creates a new instance with full initialization.
+     *
+     * @param _name Name of the card.
+     * @param _text Rules text or description.
+     * @param _isToken Token flag.
+     * @param _properties Arbitrary properties.
+     * @param _relatedCards Forward relationships.
+     * @param _reverseRelatedCards Reverse relationships.
+     * @param _sets Printing information per set.
+     * @param _cipt UI positioning flag.
+     * @param _landscapeOrientation UI rendering orientation.
+     * @param _tableRow Row index for table placement.
+     * @param _upsideDownArt Artwork orientation flag.
+     * @return Shared pointer to the new CardInfo instance.
+     */
+    static CardInfoPtr newInstance(const QString &_name,
+                                   const QString &_text,
+                                   bool _isToken,
+                                   QVariantHash _properties,
+                                   const QList<CardRelation *> &_relatedCards,
+                                   const QList<CardRelation *> &_reverseRelatedCards,
+                                   SetToPrintingsMap _sets,
+                                   bool _cipt,
+                                   bool _landscapeOrientation,
+                                   int _tableRow,
+                                   bool _upsideDownArt);
+
+    /**
+     * @brief Clones the current CardInfo instance.
+     *
+     * Uses the copy constructor and ensures the smart pointer is properly set.
+     *
+     * @return Shared pointer to the cloned CardInfo.
+     */
+    CardInfoPtr clone() const
+    {
+        CardInfoPtr newCardInfo = CardInfoPtr(new CardInfo(*this));
+        newCardInfo->setSmartPointer(newCardInfo); // Set the smart pointer for the new instance
+        return newCardInfo;
+    }
+
+    /**
+     * @brief Sets the internal smart pointer to self.
+     *
+     * Used internally to allow safe cross-references among CardInfo and CardSet.
+     *
+     * @param _ptr Shared pointer pointing to this instance.
+     */
+    void setSmartPointer(CardInfoPtr _ptr)
+    {
+        smartThis = std::move(_ptr);
+    }
+
+    /** @name Basic Properties Accessors */ //@{
+    inline const QString &getName() const
+    {
+        return name;
+    }
+    const QString &getSimpleName() const
+    {
+        return simpleName;
+    }
+    const QString &getText() const
+    {
+        return text;
+    }
+    void setText(const QString &_text)
+    {
+        text = _text;
+        emit cardInfoChanged(smartThis);
+    }
+    bool getIsToken() const
+    {
+        return isToken;
+    }
+    QStringList getProperties() const
+    {
+        return properties.keys();
+    }
+    QString getProperty(const QString &propertyName) const
+    {
+        return properties.value(propertyName).toString();
+    }
+    void setProperty(const QString &_name, const QString &_value)
+    {
+        properties.insert(_name, _value);
+        emit cardInfoChanged(smartThis);
+    }
+    bool hasProperty(const QString &propertyName) const
+    {
+        return properties.contains(propertyName);
+    }
+    const SetToPrintingsMap &getSets() const
+    {
+        return setsToPrintings;
+    }
+    const QString &getSetsNames() const
+    {
+        return setsNames;
+    }
+    //@}
+
+    /** @name Related Cards Accessors */ //@{
+    const QList<CardRelation *> &getRelatedCards() const
+    {
+        return relatedCards;
+    }
+    const QList<CardRelation *> &getReverseRelatedCards() const
+    {
+        return reverseRelatedCards;
+    }
+    const QList<CardRelation *> &getReverseRelatedCards2Me() const
+    {
+        return reverseRelatedCardsToMe;
+    }
+    QList<CardRelation *> getAllRelatedCards() const
+    {
+        QList<CardRelation *> result;
+        result.append(getRelatedCards());
+        result.append(getReverseRelatedCards2Me());
+        return result;
+    }
+    void resetReverseRelatedCards2Me();
+    void addReverseRelatedCards2Me(CardRelation *cardRelation)
+    {
+        reverseRelatedCardsToMe.append(cardRelation);
+    }
+    //@}
+
+    /** @name UI Positioning */ //@{
+    bool getCipt() const
+    {
+        return cipt;
+    }
+    bool getLandscapeOrientation() const
+    {
+        return landscapeOrientation;
+    }
+    int getTableRow() const
+    {
+        return tableRow;
+    }
+    void setTableRow(int _tableRow)
+    {
+        tableRow = _tableRow;
+    }
+    bool getUpsideDownArt() const
+    {
+        return upsideDownArt;
+    }
+    const QChar getColorChar() const;
+    //@}
+
+    /** @name Legacy/Convenience Property Accessors */ //@{
+    const QString getCardType() const;
+    void setCardType(const QString &value);
+    const QString getCmc() const;
+    const QString getColors() const;
+    void setColors(const QString &value);
+    const QString getLoyalty() const;
+    const QString getMainCardType() const;
+    const QString getManaCost() const;
+    const QString getPowTough() const;
+    void setPowTough(const QString &value);
+    //@}
+
+    /**
+     * @brief Returns a version of the card name safe for file storage or fuzzy matching.
+     *
+     * Removes invalid characters, replaces spacing markers, and normalizes diacritics.
+     *
+     * @return Corrected card name as a QString.
+     */
+    QString getCorrectedName() const;
+
+    /**
+     * @brief Adds a printing to a specific set.
+     *
+     * Updates the mapping and refreshes the cached list of set names.
+     *
+     * @param _set The set to which the card should be added.
+     * @param _info Optional printing information.
+     */
+    void addToSet(const CardSetPtr &_set, PrintingInfo _info = PrintingInfo());
+
+    /**
+     * @brief Combines legality properties from a provided map.
+     *
+     * Useful for merging format legality flags from multiple sources.
+     *
+     * @param props Key-value mapping of format legalities.
+     */
+    void combineLegalities(const QVariantHash &props);
+
+    /**
+     * @brief Refreshes the cached, human-readable list of set names.
+     *
+     * Typically called after adding or modifying set memberships.
+     */
+    void refreshCachedSetNames();
+
+    /**
+     * @brief Simplifies a name for fuzzy matching.
+     *
+     * Converts to lowercase, removes punctuation/spacing.
+     *
+     * @param name Original name string.
+     * @return Simplified name string.
+     */
+    static QString simplifyName(const QString &name);
+
+signals:
+    /**
+     * @brief Emitted when a pixmap for this card has been updated or finished loading.
+     *
+     * @param printing Specific printing for which the pixmap has updated.
+     */
+    void pixmapUpdated(const PrintingInfo &printing);
+
+    /**
+     * @brief Emitted when card properties or state have changed.
+     *
+     * @param card Shared pointer to the CardInfo instance that changed.
+     */
+    void cardInfoChanged(CardInfoPtr card);
+};
+#endif

libs/card/include/card/card_info_comparator.h

@@ -0,0 +1,30 @@
+/**
+ * @file card_info_comparator.h
+ * @ingroup Cards
+ * @brief TODO: Document this.
+ */
+
+#ifndef CARD_INFO_COMPARATOR_H
+#define CARD_INFO_COMPARATOR_H
+
+#include "card_info.h"
+
+#include <QStringList>
+#include <QVariant>
+#include <Qt>
+
+class CardInfoComparator
+{
+public:
+    explicit CardInfoComparator(const QStringList &properties, Qt::SortOrder order = Qt::AscendingOrder);
+    bool operator()(const CardInfoPtr &a, const CardInfoPtr &b) const;
+
+private:
+    QStringList m_properties; // List of properties to sort by
+    Qt::SortOrder m_order;
+
+    QVariant getProperty(const CardInfoPtr &card, const QString &property) const;
+    bool compareVariants(const QVariant &a, const QVariant &b) const;
+};
+
+#endif // CARD_INFO_COMPARATOR_H

libs/card/include/card/card_printing/exact_card.h

@@ -0,0 +1,48 @@
+#ifndef EXACT_CARD_H
+#define EXACT_CARD_H
+
+#include "card/card_info.h"
+
+/**
+ * @class ExactCard
+ * @ingroup Cards
+ * @brief Identifies the card by its CardInfoPtr along with its exact printing by its PrintingInfo.
+ */
+class ExactCard
+{
+    CardInfoPtr card;
+    PrintingInfo printing;
+
+public:
+    ExactCard();
+    explicit ExactCard(const CardInfoPtr &_card, const PrintingInfo &_printing = PrintingInfo());
+
+    /**
+     * Gets the CardInfoPtr. Can be null.
+     */
+    CardInfoPtr getCardPtr() const
+    {
+        return card;
+    }
+
+    /**
+     * Gets the PrintingInfo. Can be empty.
+     */
+    PrintingInfo getPrinting() const
+    {
+        return printing;
+    }
+
+    bool operator==(const ExactCard &other) const;
+
+    QString getName() const;
+    const CardInfo &getInfo() const;
+    QString getPixmapCacheKey() const;
+
+    bool isEmpty() const;
+    explicit operator bool() const;
+
+    void emitPixmapUpdated() const;
+};
+
+#endif // EXACT_CARD_H

libs/card/include/card/card_printing/printing_info.h

@@ -0,0 +1,56 @@
+#ifndef COCKATRICE_PRINTING_INFO_H
+#define COCKATRICE_PRINTING_INFO_H
+
+#include "card/card_set/card_set.h"
+
+#include <QList>
+#include <QMap>
+#include <QStringList>
+#include <QVariant>
+
+class PrintingInfo;
+
+using SetToPrintingsMap = QMap<QString, QList<PrintingInfo>>;
+
+/**
+ * Info relating to a specific printing for a card.
+ */
+class PrintingInfo
+{
+public:
+    explicit PrintingInfo(const CardSetPtr &_set = nullptr);
+    ~PrintingInfo() = default;
+
+    bool operator==(const PrintingInfo &other) const
+    {
+        return this->set == other.set && this->properties == other.properties;
+    }
+
+private:
+    CardSetPtr set;
+    // per-printing card properties;
+    QVariantHash properties;
+
+public:
+    CardSetPtr getSet() const
+    {
+        return set;
+    }
+
+    QStringList getProperties() const
+    {
+        return properties.keys();
+    }
+    QString getProperty(const QString &propertyName) const
+    {
+        return properties.value(propertyName).toString();
+    }
+    void setProperty(const QString &_name, const QString &_value)
+    {
+        properties.insert(_name, _value);
+    }
+
+    QString getUuid() const;
+};
+
+#endif // COCKATRICE_PRINTING_INFO_H

libs/card/include/card/card_relation/card_relation.h

@@ -0,0 +1,73 @@
+#ifndef COCKATRICE_CARD_RELATION_H
+#define COCKATRICE_CARD_RELATION_H
+
+#include "card/card_relation/card_relation_type.h"
+
+#include <QObject>
+#include <QString>
+
+class CardRelation : public QObject
+{
+    Q_OBJECT
+
+private:
+    QString name;
+    CardRelationType attachType;
+    bool isCreateAllExclusion;
+    bool isVariableCount;
+    int defaultCount;
+    bool isPersistent;
+
+public:
+    explicit CardRelation(const QString &_name = QString(),
+                          CardRelationType _attachType = CardRelationType::DoesNotAttach,
+                          bool _isCreateAllExclusion = false,
+                          bool _isVariableCount = false,
+                          int _defaultCount = 1,
+                          bool _isPersistent = false);
+
+    const QString &getName() const
+    {
+        return name;
+    }
+    CardRelationType getAttachType() const
+    {
+        return attachType;
+    }
+    bool getDoesAttach() const
+    {
+        return attachType != CardRelationType::DoesNotAttach;
+    }
+    bool getDoesTransform() const
+    {
+        return attachType == CardRelationType::TransformInto;
+    }
+
+    QString getAttachTypeAsString() const
+    {
+        return cardAttachTypeToString(attachType);
+    }
+
+    bool getCanCreateAnother() const
+    {
+        return !getDoesAttach();
+    }
+    bool getIsCreateAllExclusion() const
+    {
+        return isCreateAllExclusion;
+    }
+    bool getIsVariable() const
+    {
+        return isVariableCount;
+    }
+    int getDefaultCount() const
+    {
+        return defaultCount;
+    }
+    bool getIsPersistent() const
+    {
+        return isPersistent;
+    }
+};
+
+#endif // COCKATRICE_CARD_RELATION_H

libs/card/include/card/card_relation/card_relation_type.h

@@ -0,0 +1,29 @@
+#ifndef COCKATRICE_CARD_RELATION_TYPE_H
+#define COCKATRICE_CARD_RELATION_TYPE_H
+
+#include <QString>
+
+/**
+ * Represents how a card relates to another (attach, transform, etc.).
+ */
+enum class CardRelationType
+{
+    DoesNotAttach = 0,
+    AttachTo = 1,
+    TransformInto = 2,
+};
+
+// Optional helper
+inline QString cardAttachTypeToString(CardRelationType type)
+{
+    switch (type) {
+        case CardRelationType::AttachTo:
+            return "attach";
+        case CardRelationType::TransformInto:
+            return "transform";
+        default:
+            return "";
+    }
+}
+
+#endif // COCKATRICE_CARD_RELATION_TYPE_H

libs/card/include/card/card_set/card_set.h

@@ -0,0 +1,116 @@
+#ifndef COCKATRICE_CARD_SET_H
+#define COCKATRICE_CARD_SET_H
+
+#include <QDate>
+#include <QList>
+#include <QSharedPointer>
+#include <QString>
+
+class CardInfo;
+using CardInfoPtr = QSharedPointer<CardInfo>;
+
+class CardSet;
+using CardSetPtr = QSharedPointer<CardSet>;
+
+class CardSet : public QList<CardInfoPtr>
+{
+public:
+    enum Priority
+    {
+        PriorityFallback = 0,
+        PriorityPrimary = 10,
+        PrioritySecondary = 20,
+        PriorityReprint = 30,
+        PriorityOther = 40,
+        PriorityLowest = 100,
+    };
+
+    static const char *TOKENS_SETNAME;
+
+private:
+    QString shortName, longName;
+    unsigned int sortKey;
+    QDate releaseDate;
+    QString setType;
+    Priority priority;
+    bool enabled, isknown;
+
+public:
+    explicit CardSet(const QString &_shortName = QString(),
+                     const QString &_longName = QString(),
+                     const QString &_setType = QString(),
+                     const QDate &_releaseDate = QDate(),
+                     const Priority _priority = PriorityFallback);
+
+    static CardSetPtr newInstance(const QString &_shortName = QString(),
+                                  const QString &_longName = QString(),
+                                  const QString &_setType = QString(),
+                                  const QDate &_releaseDate = QDate(),
+                                  const Priority _priority = PriorityFallback);
+
+    QString getCorrectedShortName() const;
+
+    QString getShortName() const
+    {
+        return shortName;
+    }
+    QString getLongName() const
+    {
+        return longName;
+    }
+    QString getSetType() const
+    {
+        return setType;
+    }
+    QDate getReleaseDate() const
+    {
+        return releaseDate;
+    }
+    Priority getPriority() const
+    {
+        return priority;
+    }
+
+    void setLongName(const QString &_longName)
+    {
+        longName = _longName;
+    }
+    void setSetType(const QString &_setType)
+    {
+        setType = _setType;
+    }
+    void setReleaseDate(const QDate &_releaseDate)
+    {
+        releaseDate = _releaseDate;
+    }
+    void setPriority(const Priority _priority)
+    {
+        priority = _priority;
+    }
+
+    void loadSetOptions();
+    int getSortKey() const
+    {
+        return sortKey;
+    }
+    void setSortKey(unsigned int _sortKey);
+
+    bool getEnabled() const
+    {
+        return enabled;
+    }
+    void setEnabled(bool _enabled);
+
+    bool getIsKnown() const
+    {
+        return isknown;
+    }
+    void setIsKnown(bool _isknown);
+
+    bool getIsKnownIgnored() const
+    {
+        return longName.length() + setType.length() + releaseDate.toString().length() == 0;
+    }
+};
+
+#endif // COCKATRICE_CARD_SET_H

libs/card/include/card/card_set/card_set_comparator.h

@@ -0,0 +1,66 @@
+/**
+ * @file card_set_comparator.h
+ * @ingroup Cards
+ * @brief TODO: Document this.
+ */
+
+#ifndef SET_PRIORITY_COMPARATOR_H
+#define SET_PRIORITY_COMPARATOR_H
+
+#include "card/card_info.h"
+
+class SetPriorityComparator
+{
+public:
+    /*
+     * Returns true if a has higher download priority than b
+     * Enabled sets have priority over disabled sets
+     * Both groups follow the user-defined order
+     */
+    inline bool operator()(const CardSetPtr &a, const CardSetPtr &b) const
+    {
+        if (a->getEnabled()) {
+            return !b->getEnabled() || a->getSortKey() < b->getSortKey();
+        } else {
+            return !b->getEnabled() && a->getSortKey() < b->getSortKey();
+        }
+    }
+};
+
+class SetReleaseDateComparator
+{
+public:
+    /*
+     * Returns true if a has higher download priority than b
+     * Enabled sets have priority over disabled sets
+     * Both groups follow the user-defined order
+     */
+    inline bool operator()(const CardSetPtr &a, const CardSetPtr &b) const
+    {
+        if (a->getEnabled()) {
+            return !b->getEnabled() || a->getReleaseDate() < b->getReleaseDate();
+        } else {
+            return !b->getEnabled() && a->getReleaseDate() < b->getReleaseDate();
+        }
+    }
+};
+
+class CardSetPriorityComparator
+{
+public:
+    /*
+     * Returns true if a has higher download priority than b
+     * Enabled sets have priority over disabled sets
+     * Both groups follow the user-defined order
+     */
+    inline bool operator()(const PrintingInfo &a, const PrintingInfo &b) const
+    {
+        if (a.getSet()->getEnabled()) {
+            return !b.getSet()->getEnabled() || a.getSet()->getSortKey() < b.getSet()->getSortKey();
+        } else {
+            return !b.getSet()->getEnabled() && a.getSet()->getSortKey() < b.getSet()->getSortKey();
+        }
+    }
+};
+
+#endif // SET_PRIORITY_COMPARATOR_H

libs/card/include/card/card_set/card_set_list.h

@@ -0,0 +1,26 @@
+#ifndef COCKATRICE_CARD_SET_LIST_H
+#define COCKATRICE_CARD_SET_LIST_H
+
+#include "card_set.h"
+
+#include <QList>
+#include <QStringList>
+
+class CardSetList : public QList<CardSetPtr>
+{
+private:
+    class KeyCompareFunctor;
+
+public:
+    void sortByKey();
+    void guessSortKeys();
+    void enableAllUnknown();
+    void enableAll();
+    void markAllAsKnown();
+    int getEnabledSetsNum();
+    int getUnknownSetsNum();
+    QStringList getUnknownSetsNames();
+    void defaultSort();
+};
+
+#endif // COCKATRICE_CARD_SET_LIST_H

libs/card/include/card/game_specific_terms.h

@@ -0,0 +1,58 @@
+/**
+ * @file game_specific_terms.h
+ * @ingroup Cards
+ * @brief TODO: Document this.
+ */
+
+#ifndef GAME_SPECIFIC_TERMS_H
+#define GAME_SPECIFIC_TERMS_H
+
+#include <QCoreApplication>
+#include <QString>
+
+/*
+ * Collection of traslatable property names used in games,
+ * so we can use Game::Property instead of hardcoding strings.
+ * Note: Mtg = "Maybe that game"
+ */
+
+namespace Mtg
+{
+QString const CardType("type");
+QString const ConvertedManaCost("cmc");
+QString const Colors("colors");
+QString const Loyalty("loyalty");
+QString const MainCardType("maintype");
+QString const ManaCost("manacost");
+QString const PowTough("pt");
+QString const Side("side");
+QString const Layout("layout");
+QString const ColorIdentity("coloridentity");
+
+inline static const QString getNicePropertyName(QString key)
+{
+    if (key == CardType)
+        return QCoreApplication::translate("Mtg", "Card Type");
+    if (key == ConvertedManaCost)
+        return QCoreApplication::translate("Mtg", "Mana Value");
+    if (key == Colors)
+        return QCoreApplication::translate("Mtg", "Color(s)");
+    if (key == Loyalty)
+        return QCoreApplication::translate("Mtg", "Loyalty");
+    if (key == MainCardType)
+        return QCoreApplication::translate("Mtg", "Main Card Type");
+    if (key == ManaCost)
+        return QCoreApplication::translate("Mtg", "Mana Cost");
+    if (key == PowTough)
+        return QCoreApplication::translate("Mtg", "P/T");
+    if (key == Side)
+        return QCoreApplication::translate("Mtg", "Side");
+    if (key == Layout)
+        return QCoreApplication::translate("Mtg", "Layout");
+    if (key == ColorIdentity)
+        return QCoreApplication::translate("Mtg", "Color Identity");
+    return key;
+}
+}; // namespace Mtg
+
+#endif