// Los lenguajes de los autómatas de machines/, como funciones que miran la cadena completa.
// Las pruebas comparan cada autómata y cada gramática con su función.
#ifndef PREDICATES_H
#define PREDICATES_H

#include <algorithm>
#include <cstddef>
#include <string>

#include "pumping.h"

// { w w^R }: los palíndromos de longitud par.
inline bool is_even_palindrome(const std::string& w) {
    std::string reversed(w.rbegin(), w.rend());
    return w.size() % 2 == 0 && w == reversed;
}

// Paréntesis balanceados: ningún prefijo cierra más de lo que abrió, y al final no queda nada abierto.
inline bool is_balanced(const std::string& w) {
    long open = 0;
    for (char c : w) {
        open += (c == '(') ? 1 : -1;
        if (open < 0) {
            return false;
        }
    }
    return open == 0;
}

// La misma cantidad de a que de b.
inline bool has_equal_ab(const std::string& w) {
    return std::count(w.begin(), w.end(), 'a') == std::count(w.begin(), w.end(), 'b');
}

// { a^n b^n c^m }
inline bool is_anbn_cm(const std::string& w) {
    std::size_t i = 0;
    std::size_t a = block(w, i, 'a');
    std::size_t b = block(w, i, 'b');
    block(w, i, 'c');
    return i == w.size() && a == b;
}

// { a^m b^n c^n }
inline bool is_am_bncn(const std::string& w) {
    std::size_t i = 0;
    block(w, i, 'a');
    std::size_t b = block(w, i, 'b');
    std::size_t c = block(w, i, 'c');
    return i == w.size() && b == c;
}

// { a^i b^j c^k : i = j o j = k }
inline bool is_ij_or_jk(const std::string& w) {
    return is_anbn_cm(w) || is_am_bncn(w);
}

// Cantidad par de unos.
inline bool has_even_ones(const std::string& w) {
    return std::count(w.begin(), w.end(), '1') % 2 == 0;
}

#endif
