flagsgenerator.cpp

#include "flagsgenerator.hpp"
#include <iostream>
#include <fstream>
#include <random>
#include <string>
#include <vector>

std::mt19937 rng(std::random_device{}());

Item parseItem(const json &j) {
    Item it;

    if (j.is_string()) {
        it.isString = true;
        it.value = j.get<std::string>();
        return it;
    }

    if (j.is_object()) {
        it.isString = false;

        for (auto &[key, val] : j.items()) {
            it.name = key;

            for (const auto &child : val) {
                it.children.push_back(parseItem(child));
            }
        }
    }

    return it;
}

// -------- ANTIGA GERACAO DE STRING --------
// Agora ela só gera uma string a partir de um Item
std::string generateRandomFromItem(const Item &it);

std::string pickChild(const Item &it) {
    if (it.children.empty())
        return "";

    std::uniform_int_distribution<> dist(0, it.children.size() - 1);
    return generateRandomFromItem(it.children[dist(rng)]);
}

std::string generateRandomFromItem(const Item &it) {
    if (it.isString)
        return it.value;

    std::string base = it.name;
    std::string nameOnly;
    bool hasPar = false;
    bool hasAngle = false;

    if (base.find("()") != std::string::npos) {
        nameOnly = base.substr(0, base.size() - 2);
        hasPar = true;
    } else if (base.find("<>") != std::string::npos) {
        nameOnly = base.substr(0, base.size() - 2);
        hasAngle = true;
    } else {
        nameOnly = base;
    }

    std::string inner = pickChild(it);

    if (hasPar)
        return nameOnly + "(" + inner + ")";
    if (hasAngle)
        return nameOnly + "<" + inner + ">";

    return nameOnly + "(" + inner + ")";
}

// ----------------------------------------------------
// NOVO: generateRandomFlags agora retorna vector<Item>
// ----------------------------------------------------
std::vector<Item> generateRandomFlags(const std::vector<Item> &items) {
    std::uniform_int_distribution<> sizeDist(3, 50);
    int count = sizeDist(rng);

    std::uniform_int_distribution<> dist(0, items.size() - 1);

    std::vector<Item> out;
    out.reserve(count);

    for (int i = 0; i < count; i++) {
        out.push_back(items[dist(rng)]);
    }

    return out;
}

// -----------------------------------------------------------
// NOVO: Converte vector<Item> para string com flags separadas
// -----------------------------------------------------------
std::string itemsToFlagString(const std::vector<Item> &list) {
    std::string out;

    for (size_t i = 0; i < list.size(); i++) {
        out += generateRandomFromItem(list[i]);
        if (i + 1 < list.size())
            out += ",";
    }

    return out;
}

Item random_item(const std::vector<Item>& FLAGS) {
    if (FLAGS.empty()) {
        // segurança caso o JSON esteja vazio
        Item empty;
        empty.isString = true;
        empty.value = "";
        return empty;
    }

    std::uniform_int_distribution<> dist(0, FLAGS.size() - 1);
    return FLAGS[dist(rng)];
}

// int main() {
int run() {
    json j;
    std::ifstream f("flags.json");
    f >> j;

    std::vector<Item> items;

    for (const auto &entry : j["Flags"])
        items.push_back(parseItem(entry));

    // agora retorna lista de Item
    std::vector<Item> chosen = generateRandomFlags(items);

    // converter lista → string
    std::string result = itemsToFlagString(chosen);

    std::cout << "Flags aleatórias:\n" << result << "\n\n";

    return 0;
}