advancedDetector.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef ENGINES_ADVANCED_DETECTOR_H
#define ENGINES_ADVANCED_DETECTOR_H

#include "engines/metaengine.h"
#include "engines/engine.h"

#include "common/hash-str.h"

#include "common/gui_options.h" // Keep it here, so detection tables can refer to them

namespace Common {
class Error;
class FSList;
}
struct ADGameFileDescription {
    const char *fileName; 
    uint16 fileType;      
    const char *md5;      
    int64 fileSize;       
};

#define AD_LISTEND {NULL, 0, NULL, 0}

#define AD_ENTRY1(f, x) {{ f, 0, x, -1}, AD_LISTEND}

#define AD_ENTRY1s(f, x, s) {{ f, 0, x, s}, AD_LISTEND}

#define AD_ENTRY2s(f1, x1, s1, f2, x2, s2) {{f1, 0, x1, s1}, {f2, 0, x2, s2}, AD_LISTEND}

#define AD_ENTRY3s(f1, x1, s1, f2, x2, s2, f3, x3, s3) {{f1, 0, x1, s1}, {f2, 0, x2, s2}, {f3, 0, x3, s3}, AD_LISTEND}
#define AD_ENTRY4s(f1, x1, s1, f2, x2, s2, f3, x3, s3, f4, x4, s4) {{f1, 0, x1, s1}, {f2, 0, x2, s2}, {f3, 0, x3, s3}, {f4, 0, x4, s4}, AD_LISTEND}
#define AD_ENTRY5s(f1, x1, s1, f2, x2, s2, f3, x3, s3, f4, x4, s4, f5, x5, s5) {{f1, 0, x1, s1}, {f2, 0, x2, s2}, {f3, 0, x3, s3}, {f4, 0, x4, s4}, {f5, 0, x5, s5}, AD_LISTEND}
#define AD_ENTRY6s(f1, x1, s1, f2, x2, s2, f3, x3, s3, f4, x4, s4, f5, x5, s5, f6, x6, s6) {{f1, 0, x1, s1}, {f2, 0, x2, s2}, {f3, 0, x3, s3}, {f4, 0, x4, s4}, {f5, 0, x5, s5}, {f6, 0, x6, s6}, AD_LISTEND}

enum ADGameFlags : uint {
    ADGF_NO_FLAGS        =  0u,        
    ADGF_TAILMD5         = (1u << 16), 
    ADGF_AUTOGENTARGET   = (1u << 17), 
    ADGF_UNSTABLE        = (1u << 18), 
    ADGF_TESTING         = (1u << 19), 
    ADGF_PIRATED         = (1u << 20), 
    ADGF_UNSUPPORTED     = (1u << 21), 
    ADGF_WARNING         = (1u << 22), 
    ADGF_ADDENGLISH      = (1u << 23), 
    ADGF_MACRESFORK      = (1u << 24), 
    ADGF_USEEXTRAASTITLE = (1u << 25), 
    ADGF_DROPLANGUAGE    = (1u << 26), 
    ADGF_DROPPLATFORM    = (1u << 27), 
    ADGF_CD              = (1u << 28), 
    ADGF_DVD             = (1u << 29), 
    ADGF_DEMO            = (1u << 30), 
    ADGF_REMASTERED      = (1u << 31)  
};

struct ADGameDescription {
    const char *gameId;

    const char *extra;

    ADGameFileDescription filesDescriptions[14];

    Common::Language language;

    Common::Platform platform;

    uint32 flags;

    const char *guiOptions;
};

struct ADDetectedGameExtraInfo {
    Common::String gameName;            
    Common::String targetID;            
};

struct ADDetectedGame {
    bool hasUnknownFiles;           
    FilePropertiesMap matchedFiles; 
    const ADGameDescription *desc;  
    ADDetectedGame() : desc(nullptr), hasUnknownFiles(false) {}
    explicit ADDetectedGame(const ADGameDescription *d) : desc(d), hasUnknownFiles(false) {}
};

typedef Common::Array<ADDetectedGame> ADDetectedGames;

#define AD_TABLE_END_MARKER \
    { NULL, NULL, { { NULL, 0, NULL, 0 } }, Common::UNK_LANG, Common::kPlatformUnknown, ADGF_NO_FLAGS, GUIO0() }

struct ADFileBasedFallback {
    const ADGameDescription *desc;

    const char *filenames[10];
};


enum ADFlags {
    kADFlagUseExtraAsHint = (1 << 0),

     kADFlagMatchFullPaths = (1 << 1),

     kADFlagPreferFallbackDetection = (1 << 2),

    kADFlagCanPlayUnknownVariants = (1 << 3),
};


struct ADExtraGuiOptionsMap {
    const char *guioFlag;  
    ExtraGuiOption option; 
};

#define AD_EXTRA_GUI_OPTIONS_TERMINATOR { 0, { 0, 0, 0, 0, 0, 0 } }

class AdvancedMetaEngineDetection : public MetaEngineDetection {
protected:
    const byte *_gameDescriptors;

    const uint _descItemSize;

    const PlainGameDescriptor *_gameIds;

    uint _md5Bytes;

    uint32 _flags;

    Common::String _guiOptions;

    uint32 _maxScanDepth;

    const char * const *_directoryGlobs;

    int _maxAutogenLength;

     int _fullPathGlobsDepth;

public:
    AdvancedMetaEngineDetection(const void *descs, uint descItemSize, const PlainGameDescriptor *gameIds);

    PlainGameList getSupportedGames() const override;

    PlainGameDescriptor findGame(const char *gameId) const override;

    DetectedGames detectGames(const Common::FSList &fslist, uint32 skipADFlags, bool skipIncomplete) override;

    Common::Error createInstance(OSystem *syst, Engine **engine);

    static Common::StringArray getPathsFromEntry(const ADGameDescription *g);

    uint getMD5Bytes() const override final { return _md5Bytes; }

    int getGameVariantCount() const override final {
        uint count = 0;
        for (const byte *descPtr = _gameDescriptors; ((const ADGameDescription *)descPtr)->gameId != nullptr; descPtr += _descItemSize)
            ++count;
        return count;
    }

    void dumpDetectionEntries() const override final;

protected:
    typedef Common::HashMap<Common::Path, Common::FSNode, Common::Path::IgnoreCase_Hash, Common::Path::IgnoreCase_EqualTo> FileMap;

    virtual ADDetectedGame fallbackDetect(const FileMap &allFiles, const Common::FSList &fslist, ADDetectedGameExtraInfo **extra = nullptr) const {
        return ADDetectedGame();
    }

private:
    void initSubSystems(const ADGameDescription *gameDesc) const;
    void preprocessDescriptions();
    bool isEntryGrayListed(const ADGameDescription *g) const;
    void detectClashes() const;

private:
    Common::HashMap<Common::String, bool, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> _grayListMap;
    Common::HashMap<Common::String, bool, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> _globsMap;
    bool _hashMapsInited;

protected:
    virtual ADDetectedGames detectGame(const Common::FSNode &parent, const FileMap &allFiles, Common::Language language, Common::Platform platform, const Common::String &extra, uint32 skipADFlags = 0, bool skipIncomplete = false);

    ADDetectedGame detectGameFilebased(const FileMap &allFiles, const ADFileBasedFallback *fileBasedFallback) const;

    void composeFileHashMap(FileMap &allFiles, const Common::FSList &fslist, int depth, const Common::Path &parentName = Common::Path()) const;

    bool getFileProperties(const FileMap &allFiles, MD5Properties md5prop, const Common::Path &fname, FileProperties &fileProps) const;

    virtual DetectedGame toDetectedGame(const ADDetectedGame &adGame, ADDetectedGameExtraInfo *extraInfo = nullptr) const;

    bool cleanupPirated(ADDetectedGames &matched) const;

    friend class FileMapArchive;
};

class AdvancedMetaEngine : public MetaEngine {
public:
    Common::Error createInstance(OSystem *syst, Engine **engine) override;

    virtual Common::Error createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const = 0;

    const char *getName() const override = 0;

public:
    typedef Common::HashMap<Common::Path, Common::FSNode, Common::Path::IgnoreCase_Hash, Common::Path::IgnoreCase_EqualTo> FileMap;

    virtual ADDetectedGame fallbackDetectExtern(uint md5Bytes, const FileMap &allFiles, const Common::FSList &fslist, ADDetectedGameExtraInfo **extra = nullptr) const {
        return ADDetectedGame();
    }

    bool getFilePropertiesExtern(uint md5Bytes, const FileMap &allFiles, MD5Properties md5prop, const Common::Path &fname, FileProperties &fileProps) const;

protected:
    const ExtraGuiOptions getExtraGuiOptions(const Common::String &target) const override final;

    virtual const ADExtraGuiOptionsMap *getAdvancedExtraGuiOptions() const { return nullptr; }

    bool checkExtendedSaves(MetaEngineFeature f) const;
};

class AdvancedDetectorCacheManager : public Common::Singleton<AdvancedDetectorCacheManager> {
public:
    void setMD5(const Common::String &fname, const Common::String &md5) {
        md5HashMap.setVal(fname, md5);
    }

    const Common::String &getMD5(const Common::String &fname) const {
        return md5HashMap.getVal(fname);
    }

    void setSize(const Common::String &fname, int64 size) {
        sizeHashMap.setVal(fname, size);
    }

    int64 getSize(const Common::String &fname) const {
        return sizeHashMap.getVal(fname);
    }

    bool containsMD5(const Common::String &fname) const {
        return (md5HashMap.contains(fname) && sizeHashMap.contains(fname));
    }

    void addArchive(const Common::FSNode &node, Common::Archive *archivePtr) {
        if (!archivePtr)
            return;

        Common::Path filename = node.getPath();
        
        if (archiveHashMap.contains(filename)) {
            delete archiveHashMap[filename];
        }
        
        archiveHashMap.setVal(filename, archivePtr);
    }

    Common::Archive *getArchive(const Common::FSNode &node) const {
        return archiveHashMap.getValOrDefault(node.getPath(), nullptr);
    }

    AdvancedDetectorCacheManager() {
        clear();
    }

    void clearArchives() {
        for (auto &entry : archiveHashMap) {
            delete entry._value;
        }
        archiveHashMap.clear(true);
    }

    void clear() {
        md5HashMap.clear(true);
        sizeHashMap.clear(true);
        clearArchives();
    }

private:
    friend class Common::Singleton<AdvancedDetectorCacheManager>;

    typedef Common::HashMap<Common::String, Common::String, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> FileHashMap;
    typedef Common::HashMap<Common::String, int64, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> SizeHashMap;
    typedef Common::HashMap<Common::Path, Common::Archive *, Common::Path::IgnoreCase_Hash, Common::Path::IgnoreCase_EqualTo> ArchiveHashMap;
    FileHashMap md5HashMap;
    SizeHashMap sizeHashMap;
    ArchiveHashMap archiveHashMap;
};

#define ADCacheMan AdvancedDetectorCacheManager::instance()

#endif