import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors; 

public class ChatbotGUI extends JFrame implements ActionListener {

    private JTextArea chatArea;
    private JTextField inputField;
    private KnowledgeBase knowledgeBase;
    
    // NEU: Dedizierte Info-Box für Systemmeldungen
    private JTextArea systemInfoArea; 
    
    private static final Pattern TITLE_EXTRACT_PATTERN = Pattern.compile("^TITEL:\\s*(.*)", Pattern.MULTILINE);
    private static final Pattern SCORE_EXTRACT_PATTERN = Pattern.compile("\\[Übereinstimmung: ([0-9]+\\.[0-9]+)%%\\]"); 
    private static final Pattern FILE_SCORE_EXTRACT_PATTERN = Pattern.compile("^SCORE:\\s*(\\d+)", Pattern.MULTILINE); 
    
    private JList<String> docList;
    private DefaultListModel<String> listModel;
    private JTextArea editContentArea;
    private JTextField editTitleField;
    private JTextField editTagsField;
    private JTextField editScoreField; 
    private JButton saveEditButton;
    private JButton deleteButton;
    private JButton reloadButton; 
    
    private List<Map<String, String>> currentEditableDocs; 
    
    // Felder für die Score-Anpassung (Dropdown)
    private JComboBox<String> scoreDropdown;
    private JButton scoreSubmitButton; 
    private List<String> currentFoundTitles; 
    
    // NEU: Speichert die letzte Suchanfrage für das Score-Feedback
    private String lastSearchQuery = ""; 

    // NEU: Speichert die letzte Benutzer-Suchanfrage für systemInfoArea
    private String currentInfoBoxUserQuery = ""; 

    public ChatbotGUI() {
        super("Lokale Wissensdatenbank");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(1000, 700);
        setLocationRelativeTo(null);
        setResizable(false); 

        this.knowledgeBase = new KnowledgeBase();
        
        JTabbedPane tabbedPane = new JTabbedPane();
        tabbedPane.addTab("🔍 Chat / Suche", createChatPanel());
        tabbedPane.addTab("📚 Wissen pflegen", createKnowledgeManagementPanel());
        
        add(tabbedPane, BorderLayout.CENTER);
        
        displayMessage("SYSTEM", "Anwendung gestartet. Die Wissensdatenbank ist betriebsbereit.");

        setVisible(true);
        loadDocumentsForManagement();
    }
    
    private JPanel createChatPanel() {
        JPanel chatPanel = new JPanel(new BorderLayout());
        
        // --- System Info Area (die zusätzliche Info Box) ---
        systemInfoArea = new JTextArea(3, 50);
        systemInfoArea.setEditable(false);
        systemInfoArea.setLineWrap(true);
        systemInfoArea.setWrapStyleWord(true);
        systemInfoArea.setFont(new Font("Monospaced", Font.BOLD, 12));
        systemInfoArea.setBackground(new Color(255, 255, 220)); // Helles Gelb für optische Trennung
        systemInfoArea.setBorder(BorderFactory.createTitledBorder("System-Status / Letzte Meldung"));
        JScrollPane systemInfoScroll = new JScrollPane(systemInfoArea);
        systemInfoScroll.setPreferredSize(new Dimension(systemInfoScroll.getPreferredSize().width, 75)); // Feste Höhe

        chatPanel.add(systemInfoScroll, BorderLayout.NORTH); // Platziere die Info-Box oben
        // --- Ende System Info Area ---
        
        
        chatArea = new JTextArea();
        chatArea.setEditable(false);
        chatArea.setLineWrap(true);
        chatArea.setWrapStyleWord(true);
        chatArea.setFont(new Font("Monospaced", Font.PLAIN, 14));
        JScrollPane scrollPane = new JScrollPane(chatArea);
        
        chatPanel.add(scrollPane, BorderLayout.CENTER); // Main Chat Area in der Mitte

        inputField = new JTextField(50);
        inputField.addActionListener(this);
        
        JButton sendButton = new JButton("Senden");
        sendButton.addActionListener(this);
        
        JPanel inputPanel = new JPanel(new BorderLayout());
        inputPanel.add(inputField, BorderLayout.CENTER);
        inputPanel.add(sendButton, BorderLayout.EAST);

        // Score Adjustment Panel
        JPanel adjustmentPanel = createScoreAdjustmentPanel();

        JPanel southPanel = new JPanel(new BorderLayout());
        southPanel.add(adjustmentPanel, BorderLayout.NORTH); 
        southPanel.add(inputPanel, BorderLayout.SOUTH); 

        chatPanel.add(southPanel, BorderLayout.SOUTH);
        
        return chatPanel;
    }

    // Methode für das Score Adjustment Panel
    private JPanel createScoreAdjustmentPanel() {
        JPanel panel = new JPanel(new FlowLayout(FlowLayout.LEFT, 5, 5));
        panel.setBorder(BorderFactory.createTitledBorder("Score-Anpassung der aktuellen Ergebnisse"));

        scoreDropdown = new JComboBox<>();
        scoreDropdown.setPreferredSize(new Dimension(500, scoreDropdown.getPreferredSize().height));
        scoreDropdown.addItem("Bitte zuerst eine Suche starten..."); 
        
        scoreSubmitButton = new JButton("Bestätigen und Score erhöhen (+5)");
        scoreSubmitButton.addActionListener(e -> handleScoreAdjustment());
        scoreSubmitButton.setEnabled(false); // Anfangs deaktiviert

        panel.add(new JLabel("Betroffenes Dokument wählen:"));
        panel.add(scoreDropdown);
        panel.add(scoreSubmitButton);

        return panel;
    }
    
    // Methode zum Füllen des Dropdowns
    private void populateScoreDropdown(List<String> foundAnswers) {
        scoreDropdown.removeAllItems();
        currentFoundTitles = new ArrayList<>();

        // 1. Dropdown mit allen gültigen Titeln aus den Suchergebnissen befüllen
        if (foundAnswers != null) {
            for (String fullAnswer : foundAnswers) {
                 Matcher titleMatcher = TITLE_EXTRACT_PATTERN.matcher(fullAnswer);
                 Matcher scoreMatcher = FILE_SCORE_EXTRACT_PATTERN.matcher(fullAnswer);
                 
                 String title = titleMatcher.find() ? titleMatcher.group(1).trim() : "UNBEKANNT";
                 String score = scoreMatcher.find() ? scoreMatcher.group(1).trim() : "?";

                 if (!title.equals("UNBEKANNT")) {
                     // Format: "Title (SCORE: X)"
                     scoreDropdown.addItem(String.format("%s (SCORE: %s)", title, score));
                     currentFoundTitles.add(title); // Speichert den reinen Titel für handleScoreAdjustment
                 }
            }
        }
        
        // 2. Button-Status basierend auf der Anzahl der Titel festlegen
        if (currentFoundTitles.size() < 2) {
             scoreSubmitButton.setEnabled(false);
             
             // Benutzerführung: Dropdown-Inhalt anpassen, wenn 0 oder 1 Ergebnis gefunden wurde
             String message;
             if (currentFoundTitles.isEmpty()) {
                 message = "Keine Suchergebnisse gefunden.";
             } else {
                 // Ein einziges Ergebnis wurde hinzugefügt (z.B. nach Dominanzfilterung), dies entfernen
                 String singleResult = (String) scoreDropdown.getItemAt(0); 
                 scoreDropdown.removeAllItems(); 
                 // Neues Element hinzufügen, das den Deaktivierungsgrund erklärt und das gefundene Ergebnis nennt
                 // Nur den Titel ohne (SCORE: X) anzeigen
                 String titleOnly = singleResult.substring(0, singleResult.lastIndexOf(" (SCORE:")).trim();
                 message = "Score-Anpassung deaktiviert: Nur 1 relevantes Dokument (" + titleOnly + ")";
             }
             scoreDropdown.addItem(message);
        } else {
             scoreSubmitButton.setEnabled(true);
        }
    }

    // Methode zur Behandlung des Score-Updates
    private void handleScoreAdjustment() {
        String selectedItem = (String) scoreDropdown.getSelectedItem();
        if (selectedItem == null || selectedItem.isEmpty() || selectedItem.startsWith("Score-Anpassung deaktiviert") || selectedItem.startsWith("Keine Suchergebnisse")) {
            displayMessage("SYSTEM", "FEHLER: Bitte wählen Sie ein gültiges Dokument aus der Liste aus.");
            return;
        }

        // Titel extrahieren: Alles vor " (SCORE:"
        int titleEndIndex = selectedItem.lastIndexOf(" (SCORE:");
        String selectedTitle = selectedItem;
        if (titleEndIndex != -1) {
            selectedTitle = selectedItem.substring(0, titleEndIndex).trim();
        }
        
        if (!selectedTitle.isEmpty() && !selectedTitle.equals("UNBEKANNT")) {
            // Aufruf der Logik in KnowledgeBase, Übergabe der letzten Suchanfrage
            String result = knowledgeBase.adjustDocumentScore(selectedTitle, lastSearchQuery); 
            displayMessage("SYSTEM", result);
            
            // Dropdown leeren und deaktivieren, um eine Neusuche zu erzwingen 
            scoreDropdown.removeAllItems();
            scoreDropdown.addItem("Score angepasst. Neue Suche starten, um aktualisierte Scores zu sehen.");
            scoreSubmitButton.setEnabled(false);

        } else {
            displayMessage("SYSTEM", "FEHLER: Es konnte kein gültiger Titel für das Feedback ermittelt werden.");
        }
    }


    private JPanel createKnowledgeManagementPanel() {
        JPanel mainPanel = new JPanel(new BorderLayout(10, 10));
        mainPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));

        listModel = new DefaultListModel<>();
        docList = new JList<>(listModel);
        docList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        docList.addListSelectionListener(e -> {
            if (!e.getValueIsAdjusting() && docList.getSelectedIndex() != -1) {
                loadSelectedDocumentForEdit(docList.getSelectedIndex());
            }
        });
        
        reloadButton = new JButton("Wissen neu laden (von Datei)"); 
        reloadButton.addActionListener(e -> {
            loadDocumentsForManagement();
            displayMessage("SYSTEM", "Wissensliste aus 'knowledge.txt' neu geladen.");
        });
        
        JPanel listControlPanel = new JPanel(new BorderLayout());
        listControlPanel.add(new JLabel("Liste der Dokumente:"), BorderLayout.NORTH);
        listControlPanel.add(new JScrollPane(docList), BorderLayout.CENTER);
        listControlPanel.add(reloadButton, BorderLayout.SOUTH); 
        
        listControlPanel.setPreferredSize(new Dimension(300, 600));

        editTitleField = new JTextField();
        editTagsField = new JTextField();
        editScoreField = new JTextField(); 
        editContentArea = new JTextArea();
        editContentArea.setLineWrap(true);
        editContentArea.setWrapStyleWord(true);
        JScrollPane editContentScroll = new JScrollPane(editContentArea);
        
        saveEditButton = new JButton("Änderungen speichern");
        saveEditButton.addActionListener(this::saveEditedDocument);
        
        deleteButton = new JButton("DOKUMENT LÖSCHEN");
        deleteButton.setBackground(Color.RED);
        deleteButton.setForeground(Color.WHITE);
        deleteButton.addActionListener(this::deleteDocument);

        JPanel buttonPanel = new JPanel(new GridLayout(1, 2, 10, 0));
        buttonPanel.add(saveEditButton);
        buttonPanel.add(deleteButton);
        
        JPanel fieldPanel = new JPanel(new GridLayout(3, 2, 5, 5)); 
        fieldPanel.add(new JLabel("Titel:"));
        fieldPanel.add(editTitleField);
        fieldPanel.add(new JLabel("Tags (kommasepariert):"));
        fieldPanel.add(editTagsField);
        fieldPanel.add(new JLabel("SCORE:")); 
        fieldPanel.add(editScoreField); 
        
        JPanel editPanel = new JPanel(new BorderLayout(5, 5));
        editPanel.add(fieldPanel, BorderLayout.NORTH);
        editPanel.add(editContentScroll, BorderLayout.CENTER);
        editPanel.add(buttonPanel, BorderLayout.SOUTH);
        editPanel.setBorder(BorderFactory.createTitledBorder("Dokument bearbeiten"));
        
        JPanel addPanel = createAddKnowledgePanel();
        
        JSplitPane rightSplit = new JSplitPane(JSplitPane.VERTICAL_SPLIT, editPanel, addPanel);
        rightSplit.setResizeWeight(0.7); 
        
        JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, listControlPanel, rightSplit); 
        splitPane.setDividerLocation(300);

        mainPanel.add(splitPane, BorderLayout.CENTER);
        
        return mainPanel;
    }
    
    private JPanel createAddKnowledgePanel() {
        JPanel panel = new JPanel(new BorderLayout());
        panel.setBorder(BorderFactory.createTitledBorder("Neues Wissen hinzufügen"));

        JTextField titleField = new JTextField(20);
        JTextField tagsField = new JTextField(20);
        JTextArea contentArea = new JTextArea(5, 20);
        contentArea.setLineWrap(true);
        contentArea.setWrapStyleWord(true);
        JScrollPane contentScroll = new JScrollPane(contentArea);
        JButton saveButton = new JButton("Neues Dokument speichern");

        saveButton.addActionListener(e -> {
            String title = titleField.getText().trim();
            String tags = tagsField.getText().trim();
            String content = contentArea.getText().trim();

            if (!title.isEmpty() && !content.isEmpty()) {
                knowledgeBase.saveNewDocument(title, tags, content); 
                titleField.setText("");
                tagsField.setText("");
                contentArea.setText("");
                loadDocumentsForManagement();
                displayMessage("SYSTEM", "Wissensdokument '" + title + "' gespeichert.");
            } else {
                JOptionPane.showMessageDialog(this, "Titel und Inhalt dürfen nicht leer sein.", "Fehler", JOptionPane.ERROR_MESSAGE);
            }
        });

        JPanel fieldPanel = new JPanel(new GridLayout(2, 2, 5, 5));
        fieldPanel.add(new JLabel("Titel:"));
        fieldPanel.add(titleField);
        fieldPanel.add(new JLabel("Tags:"));
        fieldPanel.add(tagsField);

        panel.add(fieldPanel, BorderLayout.NORTH);
        panel.add(contentScroll, BorderLayout.CENTER);
        panel.add(saveButton, BorderLayout.SOUTH);
        return panel;
    }
    
    /**
     * Methode zum Anzeigen der Nachricht. System-Meldungen erscheinen nur in der Info-Box,
     * kombiniert mit der letzten Benutzeranfrage, falls vorhanden.
     */
    private void displayMessage(String sender, String message) {
        
        String infoBoxMessage;

        // --- Systemmeldungen nur in die Info-Box (und beende die Methode) ---
        if ("SYSTEM".equalsIgnoreCase(sender)) {
            String cleanMessage = message.replaceAll("\\*\\*", "");
            
            // FÜGE SYSTEM-STATUS VOR DER LETZTEN AKTION EIN
            infoBoxMessage = String.format("[%tH:%<tM] SYSTEM: %s\n%s", 
                                            new Date(),                 
                                            cleanMessage,               
                                            currentInfoBoxUserQuery);   
            systemInfoArea.setText(infoBoxMessage.trim()); 
            return; 
        }

        // --- Benutzermeldungen (BENUTZER) nur in die Info-Box ---
        if ("BENUTZER".equalsIgnoreCase(sender)) {
            // Benutzernachrichten als 'Letzte Aktion' in die Info-Box speichern
            currentInfoBoxUserQuery = String.format("LETZTE AKTION (Suche): %s", message);
            
            // Setze die Info-Box nur auf die Aktion, bis das Ergebnis kommt
            systemInfoArea.setText(String.format("[%tH:%tM] %s", new Date(), new Date(), currentInfoBoxUserQuery));
            return; 
        }
        
        // --- Fallback für andere Sender (falls nicht SYSTEM oder BENUTZER) in die chatArea ---
        String formattedMessage = String.format("[%s @ %tH:%tM] %s\n\n", sender, new Date(), new Date(), message);
        chatArea.append(formattedMessage);
        chatArea.setCaretPosition(chatArea.getDocument().getLength());
    }

    private void loadDocumentsForManagement() {
        currentEditableDocs = knowledgeBase.loadDocumentsForEditing();
        listModel.clear();
        for (Map<String, String> doc : currentEditableDocs) {
            listModel.addElement(doc.get("title"));
        }
    }
    
    private void loadSelectedDocumentForEdit(int selectedIndex) {
        if (selectedIndex != -1) {
            Map<String, String> selectedDoc = currentEditableDocs.get(selectedIndex);
            editTitleField.setText(selectedDoc.get("title"));
            editTagsField.setText(selectedDoc.get("tags"));
            editScoreField.setText(selectedDoc.get("score")); 
            editContentArea.setText(selectedDoc.get("content"));
            saveEditButton.setEnabled(true);
            deleteButton.setEnabled(true);
        }
    }
    
    private void saveEditedDocument(ActionEvent e) {
        int selectedIndex = docList.getSelectedIndex();
        if (selectedIndex != -1) {
            String newTitle = editTitleField.getText().trim();
            String newTags = editTagsField.getText().trim();
            String newScore = editScoreField.getText().trim(); 
            String newContent = editContentArea.getText().trim();
            
            if (!newTitle.isEmpty() && !newContent.isEmpty() && newScore.matches("\\d+")) { 
                Map<String, String> docToUpdate = currentEditableDocs.get(selectedIndex);
                docToUpdate.put("title", newTitle);
                docToUpdate.put("tags", newTags);
                docToUpdate.put("score", newScore); 
                docToUpdate.put("content", newContent);
                
                knowledgeBase.saveAllDocuments(currentEditableDocs);
                
                listModel.setElementAt(newTitle, selectedIndex);
                displayMessage("SYSTEM", "Dokument '" + newTitle + "' erfolgreich gespeichert/aktualisiert.");
            } else {
                JOptionPane.showMessageDialog(this, "Titel, Inhalt und SCORE (muss eine Zahl sein) dürfen nicht leer sein.", "Fehler", JOptionPane.ERROR_MESSAGE);
            }
        }
    }

    private void deleteDocument(ActionEvent e) {
        int selectedIndex = docList.getSelectedIndex();
        if (selectedIndex != -1) {
            String titleToDelete = listModel.getElementAt(selectedIndex);
            int confirm = JOptionPane.showConfirmDialog(this, 
                "Soll das Dokument '" + titleToDelete + "' wirklich gelöscht werden?", 
                "Dokument löschen", JOptionPane.YES_NO_OPTION);
            
            if (confirm == JOptionPane.YES_OPTION) {
                currentEditableDocs.remove(selectedIndex);
                
                knowledgeBase.saveAllDocuments(currentEditableDocs);
                
                listModel.remove(selectedIndex);
                editTitleField.setText("");
                editTagsField.setText("");
                editScoreField.setText(""); 
                editContentArea.setText("");
                saveEditButton.setEnabled(false);
                deleteButton.setEnabled(false);
                displayMessage("SYSTEM", "Dokument '" + titleToDelete + "' erfolgreich gelöscht.");
            }
        }
    }
    
    /**
     * HILFSMETHODE: Erstellt einen dynamischen Trennstrich basierend auf der Breite der chatArea.
     * Der Zähler für '=' wird um +2 erhöht, wie gewünscht.
     */
    private String createDynamicSeparator() {
        // 1. Breite der Komponente abrufen
        int usableWidth = chatArea.getWidth();
        // Fallback-Wert für den Fall, dass die Breite noch nicht initialisiert ist
        if (usableWidth <= 0) { 
            usableWidth = 800; 
        }

        // 2. FontMetrics abrufen, um die Zeichenbreite zu ermitteln
        Graphics g = chatArea.getGraphics();
        
        int charWidth = 9; // Fallback-Breite für Monospaced 14pt
        if (g != null) {
            FontMetrics fm = g.getFontMetrics(chatArea.getFont());
            if (fm != null) {
                // Die Breite des breitesten Zeichens ('W') verwenden
                charWidth = fm.charWidth('W'); 
            }
        }

        // 3. Anzahl der Zeichen berechnen, die in die Breite passen
        // Subtrahieren eines kleinen Margins (z.B. 20 Pixel) für Scrollbalken/Padding
        int estimatedColumns = (usableWidth - 20) / charWidth;
        
        // 4. Sicherstellen einer Mindestbreite UND HINZUFÜGEN VON +2 ZEICHEN
        estimatedColumns = Math.max(50, estimatedColumns) + 2; 
        
        // 5. String mit '=' Zeichen erzeugen
        StringBuilder sb = new StringBuilder();
        for (int j = 0; j < estimatedColumns; j++) {
            sb.append('=');
        }

        return sb.toString() + "\n\n";
    }

    /**
     * Methode zum Anzeigen der Top-N-Ergebnisse in der chatArea.
     */
    private void displayMultipleAnswers(List<String> answers) {
        
        if (answers.size() == 1 && answers.get(0).startsWith("FEHLER")) {
            // FEHLER-Meldungen müssen über displayMessage("SYSTEM", ...) gehen, um die Query zu erhalten
            displayMessage("SYSTEM", answers.get(0)); 
            populateScoreDropdown(new ArrayList<>());
            return;
        }
        
        List<String> answersToDisplay = answers;
        String systemFeedback = null;
        
        // --- LOGIK: 2. PRÜFUNG (ABSOLUTE DOMINANZ-FILTERUNG mit 20 Punkten auf dem manuellen SCORE) ---
        if (answers.size() >= 2) {
            
            // 1. Manuelle Scores (SCORE: XX) als Integer extrahieren
            List<Integer> fileScores = answers.stream()
                .map(fullAnswer -> {
                    Matcher m = FILE_SCORE_EXTRACT_PATTERN.matcher(fullAnswer);
                    if (m.find()) {
                        try {
                            return Integer.parseInt(m.group(1)); 
                        } catch (NumberFormatException ex) {
                            return 0;
                        }
                    }
                    return 0;
                })
                .collect(Collectors.toList());

            int topScore = fileScores.get(0);
            int highestCompetingScore = fileScores.get(1); 
            int dominanceDifference = topScore - highestCompetingScore; 
            
            final int ABSOLUTE_DOMINANCE_DIFFERENCE = 20; 

            boolean triggerFilter = false;
            
            // PRÜFUNG: Ist die absolute Differenz >= 20 Punkte?
            if (dominanceDifference >= ABSOLUTE_DOMINANCE_DIFFERENCE) { 
                triggerFilter = true;
                systemFeedback = String.format("AUTOMATISCHE FILTERUNG: Erste Antwort (SCORE %d) wurde wegen einer **Dominanz von %d Punkten (>= %d)** über den nächstbesten Score (%d) direkt angezeigt.", 
                    topScore, dominanceDifference, ABSOLUTE_DOMINANCE_DIFFERENCE, highestCompetingScore);
            }
            
            if (triggerFilter) {
                // Nur die EINE beste Antwort anzeigen
                answersToDisplay = answers.subList(0, 1);
            } else {
                 // Alle (maximal 3) Antworten anzeigen
                 systemFeedback = String.format("Mehrere relevante Antworten (SCORE-Dominanz nur %d Punkte, d.h. Differenz < %d Punkte)", 
                     dominanceDifference, ABSOLUTE_DOMINANCE_DIFFERENCE);
            }
        } else {
            systemFeedback = "Die besten Antworten wurden bereitgestellt.";
        }
        // --- ENDE LOGIK ---

        // Dropdown mit den angezeigten Titeln befüllen und Button-Status setzen
        populateScoreDropdown(answersToDisplay);

        // System-Feedback in der systemInfoArea anzeigen (nutzt displayMessage("SYSTEM", ...) )
        if (systemFeedback != null) {
             displayMessage("SYSTEM", systemFeedback);
        }
        
        // Dynamisch berechneter Doppelstrich-Trenner
        String dynamicSeparator = createDynamicSeparator(); 


        // Zeige die (gefilterten) Ergebnisse einzeln in der chatArea an
        for (int i = 0; i < answersToDisplay.size(); i++) {
            String fullAnswer = answersToDisplay.get(i);
            
            // --- LOGIK FÜR NUR TITEL UND INHALT ---
            String rawContent = fullAnswer.split("---ENDE-ANTWORT---")[0].trim();

            // 1. Titelzeile extrahieren (TITEL: ...)
            Matcher titleMatcher = TITLE_EXTRACT_PATTERN.matcher(rawContent);
            String titleLine = titleMatcher.find() ? titleMatcher.group(0).trim() : "TITEL: UNBEKANNT";

            String contentOnly = rawContent;

            // Finde das Ende der Metadaten-Sektion (nach der letzten Zeile SCORE: XX)
            Pattern scoreLinePattern = Pattern.compile("^SCORE:\\s*\\d+$", Pattern.MULTILINE);
            Matcher scoreLineMatcher = scoreLinePattern.matcher(rawContent);
            int lastMetadataEnd = -1;
            
            // Suchen wir nach dem Ende der SCORE-Zeile
            while(scoreLineMatcher.find()) {
                lastMetadataEnd = scoreLineMatcher.end();
            }

            if (lastMetadataEnd != -1) {
                // Alles nach der letzten Metadaten-Zeile ist der eigentliche Inhalt
                contentOnly = rawContent.substring(lastMetadataEnd).trim();
            } else {
                // Fallback: Entferne bekannte Metadatenzeilen
                contentOnly = rawContent.replaceFirst("TITEL:\\s*.*\\n?", "").trim();
                contentOnly = contentOnly.replaceAll("^TAGS:\\s*.*\\n?", "").trim();
                contentOnly = contentOnly.replaceAll("\\[Übereinstimmung: [0-9]+\\.[0-9]+%%\\]\\n?", "").trim();
                contentOnly = contentOnly.replaceAll("^SCORE:\\s*.*\\n?", "").trim();
                
                if (titleLine.startsWith("TITEL:") && !contentOnly.isEmpty()) {
                    contentOnly = titleLine + "\n" + contentOnly;
                    titleLine = "";
                }
            }
            
            // Setze den anzuzeigenden Inhalt zusammen: Nur Titel und reiner Inhalt.
            String displayContent;
            if (titleLine.isEmpty()) {
                displayContent = contentOnly;
            } else {
                displayContent = String.format("%s\n%s", titleLine, contentOnly);
            }
            // --- ENDE LOGIK ---
            
            // Formatierung für die chatArea
            // Füge den NEUEN Trennbalken NUR ZWISCHEN den Antworten ein (nicht nach der letzten)
            String formattedResult = String.format("%s\n\n%s", displayContent, 
                                                   (i < answersToDisplay.size() - 1 ? dynamicSeparator : ""));
            
            // Füge das Ergebnis zur chatArea hinzu
            chatArea.append(formattedResult); 
        }
        
        chatArea.setCaretPosition(chatArea.getDocument().getLength());
    }


    @Override
    public void actionPerformed(ActionEvent e) {
        String userInput = inputField.getText().trim();
        if (!userInput.isEmpty()) {
            
            // NEU: Speichert die letzte Suchanfrage für das Score-Feedback
            lastSearchQuery = userInput; 
            
            // chatArea leeren, bevor neue Nachrichten hinzugefügt werden
            chatArea.setText(""); 
            
            displayMessage("BENUTZER", userInput); // Aktualisiert NUR systemInfoArea (mit der Query)
            
            List<String> answers = knowledgeBase.findBestAnswer(userInput); 
            
            displayMultipleAnswers(answers); // Aktualisiert systemInfoArea (mit SYSTEM-Status + Query) und chatArea (mit Ergebnissen)
            inputField.setText("");
        }
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(ChatbotGUI::new);
    }
}