API.hpp

#pragma once
#include "scanner.hpp"
#include <string>
#include <vector>
#include "pattern.hpp"

class EasyScanner {
public:
    EasyScanner() : scanner(std::make_unique<MemoryScanner>()) {}

    // pattern scan
    std::vector<uintptr_t> ScanPattern(const std::string& pattern) {
        Pattern p(pattern);
        if (!p.IsValid()) {
            return {};
        }
        return scanner->PerformScan(p);
    }

    // string search
    std::vector<uintptr_t> ScanString(const std::string& str, bool caseSensitive = true) {
        std::vector<std::string> strings = { str };
        auto results = scanner->ScanStrings(strings, caseSensitive);

        std::vector<uintptr_t> addresses;
        for (const auto& result : results) {
            addresses.push_back(result.second);
        }
        return addresses;
    }

    //multi scan
    std::vector<std::pair<std::string, uintptr_t>>
        ScanMultiple(const std::vector<std::string>& patterns) {
        std::vector<std::pair<std::string, uintptr_t>> allResults;

        for (const auto& patternStr : patterns) {
            Pattern pattern(patternStr);
            if (pattern.IsValid()) {
                auto results = scanner->PerformScan(pattern);
                for (auto addr : results) {
                    allResults.emplace_back(patternStr, addr);
                }
            }
        }

        return allResults;
    }

    //extern
    void SetTargetProcess(HANDLE processHandle) {
        scanner = std::make_unique<MemoryScanner>(processHandle);
    }

    //auto scan all when loaded
    void EnableAutoScan(bool enable) {
        scanner->EnableDllAutoScan(enable);
    }

private:
    std::unique_ptr<MemoryScanner> scanner;
};