#include <iostream>         ///< Para entrada e saída padrão (std::cout).
#include <vector>          ///< Para contêiner std::vector usado no armazenamento de sequências.
#include <string>          ///< Para std::string, usado em palavras e mensagens.
#include <unordered_map>   ///< Para std::unordered_map, usado no mapeamento de palavras.
#include <random>          ///< Para geração de números aleatórios (std::mt19937).
#include <cmath>           ///< Para funções matemáticas como std::exp, std::sqrt e std::log.
#include <fstream>         ///< Para leitura/escrita de arquivos.
#include <algorithm>       ///< Para std::sort e outras funções de manipulação.
#include <numeric>         ///< Para std::accumulate e std::transform.
#include <iomanip>         ///< Para std::fixed e std::setprecision, usados na formatação de saída.
#include <limits>          ///< Para std::numeric_limits.
#include <chrono>          ///< Para medir o tempo de execução (std::chrono::high_resolution_clock). 

#define NOMINMAX            ///< o windows.h inclui macros mim e max que conflitam com a 
                            ///< biblioteca padrão este define impede a definição destas macros
#include <windows.h>       ///< Para SetConsoleOutputCP e CP_UTF8 (específico do Windows)

// --- Constantes ---
/** @brief Valor máximo para a entrada da função sigmóide/exponencial para evitar overflow. */
const float MAX_EXP = 6.0f;

/**
 * @struct Word
 * @brief Estrutura para representar uma palavra, sua contagem e seus vetores no modelo Word2Vec (CBoW).
 */
struct Word {
    std::string word;           ///< A palavra em si.
    std::vector<float> vector;  ///< O vetor de embedding de ENTRADA da palavra (v_w).
    long long count = 0;        ///< Contagem de ocorrências no corpus, inicializada como 0.
};

/**
 * @class Word2Vec_CBOW
 * @brief Uma classe que implementa o modelo Word2Vec com Continuous Bag-of-Words (CBoW) e Softmax.
 *
 * Esta classe constrói embeddings de palavras a partir de um corpus de texto, utilizando
 * a abordagem CBoW para prever uma palavra-alvo a partir de seu contexto.
 * Utiliza a função Softmax completa para o cálculo de probabilidades, aderindo ao
 * exemplo teórico detalhado. Suporta treinamento, salvamento/carregamento de embeddings,
 * busca de palavras similares e operações de analogia vetorial.
 */
class Word2Vec_CBOW {
private:
    // --- Parâmetros do Modelo ---
    int vector_size;        ///< Dimensão dos vetores de embedding (d).
    int window_size;        ///< Tamanho máximo da janela de contexto (c).
    float learning_rate;    ///< Taxa de aprendizado inicial (eta).

    // --- Vocabulário e Embeddings ---
    std::unordered_map<std::string, int> word_to_index; ///< Mapeamento palavra -> índice.
    std::vector<Word> vocabulary;                      ///< Lista de palavras e seus embeddings DE ENTRADA (matriz W_entrada).
    std::vector<std::vector<float>> output_weights;     ///< Matriz de pesos de SAÍDA (W_saida), output_weights[vocab_idx] -> v'_w.

    // --- Contagens e Aleatoriedade ---
    long long total_words;                             ///< Total de palavras no corpus.
    mutable std::mt19937 rng;                          ///< Gerador Mersenne Twister (mutável para operações const como findSimilar).
    std::uniform_int_distribution<int> uniform_window; ///< Distribuição para tamanho dinâmico da janela.

    /**
     * @brief Inicializa os embeddings de entrada e os pesos de saída com valores aleatórios.
     *
     * Os vetores são inicializados com valores pequenos aleatórios seguindo uma distribuição uniforme,
     * conforme prática comum para facilitar a convergência durante o treinamento.
     */
    void initializeEmbeddings() {
        std::uniform_real_distribution<float> dist(-0.5f / vector_size, 0.5f / vector_size);
        output_weights.resize(vocabulary.size(), std::vector<float>(vector_size));

        for (size_t i = 0; i < vocabulary.size(); ++i) {
            vocabulary[i].vector.resize(vector_size);
            for (int j = 0; j < vector_size; ++j) {
                vocabulary[i].vector[j] = dist(rng); // Inicializa embedding de entrada v_w
                output_weights[i][j] = dist(rng);     // Inicializa pesos de saída v'_w (poderia ser inicializado com zeros também)
            }
        }
        std::cout << "Embeddings de entrada e pesos de saída inicializados para " << vocabulary.size() << " palavras.\n";
    }

    /**
     * @brief Calcula a função Softmax para um vetor de scores.
     * @param scores Vetor de scores (z) para cada palavra no vocabulário.
     * @return Vetor de probabilidades (P) após aplicar Softmax.
     * @note Inclui tratamento para evitar overflow numérico com exponenciais grandes.
     */
    std::vector<float> softmax(const std::vector<float>& scores) const {
        std::vector<float> probabilities(scores.size());
        float max_score = -std::numeric_limits<float>::infinity();
        for (float score : scores) {
            if (score > max_score) {
                max_score = score;
            }
        }

        float sum_exp = 0.0f;
        for (size_t i = 0; i < scores.size(); ++i) {
            // Subtrai max_score para estabilidade numérica
            float exp_val = std::exp(scores[i] - max_score);
            probabilities[i] = exp_val;
            sum_exp += exp_val;
        }

        if (sum_exp > 0.0f) { // Evita divisão por zero
            for (size_t i = 0; i < probabilities.size(); ++i) {
                probabilities[i] /= sum_exp;
            }
        }
        return probabilities;
    }


    /**
     * @brief Treina o modelo para um único par (contexto -> alvo) usando CBoW e Softmax.
     *
     * Implementa os passos descritos no exemplo CBoW do arquivo:
     * 1. Calcula o vetor médio do contexto (h).
     * 2. Calcula os scores (z) para todas as palavras do vocabulário.
     * 3. Aplica Softmax para obter probabilidades (P).
     * 4. Calcula o erro (gradiente) para a camada de saída (e = P - y).
     * 5. Propaga o erro para atualizar os pesos de saída (W_saida).
     * 6. Propaga o erro para atualizar os embeddings de entrada das palavras de contexto (W_entrada).
     *
     * @param context_indices Vetor contendo os índices das palavras de contexto.
     * @param target_idx Índice da palavra-alvo a ser prevista.
     */
    void trainCBOWPair(const std::vector<int>& context_indices, int target_idx) {
        if (context_indices.empty()) {
            return; // Não há contexto para treinar
        }

        // --- Passo 1 & 2: Calcular vetor médio do contexto (h) ---
        std::vector<float> h(vector_size, 0.0f);
        for (int context_idx : context_indices) {
            const auto& context_vector = vocabulary[context_idx].vector;
            for (int i = 0; i < vector_size; ++i) {
                h[i] += context_vector[i];
            }
        }
        // Calcular a média dividindo pelo número de palavras no contexto
        float num_context_words = static_cast<float>(context_indices.size());
        for (int i = 0; i < vector_size; ++i) {
            h[i] /= num_context_words;
        }

        // --- Passo 4: Calcular scores (z = h * W_saida) ---
        // z_j = h . v'_j  (produto escalar de h com o vetor de SAÍDA da palavra j)
        std::vector<float> scores(vocabulary.size());
        for (size_t j = 0; j < vocabulary.size(); ++j) {
            float dot_product = 0.0f;
            for (int i = 0; i < vector_size; ++i) {
                dot_product += h[i] * output_weights[j][i]; // h . v'_j
            }
            scores[j] = dot_product;
        }

        // --- Passo 5: Aplicar Softmax para obter probabilidades (P) ---
        std::vector<float> probabilities = softmax(scores);

        // --- Passo 7: Backpropagation ---
        // Calcular erro na camada de saída (e = P - y)
        // y é o vetor One-Hot da palavra alvo (target_idx)
        std::vector<float> error_output_layer = probabilities; // Copia P
        error_output_layer[target_idx] -= 1.0f; // Subtrai 1 na posição do alvo (P - y)

        // Calcular gradiente para a camada oculta (dL/dh = e * W_saida^T)
        // dL/dh_i = sum_j (e_j * W_saida[j][i]) = sum_j (e_j * v'_j[i])
        std::vector<float> gradient_hidden_layer(vector_size, 0.0f);
        for (int i = 0; i < vector_size; ++i) { // Para cada dimensão do embedding
            float sum = 0.0f;
            for (size_t j = 0; j < vocabulary.size(); ++j) { // Somar sobre todas as palavras do vocabulário
                sum += error_output_layer[j] * output_weights[j][i];
            }
            gradient_hidden_layer[i] = sum;
        }

        // --- Atualizar Pesos ---
        // Atualizar pesos de SAÍDA (W_saida)
        // dL/dW_saida[j] = dL/dz_j * dz_j/dW_saida[j] = e_j * h
        // v'_j (novo) = v'_j (antigo) - eta * e_j * h
        for (size_t j = 0; j < vocabulary.size(); ++j) {
            float error_j = error_output_layer[j]; // e_j
            for (int i = 0; i < vector_size; ++i) {
                output_weights[j][i] -= learning_rate * error_j * h[i];
            }
        }

        // Atualizar embeddings de ENTRADA (W_entrada) das palavras de contexto
        // dL/dv_context = dL/dh * dh/dv_context = dL/dh * (1 / num_context_words)
        // v_context (novo) = v_context (antigo) - eta * (1 / num_context_words) * dL/dh
        float factor = learning_rate / num_context_words;
        for (int context_idx : context_indices) {
            for (int i = 0; i < vector_size; ++i) {
                vocabulary[context_idx].vector[i] -= factor * gradient_hidden_layer[i];
            }
        }
    }

public:
    /**
     * @brief Construtor que inicializa os parâmetros do modelo CBoW.
     * @param vector_size Dimensão dos vetores de embedding (padrão: 100).
     * @param window_size Tamanho máximo da janela de contexto (padrão: 5).
     * @param learning_rate Taxa de aprendizado inicial (padrão: 0.05 para CBoW com Softmax).
     */
    Word2Vec_CBOW(int vector_size = 100, int window_size = 5, float learning_rate = 0.05f)
        : vector_size(vector_size), window_size(window_size),
        learning_rate(learning_rate), total_words(0), rng(std::random_device{}()) {
        uniform_window = std::uniform_int_distribution<int>(1, window_size); // Janela dinâmica [1, window_size]
        std::cout << "Modelo Word2Vec CBoW inicializado.\n";
        std::cout << "  Dimensão Vetores (d): " << vector_size << "\n";
        std::cout << "  Tamanho Janela (c): " << window_size << "\n";
        std::cout << "  Taxa Aprendizado (eta): " << learning_rate << "\n";
    }

    /**
     * @brief Constrói o vocabulário a partir de um corpus de texto.
     *
     * Conta as ocorrências de cada palavra e mapeia palavras para índices.
     * Após construir o vocabulário, inicializa os embeddings.
     *
     * @param corpus Vetor de sentenças, onde cada sentença é um vetor de palavras (strings).
     */
    void buildVocabulary(const std::vector<std::vector<std::string>>& corpus) {
        std::cout << "Construindo vocabulário...\n";
        std::unordered_map<std::string, long long> word_counts;
        total_words = 0;

        // Contar ocorrências
        for (const auto& sentence : corpus) {
            for (const auto& word : sentence) {
                word_counts[word]++;
                total_words++;
            }
        }

        // Verificar se o corpus é válido
        if (word_counts.empty()) {
            std::cerr << "Erro: Corpus vazio ou inválido. Vocabulário não pode ser construído.\n";
            return;
        }
        std::cout << "  Total de palavras no corpus: " << total_words << "\n";
        std::cout << "  Número de palavras únicas: " << word_counts.size() << "\n";

        // Construir vocabulário
        vocabulary.clear();
        word_to_index.clear();
        int index = 0;
        // Poderíamos adicionar filtragem por frequência mínima aqui se necessário
        for (const auto& [word, count] : word_counts) {
            Word w;
            w.word = word;
            w.count = count;
            vocabulary.push_back(w);
            word_to_index[word] = index++;
        }

        // Inicializar embeddings de entrada e pesos de saída
        initializeEmbeddings();
        std::cout << "Vocabulário construído e embeddings inicializados.\n";
    }

    /**
     * @brief Treina o modelo CBoW com Softmax completo.
     *
     * Itera sobre o corpus por um número definido de épocas. Em cada época,
     * processa cada palavra, define seu contexto e chama `trainCBOWPair`
     * para ajustar os embeddings e pesos. A taxa de aprendizado diminui linearmente
     * ao longo das épocas.
     *
     * @param corpus Vetor de sentenças para treinamento.
     * @param epochs Número de épocas de treinamento (padrão: 15).
     */
    void trainCBOW(const std::vector<std::vector<std::string>>& corpus, int epochs = 15) {
        if (vocabulary.empty()) {
            std::cerr << "Erro: Vocabulário não inicializado. Execute buildVocabulary primeiro.\n";
            return;
        }
        std::cout << "Iniciando treinamento CBoW por " << epochs << " épocas...\n";

        float initial_lr = learning_rate;
        long long words_processed_epoch = 0; // Para acompanhar progresso se necessário

        for (int epoch = 0; epoch < epochs; ++epoch) {
            words_processed_epoch = 0;
            long long pairs_trained = 0;

            for (const auto& sentence : corpus) {
                for (size_t i = 0; i < sentence.size(); ++i) {
                    // Encontrar índice da palavra-alvo
                    auto target_it = word_to_index.find(sentence[i]);
                    if (target_it == word_to_index.end()) continue; // Palavra fora do vocabulário
                    int target_idx = target_it->second;

                    // Determinar janela de contexto dinâmica
                    int current_window = uniform_window(rng);
                    std::vector<int> context_indices;
                    context_indices.reserve(static_cast<size_t>(window_size) * 2);

                    // Coletar índices das palavras de contexto
                    for (int j = -current_window; j <= current_window; ++j) {
                        if (j == 0) continue; // Pular a palavra-alvo
                        size_t context_pos = i + j;

                        // Verificar limites da sentença
                        if (context_pos < sentence.size()) { // size_t é sempre >= 0
                            auto context_it = word_to_index.find(sentence[context_pos]);
                            if (context_it != word_to_index.end()) {
                                context_indices.push_back(context_it->second);
                            }
                        }
                    }

                    // Treinar o par se houver contexto
                    if (!context_indices.empty()) {
                        trainCBOWPair(context_indices, target_idx);
                        pairs_trained++;
                    }
                    words_processed_epoch++;
                } // Fim do loop da sentença
            } // Fim do loop do corpus

            // Ajustar taxa de aprendizado linearmente
            learning_rate = initial_lr * (1.0f - static_cast<float>(epoch + 1) / epochs);
            // Garantir que a taxa de aprendizado não seja menor que um valor mínimo (opcional)
            learning_rate = std::max(learning_rate, initial_lr * 0.0001f);

            std::cout << "  Época " << epoch + 1 << "/" << epochs << " completa. Pares treinados: " << pairs_trained
                << ". LR atual: " << std::fixed << std::setprecision(6) << learning_rate << "\n";

        } // Fim do loop das épocas
        std::cout << "Treinamento CBoW concluído.\n";
    }

    /**
     * @brief Salva os embeddings de ENTRADA em um arquivo no formato texto Word2Vec.
     * @param filename Nome do arquivo de saída.
     * @note Salva apenas os vetores de entrada (v_w), que são tipicamente usados como embeddings.
     */
    void saveEmbeddings(const std::string& filename) const {
        std::cout << "Salvando embeddings de entrada em " << filename << "...\n";
        std::ofstream file(filename);
        if (!file.is_open()) {
            std::cerr << "Erro ao abrir arquivo para escrita: " << filename << "\n";
            return;
        }

        // Cabeçalho: número_de_palavras dimensão_vetor
        file << vocabulary.size() << " " << vector_size << "\n";

        // Linhas: palavra val1 val2 ... valN
        for (const auto& word : vocabulary) {
            file << word.word;
            for (float val : word.vector) {
                file << " " << std::fixed << std::setprecision(6) << val;
            }
            file << "\n";
        }
        file.close();
        std::cout << "Embeddings salvos com sucesso.\n";
    }

    /**
     * @brief Carrega embeddings pré-treinados de um arquivo.
     * @param filename Nome do arquivo de entrada.
     * @return True se o carregamento for bem-sucedido, false caso contrário.
     * @note Assume formato texto Word2Vec. Inicializa pesos de saída aleatoriamente
     * se for carregar embeddings para continuar o treinamento.
     */
    bool loadEmbeddings(const std::string& filename) {
        std::cout << "Carregando embeddings de " << filename << "...\n";
        std::ifstream file(filename);
        if (!file.is_open()) {
            std::cerr << "Erro ao abrir arquivo para leitura: " << filename << "\n";
            return false;
        }

        size_t vocab_size;
        int loaded_vector_size;
        file >> vocab_size >> loaded_vector_size;

        // Verifica se a dimensão do vetor carregado corresponde à configuração do modelo
        if (file.fail() || loaded_vector_size <= 0) {
            std::cerr << "Erro ao ler cabeçalho do arquivo: " << filename << "\n";
            return false;
        }

        std::cout << "  Arquivo contém " << vocab_size << " palavras com dimensão " << loaded_vector_size << ".\n";
        // Permite carregar embeddings com dimensão diferente, ajustando o modelo
        // Ou pode gerar um erro se as dimensões não baterem, dependendo do caso de uso.
        // Aqui, vamos ajustar o modelo para a dimensão carregada.
        if (loaded_vector_size != vector_size) {
            std::cout << "  Aviso: Dimensão do vetor no arquivo (" << loaded_vector_size
                << ") difere da configuração do modelo (" << vector_size
                << "). Ajustando modelo para " << loaded_vector_size << ".\n";
            vector_size = loaded_vector_size;
        }


        vocabulary.clear();
        word_to_index.clear();
        vocabulary.reserve(vocab_size);

        for (size_t i = 0; i < vocab_size; ++i) {
            Word w;
            file >> w.word;
            if (file.fail()) {
                std::cerr << "Erro ao ler palavra no índice " << i << " do arquivo.\n";
                return false; // Falha na leitura da palavra
            }
            w.vector.resize(vector_size);
            for (int j = 0; j < vector_size; ++j) {
                file >> w.vector[j];
                if (file.fail()) {
                    std::cerr << "Erro ao ler valor do vetor para a palavra '" << w.word << "' no índice " << j << ".\n";
                    return false; // Falha na leitura do vetor
                }
            }
            w.count = 1; // Contagem desconhecida ao carregar, definir como 1
            vocabulary.push_back(w);
            word_to_index[w.word] = i;
        }
        file.close();

        // Se carregou embeddings, precisa inicializar os pesos de saída se for treinar mais
        // Ou pode deixá-los vazios se for usar apenas para consulta.
        // Vamos inicializá-los para permitir treinamento adicional.
        output_weights.resize(vocabulary.size(), std::vector<float>(vector_size));
        std::uniform_real_distribution<float> dist(-0.5f / vector_size, 0.5f / vector_size);
        for (size_t i = 0; i < vocabulary.size(); ++i) {
            for (int j = 0; j < vector_size; ++j) {
                output_weights[i][j] = dist(rng);
            }
        }
        total_words = vocabulary.size(); // Estimativa grosseira se não tivermos o corpus original

        std::cout << "Embeddings carregados e pesos de saída (re)inicializados com sucesso.\n";
        return true;
    }


    /**
     * @brief Encontra as palavras com maior grau de similaridade a uma palavra dada usando similaridade de cosseno.
     * @param word Palavra de consulta.
     * @param top_n Número de palavras similares a retornar (padrão: 10).
     * @return Vetor de pares (palavra, similaridade), ordenado por similaridade decrescente.
     * @note Usa os embeddings de ENTRADA (v_w) para calcular a similaridade.
     */
    std::vector<std::pair<std::string, float>> findSimilar(const std::string& word, int top_n = 10) const {
        auto it = word_to_index.find(word);
        if (it == word_to_index.end()) {
            std::cerr << "Aviso: Palavra '" << word << "' não encontrada no vocabulário para busca de similaridade.\n";
            return {};
        }

        int word_idx = it->second;
        const auto& word_vector = vocabulary[word_idx].vector; // Usa vetor de ENTRADA
        std::vector<std::pair<std::string, float>> similarities;
        similarities.reserve(vocabulary.size());

        for (size_t i = 0; i < vocabulary.size(); ++i) {
            if (i == word_idx) continue; // Não comparar a palavra consigo mesma
            float similarity = cosineSimilarity(word_vector, vocabulary[i].vector); // Compara vetores de ENTRADA
            similarities.emplace_back(vocabulary[i].word, similarity);
        }

        // Ordenar por similaridade decrescente
        std::sort(similarities.begin(), similarities.end(),
            [](const auto& a, const auto& b) { return a.second > b.second; });

        // Retornar os top_n resultados
        if (similarities.size() > static_cast<size_t>(top_n)) {
            similarities.resize(top_n);
        }
        return similarities;
    }

    /**
     * @brief Calcula a similaridade de cosseno entre dois vetores.
     * @param a Primeiro vetor.
     * @param b Segundo vetor.
     * @return Valor da similaridade de cosseno [-1, 1]. Retorna 0 se uma das normas for zero.
     */
    float cosineSimilarity(const std::vector<float>& a, const std::vector<float>& b) const {
        if (a.size() != b.size() || a.empty()) {
            return 0.0f; // Vetores incompatíveis ou vazios
        }

        float dot_product = 0.0f;
        float norm_a = 0.0f;
        float norm_b = 0.0f;
        for (size_t i = 0; i < a.size(); ++i) {
            dot_product += a[i] * b[i];
            norm_a += a[i] * a[i];
            norm_b += b[i] * b[i];
        }

        // Evitar divisão por zero se um vetor for nulo
        if (norm_a <= 0.0f || norm_b <= 0.0f) {
            return 0.0f;
        }

        return dot_product / (std::sqrt(norm_a) * std::sqrt(norm_b));
    }

    /**
     * @brief Realiza operações de analogia vetorial (a - b + c ≈ ?).
     *
     * Calcula o vetor resultante `vec(a) - vec(b) + vec(c)` e encontra as palavras
     * cujos vetores de embedding (de entrada) são mais próximos a ele via similaridade de cosseno.
     *
     * @param a Primeira palavra positiva.
     * @param b Palavra negativa.
     * @param c Segunda palavra positiva.
     * @param top_n Número de resultados a retornar (padrão: 5).
     * @return Vetor de pares (palavra, similaridade).
     */
    std::vector<std::pair<std::string, float>> analogy(const std::string& a,
        const std::string& b,
        const std::string& c,
        int top_n = 5) const {
        auto it_a = word_to_index.find(a);
        auto it_b = word_to_index.find(b);
        auto it_c = word_to_index.find(c);

        if (it_a == word_to_index.end() || it_b == word_to_index.end() || it_c == word_to_index.end()) {
            std::cerr << "Aviso: Uma ou mais palavras da analogia (" << a << ", " << b << ", " << c << ") não encontradas no vocabulário.\n";
            return {};
        }

        const auto& vec_a = vocabulary[it_a->second].vector; // Vetor de ENTRADA
        const auto& vec_b = vocabulary[it_b->second].vector; // Vetor de ENTRADA
        const auto& vec_c = vocabulary[it_c->second].vector; // Vetor de ENTRADA

        std::vector<float> result_vec(vector_size);
        for (int i = 0; i < vector_size; ++i) {
            result_vec[i] = vec_a[i] - vec_b[i] + vec_c[i];
        }

        // Normalizar o vetor resultante (opcional, mas comum)
        float norm = 0.0f;
        for (float val : result_vec) {
            norm += val * val;
        }
        norm = std::sqrt(norm);
        if (norm > 0.0f) {
            for (float& val : result_vec) {
                val /= norm;
            }
        }

        // Encontrar palavras com maior grau de similaridades ao vetor resultante
        std::vector<std::pair<std::string, float>> similarities;
        similarities.reserve(vocabulary.size());
        for (size_t i = 0; i < vocabulary.size(); ++i) {
            // Não incluir as palavras de entrada na lista de resultados
            if (vocabulary[i].word == a || vocabulary[i].word == b || vocabulary[i].word == c) {
                continue;
            }
            float similarity = cosineSimilarity(result_vec, vocabulary[i].vector); // Compara com vetores de ENTRADA
            similarities.emplace_back(vocabulary[i].word, similarity);
        }

        // Ordenar e retornar top_n
        std::sort(similarities.begin(), similarities.end(),
            [](const auto& x, const auto& y) { return x.second > y.second; });
        if (similarities.size() > static_cast<size_t>(top_n)) {
            similarities.resize(top_n);
        }
        return similarities;
    }

    /**
     * @brief Retorna o vetor embedding de ENTRADA de uma palavra.
     * @param word Palavra de consulta.
     * @return Vetor de embedding (v_w). Retorna um vetor de zeros se a palavra não for encontrada.
     */
    std::vector<float> getWordVector(const std::string& word) const {
        auto it = word_to_index.find(word);
        if (it == word_to_index.end()) {
            std::cerr << "Aviso: Palavra '" << word << "' não encontrada no vocabulário para getWordVector.\n";
            return std::vector<float>(vector_size, 0.0f);
        }
        return vocabulary[it->second].vector; // Retorna vetor de ENTRADA
    }
};

/**
 * @brief Função principal que demonstra o uso da classe Word2Vec_CBOW.
 *
 * Este programa cria um modelo Word2Vec CBoW, constrói o vocabulário a partir de um corpus
 * simplificado, treina o modelo com CBoW e Softmax completo, e demonstra funcionalidades
 * como busca de palavras similares, operações de analogia e salvamento de embeddings.
 *
 * @return 0 em caso de execução bem-sucedida.
 */
/**
 * @brief Função principal que demonstra o uso da classe Word2Vec_CBOW.
 *
 * Este programa cria um modelo Word2Vec CBoW, constrói o vocabulário a partir de um corpus
 * simplificado, treina o modelo com CBoW e Softmax completo, e demonstra funcionalidades
 * como busca de palavras similares, operações de analogia e salvamento de embeddings.
 *
 * @return 0 em caso de execução bem-sucedida.
 */
int main() {
    // Configurar o console para UTF-8 (Específico do Windows)
    // Em outros sistemas (Linux/macOS), isso geralmente não é necessário
    // se o terminal já estiver configurado para UTF-8.
#ifdef _WIN32
    SetConsoleOutputCP(CP_UTF8);
    std::cout << "Console configurado para UTF-8.\n";
#endif

    // Corpus simplificado (o mesmo do exemplo anterior)
    std::vector<std::vector<std::string>> corpus = {
        {"o", "gato", "preto", "corre", "pelo", "jardim"},
        {"o", "cachorro", "late", "para", "o", "gato"},
        {"gatos", "e", "cachorros", "são", "animais", "domésticos"},
        {"muitas", "pessoas", "gostam", "de", "ter", "um", "animal", "de", "estimação"},
        {"os", "gatos", "gostam", "de", "dormir", "durante", "o", "dia"},
        {"os", "cachorros", "precisam", "passear", "todos", "os", "dias"}
    };
    std::cout << "Corpus de exemplo carregado com " << corpus.size() << " sentenças.\n";

    // --- Criar e Treinar Modelo CBoW ---
    // Usar parâmetros menores para o exemplo pequeno: dimensão 20, janela 2, lr 0.05
    // Softmax completo é mais sensível à taxa de aprendizado e requer mais épocas.
    Word2Vec_CBOW model(20, 2, 0.05f);

    // Medir Construção do Vocabulário 
    auto start_vocab = std::chrono::high_resolution_clock::now();
    
	// Calcular o tempo de construção do vocabulário
    auto end_vocab = std::chrono::high_resolution_clock::now();
    auto duration_vocab = std::chrono::duration_cast<std::chrono::nanoseconds>(end_vocab - start_vocab);
    std::cout << "Tempo de construção do vocabulário: " << duration_vocab.count() << " ns\n";
    
    // Medir Treinamento 
    int epochs_count = 100; 
    auto start_train = std::chrono::high_resolution_clock::now();
    
    // Construir vocabulário a partir do corpus
    model.buildVocabulary(corpus);

    // Treinar o modelo CBoW (pode precisar de mais épocas que SkipGram/NegSampling)
    model.trainCBOW(corpus, 100); // Aumentar épocas para CBoW com Softmax
    
    auto end_train = std::chrono::high_resolution_clock::now();
    auto duration_train = std::chrono::duration_cast<std::chrono::nanoseconds>(end_train - start_train);
    std::cout << "Tempo de treinamento (" << epochs_count << " épocas): " << duration_train.count() << " ns\n";
    // --- FIM ADIÇÃO ---
    
    // --- Usar o Modelo Treinado ---

    // Encontrar palavras similares a 'gato'
    std::cout << "\n--- Palavras similares a 'gato' ---\n";
    auto similar_to_cat = model.findSimilar("gato", 5); // Top 5
    if (similar_to_cat.empty()) {
        std::cout << "Nenhuma palavra similar encontrada (ou 'gato' não está no vocabulário).\n";
    }
    else {
        for (const auto& [word, similarity] : similar_to_cat) {
            std::cout << "  " << word << ": " << std::fixed << std::setprecision(4) << similarity << "\n";
        }
    }

    // Encontrar palavras similares a 'cachorro'
    std::cout << "\n--- Palavras similares a 'cachorro' ---\n";
    auto similar_to_dog = model.findSimilar("cachorro", 5); // Top 5
    if (similar_to_dog.empty()) {
        std::cout << "Nenhuma palavra similar encontrada (ou 'cachorro' não está no vocabulário).\n";
    }
    else {
        for (const auto& [word, similarity] : similar_to_dog) {
            std::cout << "  " << word << ": " << std::fixed << std::setprecision(4) << similarity << "\n";
        }
    }


    // Testar analogia: gato - gatos + cachorro ≈ cachorros ?
    // (Funciona melhor com corpus maiores e embeddings bem treinados)
    std::cout << "\n--- Analogia: gato está para gatos assim como cachorro está para...? ---\n";
    auto analogy_results = model.analogy("gato", "gatos", "cachorro", 3); // Top 3
    if (analogy_results.empty()) {
        std::cout << "Não foi possível calcular a analogia (palavras ausentes ou vocabulário pequeno).\n";
    }
    else {
        for (const auto& [word, similarity] : analogy_results) {
            std::cout << "  " << word << ": " << std::fixed << std::setprecision(4) << similarity << "\n";
        }
        // Esperado: 'cachorros' se o treino foi bom o suficiente
    }

    // Obter vetor de uma palavra específica
    std::cout << "\n--- Vetor da palavra 'animal' ---\n";
    std::vector<float> vec_animal = model.getWordVector("animal");
    if (vec_animal != std::vector<float>(20, 0.0f)) { // Compara com vetor de zeros
        std::cout << "  ["; // <--- CORRIGIDO AQUI (adicionado ';')
        for (size_t i = 0; i < vec_animal.size(); ++i) {
            std::cout << std::fixed << std::setprecision(3) << vec_animal[i] << (i == vec_animal.size() - 1 ? "" : ", ");
        }
        std::cout << "]\n";
    }


    // Salvar os embeddings de entrada resultantes
    model.saveEmbeddings("cbow_word_embeddings.txt");

    // Exemplo de como carregar embeddings (opcional)
    // Word2Vec_CBOW loaded_model(20); // Cria modelo com a dimensão correta
    // if (loaded_model.loadEmbeddings("cbow_word_embeddings.txt")) {
    //     std::cout << "\nEmbeddings carregados com sucesso no modelo 'loaded_model'.\n";
    //     auto similar_loaded = loaded_model.findSimilar("gato", 3);
    //     std::cout << "Palavras similares a 'gato' (modelo carregado):\n";
    //      for (const auto& [word, similarity] : similar_loaded) {
    //         std::cout << "  " << word << ": " << std::fixed << std::setprecision(4) << similarity << "\n";
    //     }
    // } else {
    //     std::cerr << "Falha ao carregar embeddings.\n";
    // }


    std::cout << "\nExecução concluída.\n";
    return 0;
}

#include <iostream>         ///< Para entrada e saída padrão (std::cout).
#include <vector>          ///< Para contêiner std::vector usado no armazenamento de sequências.
#include <string>          ///< Para std::string, usado em palavras e mensagens.
#include <unordered_map>   ///< Para std::unordered_map, usado no mapeamento de palavras.
#include <random>          ///< Para geração de números aleatórios (std::mt19937).
#include <cmath>           ///< Para funções matemáticas como std::exp, std::sqrt e std::log.
#include <fstream>         ///< Para leitura/escrita de arquivos.
#include <algorithm>       ///< Para std::sort e outras funções de manipulação.
#include <numeric>         ///< Para std::accumulate.
#include <iomanip>         ///< Para std::fixed e std::setprecision, usados na formatação de saída.
#include <limits>          ///< Para std::numeric_limits.
#include <chrono>          ///< Para medir o tempo de execução (std::chrono::high_resolution_clock).

#define NOMINMAX            ///< Impede a definição de macros min e max do windows.h que conflitam com a STL
#include <windows.h>       ///< Para SetConsoleOutputCP e CP_UTF8 (específico do Windows)

// --- Constantes ---
/** @brief Valor máximo para a entrada da função exponencial para evitar overflow na Softmax. */
const float MAX_EXP_SOFTMAX = 6.0f; // Ajustável conforme necessário

/**
 * @struct Word
 * @brief Estrutura para representar uma palavra, sua contagem e seu vetor de embedding de ENTRADA.
 */
struct Word {
    std::string word;           ///< A palavra em si.
    std::vector<float> vector;  ///< O vetor de embedding de ENTRADA da palavra (v_w).
    long long count = 0;        ///< Contagem de ocorrências no corpus, inicializada como 0.
};

/**
 * @class Word2Vec_SkipGram_Softmax
 * @brief Implementação do modelo Word2Vec com SkipGram e Softmax completo.
 *
 * Esta classe constrói embeddings de palavras a partir de um corpus de texto, utilizando
 * a abordagem SkipGram para prever palavras de contexto a partir de uma palavra-alvo.
 * Utiliza a função Softmax completa para o cálculo de probabilidades, aderindo ao
 * exemplo teórico detalhado no artigo. Suporta treinamento, salvamento/carregamento
 * de embeddings, busca de palavras similares e operações de analogia vetorial.
 * @note Esta implementação usa Softmax completo e pode ser computacionalmente intensiva
 * para vocabulários grandes. Otimizações como Negative Sampling ou Hierarchical Softmax
 * são geralmente preferidas na prática.
 */
class Word2Vec_SkipGram_Softmax {
private:
    // --- Parâmetros do Modelo ---
    int vector_size;        ///< Dimensão dos vetores de embedding (d).
    int window_size;        ///< Tamanho máximo da janela de contexto (c).
    float learning_rate;    ///< Taxa de aprendizado inicial (eta).
    float min_learning_rate; ///< Taxa de aprendizado mínima durante o decaimento.

    // --- Vocabulário e Embeddings ---
    std::unordered_map<std::string, int> word_to_index; ///< Mapeamento palavra -> índice.
    std::vector<Word> vocabulary;                      ///< Lista de palavras e seus embeddings DE ENTRADA (matriz W_entrada, v_w).
    std::vector<std::vector<float>> output_weights;     ///< Matriz de pesos de SAÍDA (W_saida, v'_w).

    // --- Contagens e Aleatoriedade ---
    long long total_words;                             ///< Total de palavras no corpus.
    long long words_processed;                         ///< Palavras processadas durante o treinamento para decaimento de LR.
    mutable std::mt19937 rng;                          ///< Gerador Mersenne Twister (mutável para operações const).
    std::uniform_int_distribution<int> uniform_window; ///< Distribuição para tamanho dinâmico da janela.

    /**
     * @brief Inicializa os embeddings de entrada (vocabulary[i].vector) e os pesos de saída (output_weights) com valores aleatórios.
     *
     * Os vetores são inicializados com valores pequenos aleatórios seguindo uma distribuição uniforme,
     * conforme prática comum para facilitar a convergência durante o treinamento.
     */
    void initializeEmbeddings() {
        std::uniform_real_distribution<float> dist(-0.5f / vector_size, 0.5f / vector_size);
        output_weights.resize(vocabulary.size(), std::vector<float>(vector_size));

        for (size_t i = 0; i < vocabulary.size(); ++i) {
            vocabulary[i].vector.resize(vector_size);
            for (int j = 0; j < vector_size; ++j) {
                vocabulary[i].vector[j] = dist(rng); // Inicializa embedding de entrada v_w
                output_weights[i][j] = dist(rng);    // Inicializa pesos de saída v'_w (alternativamente, poderiam ser zeros)
            }
        }
        std::cout << "Embeddings de entrada e pesos de saída inicializados para " << vocabulary.size() << " palavras.\n";
    }

    /**
     * @brief Calcula a função Softmax para um vetor de scores, de forma numericamente estável.
     * @param scores Vetor de scores (z) para cada palavra no vocabulário.
     * @return Vetor de probabilidades (P) após aplicar Softmax.
     */
    std::vector<float> softmax(const std::vector<float>& scores) const {
        std::vector<float> probabilities(scores.size());
        // Encontrar o score máximo para estabilidade numérica (subtrair previne exp(grande_numero))
        float max_score = -std::numeric_limits<float>::infinity();
        for (float score : scores) {
            if (score > max_score) {
                max_score = score;
            }
        }

        // Calcular exponenciais e a soma
        float sum_exp = 0.0f;
        for (size_t i = 0; i < scores.size(); ++i) {
            // Limitar a entrada da exponencial também pode ajudar
            float val = std::min(scores[i] - max_score, MAX_EXP_SOFTMAX);
            float exp_val = std::exp(val);
            probabilities[i] = exp_val;
            sum_exp += exp_val;
        }

        // Normalizar para obter probabilidades
        if (sum_exp > std::numeric_limits<float>::epsilon()) { // Evita divisão por zero ou número muito pequeno
            for (size_t i = 0; i < probabilities.size(); ++i) {
                probabilities[i] /= sum_exp;
            }
        }
        else {
            // Caso raro onde a soma é zero (todos os scores muito negativos)
            // Atribui probabilidade uniforme ou lida de outra forma
            for (size_t i = 0; i < probabilities.size(); ++i) {
                probabilities[i] = 1.0f / probabilities.size();
            }
        }
        return probabilities;
    }


    /**
     * @brief Treina o modelo para um único par (alvo -> contexto) usando SkipGram e Softmax completo.
     *
     * Implementa os passos descritos no exemplo SkipGram do artigo:
     * 1. Obtém o vetor de embedding da palavra-alvo (v_target).
     * 2. Calcula os scores (z) para todas as palavras do vocabulário usando v_target e W_saida.
     * 3. Aplica Softmax para obter probabilidades (P) de prever cada palavra como contexto.
     * 4. Calcula o erro (gradiente) para a camada de saída (e = P - y_context).
     * 5. Propaga o erro para calcular o gradiente do embedding da palavra-alvo (dL/dv_target).
     * 6. Atualiza os pesos de saída (W_saida) para todas as palavras do vocabulário.
     * 7. Atualiza o embedding de entrada da palavra-alvo (v_target).
     *
     * @param target_idx Índice da palavra-alvo (entrada).
     * @param context_idx Índice da palavra de contexto real a ser prevista (saída).
     * @param current_learning_rate Taxa de aprendizado atual para esta atualização.
     */
    void trainSkipGramPair(int target_idx, int context_idx, float current_learning_rate) {
        // --- Passo 1: Obter vetor de embedding da palavra-alvo ---
        const auto& v_target = vocabulary[target_idx].vector;

        // --- Passo 3: Calcular scores (z = v_target * W_saida) ---
        // z_j = v_target . v'_j (produto escalar de v_target com o vetor de SAÍDA da palavra j)
        std::vector<float> scores(vocabulary.size());
        for (size_t j = 0; j < vocabulary.size(); ++j) {
            float dot_product = 0.0f;
            for (int i = 0; i < vector_size; ++i) {
                // Usar output_weights[j] que corresponde a v'_j
                dot_product += v_target[i] * output_weights[j][i];
            }
            scores[j] = dot_product;
        }

        // --- Passo 4: Aplicar Softmax para obter probabilidades (P) ---
        std::vector<float> probabilities = softmax(scores);

        // --- Passo 6 (Backpropagation): Calcular erro na camada de saída ---
        // e = P - y_context, onde y_context é One-Hot para context_idx
        std::vector<float> error_output_layer = probabilities; // Copia P
        error_output_layer[context_idx] -= 1.0f; // Subtrai 1 na posição do contexto real

        // --- Passo 6 (Backpropagation): Calcular gradiente para o embedding da palavra-alvo ---
        // dL/dv_target = sum_j (e_j * v'_j) = e * W_saida^T
        std::vector<float> gradient_target_embedding(vector_size, 0.0f);
        for (int i = 0; i < vector_size; ++i) { // Para cada dimensão do embedding alvo
            float sum = 0.0f;
            for (size_t j = 0; j < vocabulary.size(); ++j) { // Somar sobre todas as palavras do vocabulário
                sum += error_output_layer[j] * output_weights[j][i]; // e_j * v'_j[i]
            }
            gradient_target_embedding[i] = sum;
        }

        // --- Passo 6 (Backpropagation): Atualizar Pesos de SAÍDA (W_saida ou v') ---
        // dL/dv'_j = dL/dz_j * dz_j/dv'_j = e_j * v_target
        // v'_j(novo) = v'_j(antigo) - eta * e_j * v_target
        // ATENÇÃO: Isso atualiza TODOS os vetores de saída (v'_j para todo j)
        for (size_t j = 0; j < vocabulary.size(); ++j) {
            float error_j = error_output_layer[j]; // e_j
            for (int i = 0; i < vector_size; ++i) {
                output_weights[j][i] -= current_learning_rate * error_j * v_target[i];
            }
        }

        // --- Passo 6 (Backpropagation): Atualizar Embedding de ENTRADA da palavra-alvo (v_target) ---
        // v_target(novo) = v_target(antigo) - eta * dL/dv_target
        for (int i = 0; i < vector_size; ++i) {
            // Acessar e modificar diretamente o vetor na estrutura Word
            vocabulary[target_idx].vector[i] -= current_learning_rate * gradient_target_embedding[i];
        }
    }

public:
    /**
     * @brief Construtor que inicializa os parâmetros do modelo SkipGram com Softmax.
     * @param vector_size Dimensão dos vetores de embedding (padrão: 100).
     * @param window_size Tamanho máximo da janela de contexto (padrão: 5).
     * @param learning_rate Taxa de aprendizado inicial (padrão: 0.025, comum para SkipGram).
     */
    Word2Vec_SkipGram_Softmax(int vector_size = 100, int window_size = 5, float learning_rate = 0.025f)
        : vector_size(vector_size), window_size(window_size),
        learning_rate(learning_rate), min_learning_rate(learning_rate * 0.0001f),
        total_words(0), words_processed(0), rng(std::random_device{}()) {
        uniform_window = std::uniform_int_distribution<int>(1, window_size); // Janela dinâmica [1, window_size]
        std::cout << "Modelo Word2Vec SkipGram (Softmax Completo) inicializado.\n";
        std::cout << "  Dimensão Vetores (d): " << vector_size << "\n";
        std::cout << "  Tamanho Janela (c): " << window_size << "\n";
        std::cout << "  Taxa Aprendizado (eta): " << learning_rate << "\n";
        std::cout << "  Aviso: Usando Softmax completo. Treinamento pode ser lento para vocabulários grandes.\n";
    }

    /**
     * @brief Constrói o vocabulário a partir de um corpus de texto.
     *
     * Conta as ocorrências de cada palavra e mapeia palavras para índices.
     * Após construir o vocabulário, inicializa os embeddings de entrada e saída.
     *
     * @param corpus Vetor de sentenças, onde cada sentença é um vetor de palavras (strings).
     */
    void buildVocabulary(const std::vector<std::vector<std::string>>& corpus) {
        std::cout << "Construindo vocabulário...\n";
        std::unordered_map<std::string, long long> word_counts;
        total_words = 0;

        // Contar ocorrências
        for (const auto& sentence : corpus) {
            for (const auto& word : sentence) {
                word_counts[word]++;
                total_words++;
            }
        }

        // Verificar se o corpus é válido
        if (word_counts.empty()) {
            std::cerr << "Erro: Corpus vazio ou inválido. Vocabulário não pode ser construído.\n";
            return;
        }
        std::cout << "  Total de palavras no corpus: " << total_words << "\n";
        std::cout << "  Número de palavras únicas: " << word_counts.size() << "\n";

        // Construir vocabulário
        vocabulary.clear();
        word_to_index.clear();
        int index = 0;
        // Poderíamos adicionar filtragem por frequência mínima aqui se necessário
        for (const auto& [word, count] : word_counts) {
            Word w;
            w.word = word;
            w.count = count;
            // Não redimensionar o vetor aqui, será feito em initializeEmbeddings
            vocabulary.push_back(w);
            word_to_index[word] = index++;
        }

        // Inicializar embeddings de entrada e pesos de saída
        initializeEmbeddings();
        std::cout << "Vocabulário construído e embeddings inicializados.\n";
    }

    /**
     * @brief Treina o modelo SkipGram com Softmax completo.
     *
     * Itera sobre o corpus por um número definido de épocas. Em cada época,
     * para cada palavra-alvo, itera sobre suas palavras de contexto e chama
     * `trainSkipGramPair` para ajustar os embeddings e pesos usando Softmax.
     * A taxa de aprendizado diminui linearmente ao longo das épocas com base
     * no número total de palavras-alvo processadas.
     *
     * @param corpus Vetor de sentenças para treinamento.
     * @param epochs Número de épocas de treinamento (padrão: 15).
     */
    void trainSkipGram(const std::vector<std::vector<std::string>>& corpus, int epochs = 15) {
        if (vocabulary.empty()) {
            std::cerr << "Erro: Vocabulário não inicializado. Execute buildVocabulary primeiro.\n";
            return;
        }
        std::cout << "Iniciando treinamento SkipGram (Softmax) por " << epochs << " épocas...\n";

        float initial_lr = learning_rate;
        words_processed = 0; // Reiniciar contagem de palavras processadas
        // Estimativa para decaimento de LR (total de palavras-alvo a serem processadas)
        long long total_training_words_estimate = static_cast<long long>(total_words) * epochs;

        for (int epoch = 0; epoch < epochs; ++epoch) {
            long long epoch_words_processed = 0; // Palavras-alvo processadas nesta época
            long long pairs_trained = 0;         // Pares (alvo, contexto) treinados nesta época

            for (const auto& sentence : corpus) {
                for (size_t i = 0; i < sentence.size(); ++i) {
                    // Encontrar índice da palavra-alvo (entrada)
                    auto target_it = word_to_index.find(sentence[i]);
                    if (target_it == word_to_index.end()) continue; // Palavra fora do vocabulário
                    int target_idx = target_it->second;

                    // --- CORREÇÃO: Calcular current_lr AQUI ---
                    // Calcula a taxa de aprendizado atual ANTES do loop de contexto
                    // baseado no progresso GERAL do treinamento (total de palavras-alvo processadas)
                    float progress = 0.0f;
                    if (total_training_words_estimate > 0) {
                        progress = static_cast<float>(words_processed) / total_training_words_estimate;
                    }
                    float current_lr = initial_lr * (1.0f - progress);
                    current_lr = std::max(current_lr, min_learning_rate); // Garante LR mínimo
                    // --- FIM CORREÇÃO ---

                    // Determinar janela de contexto dinâmica
                    int current_window = uniform_window(rng);

                    // Iterar sobre as posições de contexto
                    for (int j = -current_window; j <= current_window; ++j) {
                        if (j == 0) continue; // Pular a palavra-alvo

                        size_t context_pos = i + j;
                        // Verificar limites da sentença
                        if (context_pos < sentence.size()) { // size_t é sempre >= 0
                            auto context_it = word_to_index.find(sentence[context_pos]);
                            if (context_it != word_to_index.end()) {
                                int context_idx = context_it->second; // Palavra de contexto real (saída)

                                // Treinar o par (alvo -> contexto) - Passa a LR já calculada
                                trainSkipGramPair(target_idx, context_idx, current_lr);
                                pairs_trained++;
                            }
                        }
                    } // Fim do loop de contexto

                    epoch_words_processed++; // Incrementa contador da época
                    words_processed++;       // Incrementa contador GERAL

                    // Exibir progresso (opcional, pode desacelerar)
                   // Usa 'current_lr' que agora está no escopo correto
                    if (epoch_words_processed % 10000 == 0) {
                        std::cout << "\rÉpoca " << epoch + 1 << "/" << epochs
                            << ", Progresso Estimado: " << std::fixed << std::setprecision(2)
                            << 100.0f * progress << "%, LR: " << current_lr // AGORA VÁLIDO
                            << std::flush;
                    }

                } // Fim do loop da sentença
            } // Fim do loop do corpus

            // Imprime resumo da época - Recalcula a LR final aproximada da época para exibição
            float final_epoch_progress = 0.0f;
            if (total_training_words_estimate > 0) {
                final_epoch_progress = static_cast<float>(words_processed) / total_training_words_estimate;
            }
            float final_epoch_lr = std::max(initial_lr * (1.0f - final_epoch_progress), min_learning_rate);
            std::cout << "\n  Época " << epoch + 1 << "/" << epochs << " completa. Pares treinados: " << pairs_trained
                << ". LR final aprox: " << std::fixed << std::setprecision(6) << final_epoch_lr << "\n";

        } // Fim do loop das épocas
        std::cout << "Treinamento SkipGram (Softmax) concluído.\n";
    }
    
    /**
     * @brief Salva os embeddings de ENTRADA em um arquivo no formato texto Word2Vec.
     * @param filename Nome do arquivo de saída.
     * @note Salva apenas os vetores de entrada (v_w), que são tipicamente usados como embeddings.
     */
    void saveEmbeddings(const std::string& filename) const {
        std::cout << "Salvando embeddings de entrada em " << filename << "...\n";
        std::ofstream file(filename);
        if (!file.is_open()) {
            std::cerr << "Erro ao abrir arquivo para escrita: " << filename << "\n";
            return;
        }

        // Cabeçalho: número_de_palavras dimensão_vetor
        file << vocabulary.size() << " " << vector_size << "\n";

        // Linhas: palavra val1 val2 ... valN
        for (const auto& word : vocabulary) {
            file << word.word;
            for (float val : word.vector) {
                file << " " << std::fixed << std::setprecision(6) << val;
            }
            file << "\n";
        }
        file.close();
        std::cout << "Embeddings salvos com sucesso.\n";
    }

    /**
     * @brief Carrega embeddings pré-treinados de um arquivo (APENAS vetores de entrada).
     * @param filename Nome do arquivo de entrada.
     * @return True se o carregamento for bem-sucedido, false caso contrário.
     * @note Assume formato texto Word2Vec. Carrega apenas os vetores de entrada (v_w).
     * Os pesos de saída (v'_w) precisarão ser inicializados se for continuar o treinamento.
     */
    bool loadEmbeddings(const std::string& filename) {
        std::cout << "Carregando embeddings de ENTRADA de " << filename << "...\n";
        std::ifstream file(filename);
        if (!file.is_open()) {
            std::cerr << "Erro ao abrir arquivo para leitura: " << filename << "\n";
            return false;
        }

        size_t vocab_size;
        int loaded_vector_size;
        file >> vocab_size >> loaded_vector_size;

        // Verifica se a dimensão do vetor carregado corresponde à configuração do modelo
        if (file.fail() || loaded_vector_size <= 0) {
            std::cerr << "Erro ao ler cabeçalho do arquivo: " << filename << "\n";
            return false;
        }

        std::cout << "  Arquivo contém " << vocab_size << " palavras com dimensão " << loaded_vector_size << ".\n";
        // Permite carregar embeddings com dimensão diferente, ajustando o modelo
        if (loaded_vector_size != vector_size) {
            std::cout << "  Aviso: Dimensão do vetor no arquivo (" << loaded_vector_size
                << ") difere da configuração do modelo (" << vector_size
                << "). Ajustando modelo para " << loaded_vector_size << ".\n";
            vector_size = loaded_vector_size;
        }

        vocabulary.clear();
        word_to_index.clear();
        vocabulary.reserve(vocab_size);

        for (size_t i = 0; i < vocab_size; ++i) {
            Word w;
            file >> w.word;
            if (file.fail()) {
                std::cerr << "Erro ao ler palavra no índice " << i << " do arquivo.\n";
                return false;
            }
            w.vector.resize(vector_size); // Redimensiona o vetor de entrada
            for (int j = 0; j < vector_size; ++j) {
                file >> w.vector[j];
                if (file.fail()) {
                    std::cerr << "Erro ao ler valor do vetor para a palavra '" << w.word << "' no índice " << j << ".\n";
                    return false;
                }
            }
            w.count = 1; // Contagem desconhecida ao carregar
            vocabulary.push_back(w);
            word_to_index[w.word] = i;
        }
        file.close();

        // IMPORTANTE: Os pesos de SAÍDA NÃO são carregados por este método.
        // Se for continuar o treinamento, eles precisam ser (re)inicializados.
        // Vamos inicializá-los aleatoriamente aqui para permitir treinamento adicional.
        output_weights.resize(vocabulary.size(), std::vector<float>(vector_size));
        std::uniform_real_distribution<float> dist(-0.5f / vector_size, 0.5f / vector_size);
        for (size_t i = 0; i < vocabulary.size(); ++i) {
            for (int j = 0; j < vector_size; ++j) {
                output_weights[i][j] = dist(rng);
            }
        }
        total_words = vocabulary.size(); // Estimativa grosseira se não tivermos o corpus original

        std::cout << "Embeddings de ENTRADA carregados e pesos de SAÍDA (re)inicializados com sucesso.\n";
        return true;
    }


    /**
     * @brief Encontra as palavras com maior grau de similaridade a uma palavra dada usando similaridade de cosseno nos embeddings de ENTRADA.
     * @param word Palavra de consulta.
     * @param top_n Número de palavras similares a retornar (padrão: 10).
     * @return Vetor de pares (palavra, similaridade), ordenado por similaridade decrescente.
     */
    std::vector<std::pair<std::string, float>> findSimilar(const std::string& word, int top_n = 10) const {
        auto it = word_to_index.find(word);
        if (it == word_to_index.end()) {
            std::cerr << "Aviso: Palavra '" << word << "' não encontrada no vocabulário para busca de similaridade.\n";
            return {};
        }

        int word_idx = it->second;
        const auto& word_vector = vocabulary[word_idx].vector; // Usa vetor de ENTRADA (v_w)
        std::vector<std::pair<std::string, float>> similarities;
        similarities.reserve(vocabulary.size());

        for (size_t i = 0; i < vocabulary.size(); ++i) {
            if (i == word_idx) continue; // Não comparar a palavra consigo mesma
            // Compara vetores de ENTRADA (v_w com outros v_w)
            float similarity = cosineSimilarity(word_vector, vocabulary[i].vector);
            similarities.emplace_back(vocabulary[i].word, similarity);
        }

        // Ordenar por similaridade decrescente
        std::sort(similarities.begin(), similarities.end(),
            [](const auto& a, const auto& b) { return a.second > b.second; });

        // Retornar os top_n resultados
        if (similarities.size() > static_cast<size_t>(top_n)) {
            similarities.resize(top_n);
        }
        return similarities;
    }

    /**
     * @brief Calcula a similaridade de cosseno entre dois vetores.
     * @param a Primeiro vetor.
     * @param b Segundo vetor.
     * @return Valor da similaridade de cosseno [-1, 1]. Retorna 0 se uma das normas for zero.
     */
    float cosineSimilarity(const std::vector<float>& a, const std::vector<float>& b) const {
        if (a.size() != b.size() || a.empty()) {
            return 0.0f; // Vetores incompatíveis ou vazios
        }

        float dot_product = 0.0f;
        float norm_a = 0.0f;
        float norm_b = 0.0f;
        for (size_t i = 0; i < a.size(); ++i) {
            dot_product += a[i] * b[i];
            norm_a += a[i] * a[i];
            norm_b += b[i] * b[i];
        }

        // Evitar divisão por zero se um vetor for nulo (norma zero)
        norm_a = std::sqrt(norm_a);
        norm_b = std::sqrt(norm_b);
        if (norm_a < std::numeric_limits<float>::epsilon() || norm_b < std::numeric_limits<float>::epsilon()) {
            return 0.0f;
        }

        return dot_product / (norm_a * norm_b);
    }

    /**
     * @brief Realiza operações de analogia vetorial (a - b + c ≈ ?) usando os embeddings de ENTRADA.
     *
     * Calcula o vetor resultante `vec(a) - vec(b) + vec(c)` e encontra as palavras
     * cujos vetores de embedding de entrada (v_w) são mais próximos a ele via similaridade de cosseno.
     *
     * @param a Primeira palavra positiva.
     * @param b Palavra negativa.
     * @param c Segunda palavra positiva.
     * @param top_n Número de resultados a retornar (padrão: 5).
     * @return Vetor de pares (palavra, similaridade).
     */
    std::vector<std::pair<std::string, float>> analogy(const std::string& a,
        const std::string& b,
        const std::string& c,
        int top_n = 5) const {
        auto it_a = word_to_index.find(a);
        auto it_b = word_to_index.find(b);
        auto it_c = word_to_index.find(c);

        if (it_a == word_to_index.end() || it_b == word_to_index.end() || it_c == word_to_index.end()) {
            std::cerr << "Aviso: Uma ou mais palavras da analogia (" << a << ", " << b << ", " << c << ") não encontradas no vocabulário.\n";
            return {};
        }

        const auto& vec_a = vocabulary[it_a->second].vector; // Vetor de ENTRADA (v_w)
        const auto& vec_b = vocabulary[it_b->second].vector; // Vetor de ENTRADA (v_w)
        const auto& vec_c = vocabulary[it_c->second].vector; // Vetor de ENTRADA (v_w)

        std::vector<float> result_vec(vector_size);
        for (int i = 0; i < vector_size; ++i) {
            result_vec[i] = vec_a[i] - vec_b[i] + vec_c[i];
        }

        // Normalizar o vetor resultante (opcional, mas melhora a comparação por cosseno)
        float norm = 0.0f;
        for (float val : result_vec) {
            norm += val * val;
        }
        norm = std::sqrt(norm);
        if (norm > std::numeric_limits<float>::epsilon()) {
            for (float& val : result_vec) {
                val /= norm;
            }
        }

        // Encontrar palavras com maior grau de similaridade ao vetor resultante (usando vetores de ENTRADA)
        std::vector<std::pair<std::string, float>> similarities;
        similarities.reserve(vocabulary.size());
        for (size_t i = 0; i < vocabulary.size(); ++i) {
            // Não incluir as palavras de entrada na lista de resultados
            if (i == it_a->second || i == it_b->second || i == it_c->second) {
                continue;
            }
            // Compara o vetor resultante com os vetores de ENTRADA das outras palavras
            float similarity = cosineSimilarity(result_vec, vocabulary[i].vector);
            similarities.emplace_back(vocabulary[i].word, similarity);
        }

        // Ordenar e retornar top_n
        std::sort(similarities.begin(), similarities.end(),
            [](const auto& x, const auto& y) { return x.second > y.second; });
        if (similarities.size() > static_cast<size_t>(top_n)) {
            similarities.resize(top_n);
        }
        return similarities;
    }

    /**
     * @brief Retorna o vetor embedding de ENTRADA (v_w) de uma palavra.
     * @param word Palavra de consulta.
     * @return Vetor de embedding de entrada. Retorna um vetor de zeros se a palavra não for encontrada.
     */
    std::vector<float> getWordVector(const std::string& word) const {
        auto it = word_to_index.find(word);
        if (it == word_to_index.end()) {
            std::cerr << "Aviso: Palavra '" << word << "' não encontrada no vocabulário para getWordVector.\n";
            return std::vector<float>(vector_size, 0.0f);
        }
        return vocabulary[it->second].vector; // Retorna vetor de ENTRADA (v_w)
    }
};

/**
 * @brief Função principal que demonstra o uso da classe Word2Vec_SkipGram_Softmax.
 *
 * Cria um modelo SkipGram com Softmax completo, constrói o vocabulário, treina,
 * e demonstra funcionalidades como busca de similares, analogia e salvamento.
 * @note O treinamento pode ser lento devido ao Softmax completo.
 *
 * @return 0 em caso de execução bem-sucedida.
 */
int main() {
    // Configurar o console para UTF-8 (Específico do Windows)
#ifdef _WIN32
    SetConsoleOutputCP(CP_UTF8);
    std::cout << "Console configurado para UTF-8.\n";
#endif

    // Corpus simplificado (o mesmo dos exemplos anteriores)
    std::vector<std::vector<std::string>> corpus = {
        {"o", "gato", "preto", "corre", "pelo", "jardim"},
        {"o", "cachorro", "late", "para", "o", "gato"},
        {"gatos", "e", "cachorros", "são", "animais", "domésticos"},
        {"muitas", "pessoas", "gostam", "de", "ter", "um", "animal", "de", "estimação"},
        {"os", "gatos", "gostam", "de", "dormir", "durante", "o", "dia"},
        {"os", "cachorros", "precisam", "passear", "todos", "os", "dias"}
    };
    std::cout << "Corpus de exemplo carregado com " << corpus.size() << " sentenças.\n";

    // --- Criar e Treinar Modelo SkipGram (Softmax) ---
    // Usar parâmetros menores e LR possivelmente maior que NegSampling para o exemplo pequeno
    // Nota: LR de 0.05f pode ser razoável para este pequeno exemplo com Softmax.
    Word2Vec_SkipGram_Softmax model(20, 2, 0.05f); // Dimensão 20, Janela 2, LR 0.05

    // Medir Construção do Vocabulário
    auto start_vocab = std::chrono::high_resolution_clock::now();
    model.buildVocabulary(corpus);
    auto end_vocab = std::chrono::high_resolution_clock::now();
    auto duration_vocab = std::chrono::duration_cast<std::chrono::milliseconds>(end_vocab - start_vocab);
    std::cout << "Tempo de construção do vocabulário: " << duration_vocab.count() << " ms\n";

    // Medir Treinamento (Softmax será mais lento)
    int epochs_count = 100; // Pode precisar de mais épocas com Softmax em corpus pequeno
    auto start_train = std::chrono::high_resolution_clock::now();
    model.trainSkipGram(corpus, epochs_count);
    auto end_train = std::chrono::high_resolution_clock::now();
    auto duration_train = std::chrono::duration_cast<std::chrono::milliseconds>(end_train - start_train);
    std::cout << "Tempo de treinamento (" << epochs_count << " épocas): " << duration_train.count() << " ms\n";

    // --- Usar o Modelo Treinado ---

    // Encontrar palavras similares a 'gato'
    std::cout << "\n--- Palavras similares a 'gato' (SkipGram Softmax) ---\n";
    auto similar_to_cat = model.findSimilar("gato", 5);
    if (similar_to_cat.empty()) {
        std::cout << "Nenhuma palavra similar encontrada.\n";
    }
    else {
        for (const auto& [word, similarity] : similar_to_cat) {
            std::cout << "  " << word << ": " << std::fixed << std::setprecision(4) << similarity << "\n";
        }
    }

    // Encontrar palavras similares a 'cachorro'
    std::cout << "\n--- Palavras similares a 'cachorro' (SkipGram Softmax) ---\n";
    auto similar_to_dog = model.findSimilar("cachorro", 5);
    if (similar_to_dog.empty()) {
        std::cout << "Nenhuma palavra similar encontrada.\n";
    }
    else {
        for (const auto& [word, similarity] : similar_to_dog) {
            std::cout << "  " << word << ": " << std::fixed << std::setprecision(4) << similarity << "\n";
        }
    }


    // Testar analogia: gato - gatos + cachorro ≈ cachorros ?
    std::cout << "\n--- Analogia (SkipGram Softmax): gato - gatos + cachorro = ? ---\n";
    auto analogy_results = model.analogy("gato", "gatos", "cachorro", 3);
    if (analogy_results.empty()) {
        std::cout << "Não foi possível calcular a analogia.\n";
    }
    else {
        for (const auto& [word, similarity] : analogy_results) {
            std::cout << "  " << word << ": " << std::fixed << std::setprecision(4) << similarity << "\n";
        }
    }

    // Obter vetor de uma palavra específica
    std::cout << "\n--- Vetor da palavra 'animal' (SkipGram Softmax) ---\n";
    std::vector<float> vec_animal = model.getWordVector("animal");
    // Verifica se o vetor retornado não é o vetor de zeros (indicando palavra não encontrada)
    bool animal_found = false;
    for (float val : vec_animal) { if (std::abs(val) > 1e-9) { animal_found = true; break; } }

    if (animal_found) {
        std::cout << "  [";
        for (size_t i = 0; i < vec_animal.size(); ++i) {
            std::cout << std::fixed << std::setprecision(3) << vec_animal[i] << (i == vec_animal.size() - 1 ? "" : ", ");
        }
        std::cout << "]\n";
    }
    else {
        std::cout << "  Palavra 'animal' não encontrada ou vetor nulo.\n";
    }


    // Salvar os embeddings de entrada resultantes
    model.saveEmbeddings("SkipGram_softmax_word_embeddings.txt");

    std::cout << "\nExecução concluída.\n";
    return 0;
}