lltutorwindow.h

Go to the documentation of this file.

/*
 * SyntaxTutor - Interactive Tutorial About Syntax Analyzers
 * Copyright (C) 2025 Jose R. (jose-rzm)
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef LLTUTORWINDOW_H
#define LLTUTORWINDOW_H
 
#include <QAbstractItemView>
#include <QDialog>
#include <QFileDialog>
#include <QGraphicsColorizeEffect>
#include <QGraphicsScene>
#include <QGraphicsTextItem>
#include <QGraphicsView>
#include <QListWidgetItem>
#include <QMainWindow>
#include <QMessageBox>
#include <QPainter>
#include <QPropertyAnimation>
#include <QPushButton>
#include <QScrollBar>
#include <QShortcut>
#include <QTableWidget>
#include <QTextDocument>
#include <QTextEdit>
#include <QTime>
#include <QTimer>
#include <QTreeWidgetItem>
#include <QVBoxLayout>
#include <QtPrintSupport/QPrinter>
 
#include "backend/grammar.hpp"
#include "backend/ll1_parser.hpp"
#include "lltabledialog.h"
 
class TutorialManager;
 
namespace Ui {
class LLTutorWindow;
}
 
// ====== LL(1) Tutor States ===================================
enum class State { A, A1, A2, A_prime, B, B1, B2, B_prime, C, C_prime, fin };
 
// ====== LL(1) Tutor Main Class ===============================
class LLTutorWindow : public QMainWindow {
    Q_OBJECT
 
  public:
    // ====== Derivation Tree (used in TeachFirst) =============
    struct TreeNode {
        QString                                label;
        std::vector<std::unique_ptr<TreeNode>> children;
    };
 
    // ====== Constructor / Destructor =========================
    explicit LLTutorWindow(const Grammar&   grammar,
                           TutorialManager* tm     = nullptr,
                           QWidget*         parent = nullptr);
    ~LLTutorWindow();
 
    // ====== State Machine & Question Logic ====================
    QString generateQuestion();

    void updateState(bool isCorrect);

    QString FormatGrammar(const Grammar& grammar);
 
    // ====== UI Interaction ====================================
    void addMessage(const QString& text,
                    bool           isUser);           
    void addWidgetMessage(QWidget* widget); 
    void
    exportConversationToPdf(const QString& filePath); 
    void showTable();           
    void showTableForCPrime();  
    void updateProgressPanel(); // Update progress panel
 
    // ====== Visual Feedback / Animations ======================
    void animateLabelPop(QLabel* label);
    void animateLabelColor(QLabel* label, const QColor& flashColor);
    void wrongAnimation(); 
    void
    wrongUserResponseAnimation(); 
    void markLastUserIncorrect(); 
 
    // ====== Tree Generation (TeachFirst mode) =================
    void TeachFirstTree(const std::vector<std::string>&  symbols,
                        std::unordered_set<std::string>& first_set, int depth,
                        std::unordered_set<std::string>& processing,
                        QTreeWidgetItem*                 parent);
 
    std::unique_ptr<TreeNode>
    buildTreeNode(const std::vector<std::string>&  symbols,
                  std::unordered_set<std::string>& first_set, int depth,
                  std::vector<std::pair<std::string, std::vector<std::string>>>&
                      active_derivations);
 
    int  computeSubtreeWidth(const std::unique_ptr<TreeNode>& node,
                             int                              hSpacing);
    void drawTree(const std::unique_ptr<TreeNode>& root, QGraphicsScene* scene,
                  QPointF pos, int hSpacing, int vSpacing);
 
    void showTreeGraphics(
        std::unique_ptr<TreeNode> root); // Display derivation tree visually
 
    // ====== User Response Verification ========================
    bool verifyResponse(const QString& userResponse); // Delegates to current
                                                      // state's verification
    bool verifyResponseForA(const QString& userResponse);
    bool verifyResponseForA1(const QString& userResponse);
    bool verifyResponseForA2(const QString& userResponse);
    bool verifyResponseForB(const QString& userResponse);
    bool verifyResponseForB1(const QString& userResponse);
    bool verifyResponseForB2(const QString& userResponse);
    bool verifyResponseForC(); // C is non-textual (checks internal table)
 
    // ====== Expected Solutions (Auto-generated) ===============
    QString       solution(const std::string& state);
    QStringList   solutionForA();
    QString       solutionForA1();
    QString       solutionForA2();
    QSet<QString> solutionForB();
    QSet<QString> solutionForB1();
    QSet<QString> solutionForB2();
 
    // ====== Feedback (Corrective Explanations) ================
    QString feedback(); // Delegates by state
    QString feedbackForA();
    QString feedbackForA1();
    QString feedbackForA2();
    QString feedbackForAPrime();
    QString feedbackForB();
    QString feedbackForB1();
    QString feedbackForB2();
    QString feedbackForBPrime();
    QString feedbackForC();
    QString feedbackForCPrime();
    void    feedbackForB1TreeWidget();   // TreeWidget of Teach (LL1 TeachFirst)
    void    feedbackForB1TreeGraphics(); // Show derivation tree
    QString TeachFollow(const QString& nt);
    QString TeachPredictionSymbols(const QString&    ant,
                                   const production& conseq);
    QString TeachLL1Table();
 
    void handleTableSubmission(const QVector<QVector<QString>>& raw,
                               const QStringList&               colHeaders);
  private slots:
    void on_confirmButton_clicked();
    void on_userResponse_textChanged();
 
  signals:
    void sessionFinished(int cntRight, int cntWrong);
 
  protected:
    void closeEvent(QCloseEvent* event) override {
        emit sessionFinished(cntRightAnswers, cntWrongAnswers);
        QWidget::closeEvent(event);
    }
 
    bool eventFilter(QObject* obj, QEvent* event) override;
 
  private:
    // ====== Core Objects ======================================
    Ui::LLTutorWindow* ui;
    Grammar            grammar;
    LL1Parser          ll1;
 
    // ====== State & Grammar Tracking ==========================
    State          currentState;
    size_t         currentRule        = 0;
    const unsigned kMaxHighlightTries = 3;
    const unsigned kMaxTotalTries     = 5;
    unsigned       lltries            = 0;
    unsigned       cntRightAnswers = 0, cntWrongAnswers = 0;
 
    using Cell = std::pair<QString, QString>;
    std::vector<Cell> lastWrongCells;
    LLTableDialog*    currentDlg = nullptr;
 
    QVector<QString>                          sortedNonTerminals;
    QVector<QPair<QString, QVector<QString>>> sortedGrammar;
    QString                                   formattedGrammar;
 
    QMap<QString, QMap<QString, QVector<QString>>> lltable;
    QVector<QVector<QString>>                      rawTable;
    QSet<QString>                                  solutionSet;
 
    // ====== Conversation Logging ==============================
    struct MessageLog {
        QString message;
        bool    isUser;
        bool    isCorrect = true;
        MessageLog(const QString& message, bool isUser)
            : message(message), isUser(isUser) {}
        void toggleIsCorrect() { isCorrect = false; }
    };
 
    QVector<MessageLog> conversationLog;
    QWidget*            lastUserMessage       = nullptr;
    qsizetype           lastUserMessageLogIdx = -1;
 
    QMap<QString, QString> userCAB;
    QMap<QString, QString> userSIG;
    QMap<QString, QString> userSD;
 
    // ====== Helper Conversions ================================
    std::vector<std::string> qvectorToStdVector(const QVector<QString>& qvec);
    QVector<QString> stdVectorToQVector(const std::vector<std::string>& vec);
    QSet<QString>
    stdUnorderedSetToQSet(const std::unordered_set<std::string>& uset);
    std::unordered_set<std::string>
    qsetToStdUnorderedSet(const QSet<QString>& qset);
 
    void setupTutorial();
 
    void
    fillSortedGrammar(); // Populate sortedGrammar from internal representation
 
    QPropertyAnimation* m_shakeAnimation =
        nullptr; // For interrupting userResponse animation if they spam enter
                 // key
 
    TutorialManager* tm = nullptr;
 
    QRegularExpression re{"^\\s+|\\s+$"};
};
 
#endif // LLTUTORWINDOW_H