card_info.h

Go to the documentation of this file.

#ifndef CARD_INFO_H
#define CARD_INFO_H
 
#include "format/format_legality_rules.h"
#include "lazy_properties_hash.h"
#include "printing/printing_info.h"
 
#include <QByteArray>
#include <QChar>
#include <QHash>
#include <QList>
#include <QLoggingCategory>
#include <QMap>
#include <QMetaType>
#include <QObject>
#include <QSet>
#include <QSharedPointer>
#include <QString>
#include <QStringList>
#include <qtmetamacros.h>
#include <utility>
 
inline Q_LOGGING_CATEGORY(CardInfoLog, "card_info");
 
class CardInfo;
class CardSet;
class CardRelation;
 
typedef QSharedPointer<CardInfo> CardInfoPtr;
typedef QSharedPointer<CardSet> CardSetPtr;
typedef QSharedPointer<FormatRules> FormatRulesPtr;
typedef QMap<QString, QList<PrintingInfo>> SetToPrintingsMap;
 
typedef QHash<QString, CardInfoPtr> CardNameMap;
typedef QHash<QString, CardSetPtr> SetNameMap;
typedef QHash<QString, FormatRulesPtr> FormatRulesNameMap;
 
Q_DECLARE_METATYPE(CardInfoPtr)
 

class CardInfo : public QObject
{
    Q_OBJECT
 
public:
    struct UiAttributes
    {
        bool cipt = false;                 
        bool landscapeOrientation = false; 
        int tableRow = 0;                  
        bool upsideDownArt = false;        
    };
 
private:
    CardInfoPtr smartThis; 
    QString name;          
    QString simpleName;    
    QString text;          
    bool isToken;          
 
    QMap<QString, QString> localizedNames; 
    QMap<QString, QString> localizedTexts; 
 
    LazyPropertiesHash properties; 
 
    QList<CardRelation *> relatedCards;            
    QList<CardRelation *> reverseRelatedCards;     
    QList<CardRelation *> reverseRelatedCardsToMe; 
    SetToPrintingsMap setsToPrintings;             
    UiAttributes uiAttributes;                     
    QString setsNames;                             
    QSet<QString> altNames;                        
 
public:
    explicit CardInfo(const QString &_name,
                      const QString &_text,
                      bool _isToken,
                      const QHash<QString, QString> &_properties,
                      const QList<CardRelation *> &_relatedCards,
                      const QList<CardRelation *> &_reverseRelatedCards,
                      SetToPrintingsMap _sets,
                      UiAttributes _uiAttributes,
                      QMap<QString, QString> _localizedNames = {},
                      QMap<QString, QString> _localizedTexts = {});

    explicit CardInfo(const QString &_name,
                      const QString &_text,
                      bool _isToken,
                      const QByteArray &_propertiesBlob,
                      const QList<CardRelation *> &_relatedCards,
                      const QList<CardRelation *> &_reverseRelatedCards,
                      SetToPrintingsMap _sets,
                      UiAttributes _uiAttributes,
                      QString _simpleName,
                      QSet<QString> _altNames,
                      QMap<QString, QString> _localizedNames = {},
                      QMap<QString, QString> _localizedTexts = {});

    CardInfo(const CardInfo &other)
        : QObject(other.parent()), name(other.name), simpleName(other.simpleName), text(other.text),
          isToken(other.isToken), localizedNames(other.localizedNames), localizedTexts(other.localizedTexts),
          properties(other.properties), relatedCards(other.relatedCards),
          reverseRelatedCards(other.reverseRelatedCards), reverseRelatedCardsToMe(other.reverseRelatedCardsToMe),
          setsToPrintings(other.setsToPrintings), uiAttributes(other.uiAttributes), setsNames(other.setsNames),
          altNames(other.altNames)
    {
    }

    static CardInfoPtr newInstance(const QString &_name);

    static CardInfoPtr newInstance(const QString &_name,
                                   const QString &_text,
                                   bool _isToken,
                                   const QHash<QString, QString> &_properties,
                                   const QList<CardRelation *> &_relatedCards,
                                   const QList<CardRelation *> &_reverseRelatedCards,
                                   SetToPrintingsMap _sets,
                                   UiAttributes _uiAttributes,
                                   QMap<QString, QString> _localizedNames = {},
                                   QMap<QString, QString> _localizedTexts = {});

    static CardInfoPtr newInstance(const QString &_name,
                                   const QString &_text,
                                   bool _isToken,
                                   QByteArray _propertiesBlob,
                                   const QList<CardRelation *> &_relatedCards,
                                   const QList<CardRelation *> &_reverseRelatedCards,
                                   SetToPrintingsMap _sets,
                                   UiAttributes _uiAttributes,
                                   QString _simpleName,
                                   QSet<QString> _altNames,
                                   bool _appendToSets = true,
                                   QMap<QString, QString> _localizedNames = {},
                                   QMap<QString, QString> _localizedTexts = {});

    [[nodiscard]] CardInfoPtr clone() const
    {
        auto newCardInfo = CardInfoPtr(new CardInfo(*this));
        newCardInfo->setSmartPointer(newCardInfo); // Set the smart pointer for the new instance
        return newCardInfo;
    }

    void setSmartPointer(CardInfoPtr _ptr)
    {
        smartThis = std::move(_ptr);
    }
 //@{
    [[nodiscard]] inline const QString &getName() const
    {
        return name;
    }
    [[nodiscard]] const QString &getSimpleName() const
    {
        return simpleName;
    }
    const QSet<QString> &getAltNames()
    {
        return altNames;
    }
    [[nodiscard]] const QString &getText() const
    {
        return text;
    }
    void setText(const QString &_text)
    {
        text = _text;
        emit cardInfoChanged(smartThis);
    }

    [[nodiscard]] const QString &getLocalizedName(const QString &lang) const
    {
        const auto it = localizedNames.constFind(lang);
        return it != localizedNames.constEnd() ? it.value() : name;
    }

    [[nodiscard]] const QString &getLocalizedText(const QString &lang) const
    {
        const auto it = localizedTexts.constFind(lang);
        return it != localizedTexts.constEnd() ? it.value() : text;
    }

    [[nodiscard]] const QMap<QString, QString> &getLocalizedNames() const
    {
        return localizedNames;
    }

    [[nodiscard]] const QMap<QString, QString> &getLocalizedTexts() const
    {
        return localizedTexts;
    }

    void setLocalizedName(const QString &lang, const QString &_localizedName)
    {
        if (localizedNames.value(lang) == _localizedName) {
            return;
        }
        localizedNames.insert(lang, _localizedName);
        emit cardInfoChanged(smartThis);
    }

    void setLocalizedText(const QString &lang, const QString &_localizedText)
    {
        if (localizedTexts.value(lang) == _localizedText) {
            return;
        }
        localizedTexts.insert(lang, _localizedText);
        emit cardInfoChanged(smartThis);
    }

    [[nodiscard]] QStringList localizationLanguages() const
    {
        QStringList languages = localizedNames.keys();
        languages.append(localizedTexts.keys());
        languages.removeDuplicates();
        return languages;
    }
    [[nodiscard]] bool getIsToken() const
    {
        return isToken;
    }
    [[nodiscard]] QStringList getProperties() const
    {
        return getPropertiesHash().keys();
    }
    [[nodiscard]] const QHash<QString, QString> &getPropertiesHash() const;
 
    [[nodiscard]] QString getProperty(const QString &propertyName) const
    {
        return getPropertiesHash().value(propertyName);
    }
    void setProperty(const QString &_name, const QString &_value);
    [[nodiscard]] bool hasProperty(const QString &propertyName) const
    {
        return getPropertiesHash().contains(propertyName);
    }
    [[nodiscard]] const SetToPrintingsMap &getSets() const
    {
        return setsToPrintings;
    }
    [[nodiscard]] const QString &getSetsNames() const
    {
        return setsNames;
    }

 //@{
    [[nodiscard]] const QList<CardRelation *> &getRelatedCards() const
    {
        return relatedCards;
    }
    [[nodiscard]] const QList<CardRelation *> &getReverseRelatedCards() const
    {
        return reverseRelatedCards;
    }
    [[nodiscard]] const QList<CardRelation *> &getReverseRelatedCards2Me() const
    {
        return reverseRelatedCardsToMe;
    }
    [[nodiscard]] QList<CardRelation *> getAllRelatedCards() const
    {
        QList<CardRelation *> result;
        result.append(getRelatedCards());
        result.append(getReverseRelatedCards2Me());
        return result;
    }
    void resetReverseRelatedCards2Me();
    void addReverseRelatedCards2Me(CardRelation *cardRelation)
    {
        reverseRelatedCardsToMe.append(cardRelation);
    }

 //@{
    [[nodiscard]] const UiAttributes &getUiAttributes() const
    {
        return uiAttributes;
    }

 
    [[nodiscard]] QChar getColorChar() const;
 //@{
    [[nodiscard]] QString getCardType() const;
    void setCardType(const QString &value);
    [[nodiscard]] QString getCmc() const;
    [[nodiscard]] QString getColors() const;
    void setColors(const QString &value);
    [[nodiscard]] QString getLoyalty() const;
    [[nodiscard]] QString getMainCardType() const;
    [[nodiscard]] QString getManaCost() const;
    [[nodiscard]] QString getPowTough() const;
    void setPowTough(const QString &value);

    [[nodiscard]] QString getCorrectedName() const;

    [[nodiscard]] QString getLegalityProp(const QString &format) const;

    [[nodiscard]] bool isLegalInFormat(const QString &format) const;

    void addToSet(const CardSetPtr &_set, const PrintingInfo &_info = PrintingInfo());

    void combineLegalities(const QHash<QString, QString> &props);

    void refreshCachedSets();

    static QString simplifyName(const QString &name);
 
private:
    void refreshCachedSetNames();

    void refreshCachedAltNames();
 
signals:
    void pixmapUpdated(const PrintingInfo &printing);

    void cardInfoChanged(CardInfoPtr card);
};
#endif