// Las construcciones de cierre con gramáticas: unión, concatenación y estrella.
// Las tres agregan una variable inicial nueva y una o dos reglas.
#ifndef CLOSURE_H
#define CLOSURE_H

#include <set>
#include <stdexcept>
#include <string>
#include <vector>

#include "cfg.h"

// Una copia de g con el sufijo dado en el nombre de cada variable, para que dos gramáticas
// no compartan variables aunque las dos usen S.
inline Cfg rename_variables(const Cfg& g, const std::string& suffix) {
    Cfg result;
    result.terminals = g.terminals;
    result.start = g.start + suffix;
    for (const std::string& name : g.variables) {
        result.variables.push_back(name + suffix);
    }
    for (const Rule& rule : g.rules) {
        Rule renamed;
        renamed.head = rule.head + suffix;
        for (const std::string& symbol : rule.body) {
            renamed.body.push_back(is_variable(g, symbol) ? symbol + suffix : symbol);
        }
        result.rules.push_back(renamed);
    }
    return result;
}

// Junta las variables y las reglas de dos gramáticas ya renombradas, y agrega la variable
// inicial S0. Quien llama agrega las reglas de S0.
inline Cfg join(const Cfg& g1, const Cfg& g2) {
    Cfg g;
    g.start = "S0";
    g.variables = {"S0"};
    g.variables.insert(g.variables.end(), g1.variables.begin(), g1.variables.end());
    g.variables.insert(g.variables.end(), g2.variables.begin(), g2.variables.end());
    std::set<char> seen;
    for (const Cfg* part : {&g1, &g2}) {
        for (char a : part->terminals) {
            if (seen.insert(a).second) {
                g.terminals.push_back(a);
            }
        }
    }
    g.rules = g1.rules;
    g.rules.insert(g.rules.end(), g2.rules.begin(), g2.rules.end());
    return g;
}

// L(g) = L(g1) ∪ L(g2): la regla nueva es S0 → S1 | S2.
inline Cfg cfg_union(const Cfg& g1, const Cfg& g2) {
    Cfg a = rename_variables(g1, "_1");
    Cfg b = rename_variables(g2, "_2");
    Cfg g = join(a, b);
    g.rules.insert(g.rules.begin(), {Rule{"S0", {a.start}}, Rule{"S0", {b.start}}});
    check_cfg(g);
    return g;
}

// L(g) = L(g1) L(g2): la regla nueva es S0 → S1 S2.
inline Cfg cfg_concat(const Cfg& g1, const Cfg& g2) {
    Cfg a = rename_variables(g1, "_1");
    Cfg b = rename_variables(g2, "_2");
    Cfg g = join(a, b);
    g.rules.insert(g.rules.begin(), Rule{"S0", {a.start, b.start}});
    check_cfg(g);
    return g;
}

// L(g) = L(g1)*: las reglas nuevas son S0 → S1 S0 | ε.
inline Cfg cfg_star(const Cfg& g1) {
    Cfg a = rename_variables(g1, "_1");
    Cfg g;
    g.start = "S0";
    g.variables = {"S0"};
    g.variables.insert(g.variables.end(), a.variables.begin(), a.variables.end());
    g.terminals = a.terminals;
    g.rules = {Rule{"S0", {a.start, "S0"}}, Rule{"S0", {}}};
    g.rules.insert(g.rules.end(), a.rules.begin(), a.rules.end());
    check_cfg(g);
    return g;
}

#endif
