#include "PatternRegistry.h"

PatternRegistry::PatternRegistry() {
    // Constructor - patterns will be registered by the service
}

void PatternRegistry::registerPattern(const PatternInfo& pattern) {
    patternMap_[pattern.name] = pattern;
    typeToNameMap_[pattern.type] = pattern.name;
}

void PatternRegistry::registerPattern(const String& name, uint8_t type, const String& description,
                                    std::function<void()> initializer, std::function<void()> updater,
                                    bool requiresColor2, bool supportsDirection) {
    PatternInfo info(name, type, description, initializer, updater, requiresColor2, supportsDirection);
    registerPattern(info);
}

const PatternInfo* PatternRegistry::getPattern(const String& name) const {
    auto it = patternMap_.find(name);
    return (it != patternMap_.end()) ? &it->second : nullptr;
}

const PatternInfo* PatternRegistry::getPattern(uint8_t type) const {
    auto typeIt = typeToNameMap_.find(type);
    if (typeIt == typeToNameMap_.end()) {
        return nullptr;
    }
    return getPattern(typeIt->second);
}

String PatternRegistry::getPatternName(uint8_t type) const {
    auto it = typeToNameMap_.find(type);
    return (it != typeToNameMap_.end()) ? it->second : "";
}

uint8_t PatternRegistry::getPatternType(const String& name) const {
    const PatternInfo* info = getPattern(name);
    return info ? info->type : 0;
}

std::vector<String> PatternRegistry::getAllPatternNames() const {
    std::vector<String> names;
    names.reserve(patternMap_.size());
    for (const auto& pair : patternMap_) {
        names.push_back(pair.first);
    }
    return names;
}

std::vector<PatternInfo> PatternRegistry::getAllPatterns() const {
    std::vector<PatternInfo> patterns;
    patterns.reserve(patternMap_.size());
    for (const auto& pair : patternMap_) {
        patterns.push_back(pair.second);
    }
    return patterns;
}

bool PatternRegistry::isValidPattern(const String& name) const {
    return patternMap_.find(name) != patternMap_.end();
}

bool PatternRegistry::isValidPattern(uint8_t type) const {
    return typeToNameMap_.find(type) != typeToNameMap_.end();
}

void PatternRegistry::executePattern(const String& name) const {
    const PatternInfo* info = getPattern(name);
    if (info && info->updater) {
        info->updater();
    }
}

void PatternRegistry::executePattern(uint8_t type) const {
    const PatternInfo* info = getPattern(type);
    if (info && info->updater) {
        info->updater();
    }
}

void PatternRegistry::initializePattern(const String& name) const {
    const PatternInfo* info = getPattern(name);
    if (info && info->initializer) {
        info->initializer();
    }
}

void PatternRegistry::initializePattern(uint8_t type) const {
    const PatternInfo* info = getPattern(type);
    if (info && info->initializer) {
        info->initializer();
    }
}

void PatternRegistry::updateTypeMap() {
    typeToNameMap_.clear();
    for (const auto& pair : patternMap_) {
        typeToNameMap_[pair.second.type] = pair.first;
    }
}