path: root/calendar_gui.py

import sys
from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, 
                             QLabel, QLineEdit, QPushButton, QDateEdit, QTableWidget, 
                             QTableWidgetItem, QHeaderView, QDialog, QFormLayout, QComboBox,
                             QMessageBox, QSpinBox, QAction, QFileDialog, QMenuBar, QTextEdit,
                             QAbstractItemView)
from PyQt5.QtCore import Qt, QDate, QLocale
from PyQt5.QtGui import QFont, QFontDatabase
from datetime import datetime, timedelta
from dateutil.relativedelta import relativedelta

from calendar_manager import CalendarManager
from date_calculator import DateCalculator
from prediction_controller import PredictionController
from event_type_handler import EventTypeHandler
from date_service import DateService
from config import EventConfig

class EventDialog(QDialog):
    def __init__(self, entry=None, parent=None):
        super().__init__(parent)
        
        self.entry = entry
        self.dateformat = EventConfig.DATE_FORMAT

        # Set title based on mode
        self.setWindowTitle("Neuer Eintrag" if not entry else "Eintrag editieren")                                                                     
        self.init_ui()
        
    def init_ui(self):
        layout = QFormLayout()
        
        # Apply Arial font
        font = QFont("Arial", 12)
        self.setFont(font) 
        
        # Start date selector
        self.start_date = QDateEdit()
        self.start_date.setCalendarPopup(True)
        self.start_date.setFont(font)
        self.start_date.setDisplayFormat(self.dateformat)
        
        # Set initial date based on mode
        if self.entry:
            entry_start = QDate(self.entry.start_date.year, 
                               self.entry.start_date.month, 
                               self.entry.start_date.day)
            self.start_date.setDate(entry_start)
        else:
            self.start_date.setDate(QDate.currentDate())
                                            
        
        # Connect start date change to validate end date
        self.start_date.dateChanged.connect(self.validate_end_date)
        
        layout.addRow("Startdatum:", self.start_date)
        
        # End date selector
        self.end_date = QDateEdit()
        self.end_date.setCalendarPopup(True)
        self.end_date.setFont(font)
        self.end_date.setDisplayFormat(self.dateformat)
        
        # Set initial date based on mode
        if self.entry:
            entry_end = QDate(self.entry.end_date.year, 
                             self.entry.end_date.month, 
                             self.entry.end_date.day)
            self.end_date.setDate(entry_end)
        else:
            self.end_date.setDate(QDate.currentDate().addDays(1))
        
        layout.addRow("Enddatum:", self.end_date)
        
        # Keyword selector
        self.keyword = QComboBox()
        self.keyword.setFont(font)
        self.keyword.addItems(EventConfig.KEYWORDS)
        
        # Set initial keyword based on mode
        if self.entry and self.entry.keyword in EventConfig.KEYWORDS:
            current_index = EventConfig.KEYWORDS.index(self.entry.keyword)
            self.keyword.setCurrentIndex(current_index)
            
        self.keyword.currentTextChanged.connect(self.on_keyword_changed)
        layout.addRow("Art:", self.keyword)
        
        # Commentary input
        self.commentary_input = QTextEdit()
        self.commentary_input.setFont(font)
        self.commentary_input.setFixedHeight(80)
        if self.entry and hasattr(self.entry, 'commentary') and self.entry.commentary:
            self.commentary_input.setPlainText(self.entry.commentary)
        layout.addRow("Kommentar:", self.commentary_input)
        
        # Store layout for later access
        self.layout = layout
        self.end_date_row = 1  # Index of end date row in the form layout
        
        # Buttons
        button_layout = QHBoxLayout()
        self.save_button = QPushButton("Speichern")
        self.save_button.setFont(font)
        self.save_button.clicked.connect(self.accept)
        
        self.cancel_button = QPushButton("Abbrechen")
        self.cancel_button.setFont(font)
        self.cancel_button.clicked.connect(self.reject)
        
        button_layout.addWidget(self.save_button)
        button_layout.addWidget(self.cancel_button)
        layout.addRow("", button_layout)
        
        self.setLayout(layout)
        
        # Connect end date change to validate start date (keep range consistent both ways)
        self.end_date.dateChanged.connect(self.validate_start_date)

        # Handle initial keyword selection
        self.on_keyword_changed(self.keyword.currentText())
        
    def on_keyword_changed(self, keyword):
        """Handle visibility of the end_date field based on keyword"""
        # Get the widgets from the form layout
        end_date_label = self.layout.itemAt(self.end_date_row, QFormLayout.LabelRole).widget()
        end_date_field = self.layout.itemAt(self.end_date_row, QFormLayout.FieldRole).widget()
        
        if EventTypeHandler.should_hide_end_date_input(keyword):
            # Hide end date field for EZ pauschals since they have fixed duration
            end_date_label.setVisible(False)
            end_date_field.setVisible(False)
            
            # Update end date automatically if changing to EZ pauschal
            start_dt = self.start_date.date().toPyDate()
            end_dt = EventTypeHandler.get_duration_for_type(keyword, start_dt)
            self.end_date.setDate(QDate(end_dt.year, end_dt.month, end_dt.day))
        else:
            # Show end date field for other event types
            end_date_label.setVisible(True)
            end_date_field.setVisible(True)
            
    def validate_end_date(self):
        """Ensure end date is not before start date"""
        if self.end_date.date() < self.start_date.date():
            self.end_date.setDate(self.start_date.date())

    def validate_start_date(self):
        """Ensure start date is not after end date when end changes"""
        if self.start_date.date() > self.end_date.date():
            self.start_date.setDate(self.end_date.date())
    def get_data(self):
        start_date = DateService.format_date_for_iso(self.start_date.date())
        keyword = self.keyword.currentText()
        commentary = self.commentary_input.toPlainText().strip()
        
        if EventTypeHandler.should_hide_end_date_input(keyword):
            # For EZ pauschals, calculate end date automatically
            start_dt = DateService.parse_date_from_string(start_date)
            end_dt = EventTypeHandler.get_duration_for_type(keyword, start_dt)
            end_date = DateService.format_date_for_iso(end_dt)
        else:
            end_date = DateService.format_date_for_iso(self.end_date.date())
        return start_date, end_date, keyword, commentary


class CalendarManagerGUI(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Ausfallzeitenrechner")
        self.setMinimumSize(800, 600)
        
        # Set application font
        self.app_font = QFont("Arial", 12)
        QApplication.setFont(self.app_font)
        
        # Get system locale for consistent date formatting
        self.locale = QLocale.system()
        self.dateformat = EventConfig.DATE_FORMAT
        
        # Initialize backend components
        self.calendar_manager = CalendarManager()
        self.date_calculator = DateCalculator()
        self.prediction_controller = PredictionController(
            self.calendar_manager, 
            self.date_calculator
        )
        
        self.init_ui()
        self.create_menus()
        
    def create_menus(self):
        # Create menu bar
        menubar = self.menuBar()
        menubar.setFont(self.app_font)
        
        # File menu
        file_menu = menubar.addMenu('Start')
        
        # Save action
        save_action = QAction('Speichern', self)
        save_action.setShortcut('Ctrl+S')
        save_action.triggered.connect(self.save_file)
        file_menu.addAction(save_action)
        
        # Load action
        load_action = QAction('Laden', self)
        load_action.setShortcut('Ctrl+L')
        load_action.triggered.connect(self.load_file)
        file_menu.addAction(load_action)
        
        # Note: Saving/Loading now operate on complete prediction state

        # Clear action
        clear_action = QAction('Einträge löschen', self)
        clear_action.setShortcut('Ctrl+N')
        clear_action.triggered.connect(self.clear_entries)
        file_menu.addAction(clear_action)
        
        # Exit action
        exit_action = QAction('Beenden', self)
        exit_action.setShortcut('Ctrl+Q')
        exit_action.triggered.connect(self.close)
        file_menu.addAction(exit_action)
        
    def init_ui(self):        
        central_widget = QWidget()
        main_layout = QVBoxLayout()
        
        top_layout = QHBoxLayout()
        
        # Launch date input
        launch_date_layout = QVBoxLayout()
        launch_date_label = QLabel("Promotionsdatum:")
        launch_date_label.setFont(self.app_font)
        self.launch_date_edit = QDateEdit()
        self.launch_date_edit.setFont(self.app_font)
        self.launch_date_edit.setCalendarPopup(True)  # Enable calendar popup
        self.launch_date_edit.setDate(QDate.currentDate())
        self.launch_date_edit.setDisplayFormat(self.dateformat)
        self.launch_date_edit.dateChanged.connect(self.update_prediction)  # Auto-update on change
        launch_date_layout.addWidget(launch_date_label)
        launch_date_layout.addWidget(self.launch_date_edit)
        top_layout.addLayout(launch_date_layout)
        
        # Duration input
        duration_layout = QVBoxLayout()
        duration_label = QLabel("Bewerbungszeitraum (Jahre):")
        duration_label.setFont(self.app_font)
        self.duration_spin = QSpinBox()
        self.duration_spin.setFont(self.app_font)
        self.duration_spin.setRange(1, 99)
        self.duration_spin.setValue(1)
        self.duration_spin.valueChanged.connect(self.update_prediction)  # Auto-update on change
        duration_layout.addWidget(duration_label)
        duration_layout.addWidget(self.duration_spin)
        top_layout.addLayout(duration_layout)
        
        # Prediction result
        prediction_result_layout = QVBoxLayout()
        prediction_result_label = QLabel("Bewerbungsfrist:")
        prediction_result_label.setFont(self.app_font)
        self.prediction_result = QDateEdit()
        self.prediction_result.setFont(self.app_font)
        self.prediction_result.setReadOnly(True)
        self.prediction_result.setButtonSymbols(QDateEdit.ButtonSymbols.NoButtons)
        self.prediction_result.setDisplayFormat(self.dateformat)
        prediction_result_layout.addWidget(prediction_result_label)
        prediction_result_layout.addWidget(self.prediction_result)
        
        top_layout.addLayout(prediction_result_layout)
        
        main_layout.addLayout(top_layout)
        
        # Events section
        events_layout = QVBoxLayout()
        events_title = QLabel("<h3>Ausfallzeiten</h3>")
        events_title.setFont(self.app_font)
        events_layout.addWidget(events_title)
        
        # Add event button
        add_event_button = QPushButton("Eintrag hinzufügen")
        add_event_button.setFont(self.app_font)
        add_event_button.clicked.connect(self.add_event)
        events_layout.addWidget(add_event_button)
        
        # Events table
        self.events_table = QTableWidget()
        self.events_table.setFont(self.app_font)
        self.events_table.setColumnCount(7)  # ID (hidden), Start, End, Keyword, RelevantTime, Commentary, Actions
        self.events_table.setHorizontalHeaderLabels(["ID", "Anfangsdatum", "Enddatum", "Art", "Anger. Zeit", "Kommentar", "Aktionen"])
        self.events_table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
        self.events_table.horizontalHeader().setFont(self.app_font)
        self.events_table.setColumnHidden(0, True)  # Hide ID column
        # Wrap long text and auto-resize rows so comments are readable
        self.events_table.setWordWrap(True)
        self.events_table.verticalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
        # Enable inline editing on double click / Enter; keep computed column read-only in population step
        self._suppress_item_changed = False
        self.events_table.setEditTriggers(
            QAbstractItemView.DoubleClicked | QAbstractItemView.SelectedClicked | QAbstractItemView.EditKeyPressed
        )
        self.events_table.itemChanged.connect(self.on_events_item_changed)
        events_layout.addWidget(self.events_table)
        
        main_layout.addLayout(events_layout)
        
        # Set main layout
        central_widget.setLayout(main_layout)
        self.setCentralWidget(central_widget)
        
        # Load initial data
        self.update_events_table()
        self.update_prediction()  # Calculate initial prediction
    
    def update_prediction(self):
        """Update prediction whenever needed"""
        try:
            launch_date = self.launch_date_edit.date().toString("yyyy-MM-dd")
            duration_years = self.duration_spin.value()
            
            self.prediction_controller.make_prediction(launch_date, duration_years)
            prediction_date = self.prediction_controller.get_prediction()
            
            if prediction_date:
                self.prediction_result.setDate(prediction_date)
                
            # Update table to show corrected dates
            self.update_events_table()
            
        except Exception as e:
            self.prediction_result.setText("Error in calculation")
            print(f"Error calculating prediction: {str(e)}")
    
    def add_event(self):
        dialog = EventDialog(parent=self)
        if dialog.exec_():
            start_date, end_date, keyword, commentary = dialog.get_data()
            try:
                # Validate data before adding
                errors = self.calendar_manager.validate_entry_data(start_date, end_date, keyword)
                if errors:
                    QMessageBox.warning(self, "Validation Error", "\n".join(errors))
                    return
                
                self.calendar_manager.add_entry(start_date, end_date, keyword, commentary)
                self.update_events_table()
                self.update_prediction()  # Auto-update prediction
            except Exception as e:
                QMessageBox.critical(self, "Error", f"Error adding event: {str(e)}")
    
    def modify_event(self, event_id):
        entry = self.calendar_manager.get_entry_by_id(event_id)
        if entry:
            dialog = EventDialog(entry=entry, parent=self)
            if dialog.exec_():
                start_date, end_date, keyword, commentary = dialog.get_data()
                try:
                    # Validate data before modifying
                    errors = self.calendar_manager.validate_entry_data(start_date, end_date, keyword)
                    if errors:
                        QMessageBox.warning(self, "Validation Error", "\n".join(errors))
                        return
                    
                    self.calendar_manager.modify_entry(event_id, start_date, end_date, keyword, commentary)
                    self.update_events_table()
                    self.update_prediction()  # Auto-update prediction
                except Exception as e:
                    QMessageBox.critical(self, "Error", f"Error modifying event: {str(e)}")
    
    def delete_event(self, event_id):
        reply = QMessageBox.question(self, "Eintrag löschen", 
                                     "Wollen Sie diesen Eintrag löschen?",
                                     QMessageBox.Yes | QMessageBox.No)
        if reply == QMessageBox.Yes:
            try:
                self.calendar_manager.delete_entry(event_id)
                self.update_events_table()
                self.update_prediction()  # Auto-update prediction
            except Exception as e:
                QMessageBox.critical(self, "Error", f"Error deleting event: {str(e)}")
    
    def update_events_table(self):
        # Clear table
        self._suppress_item_changed = True
        try:
            self.events_table.setRowCount(0)
        
            # Add entries to table
            entries = self.calendar_manager.list_entries()
            for i, entry in enumerate(entries):
                self.events_table.insertRow(i)
                
                # Set item data
                self.events_table.setItem(i, 0, QTableWidgetItem(entry.id))
                
                # Format dates using unified display format
                start_date_text = DateService.format_date_for_display(entry.start_date, self.dateformat)
                end_date_text = DateService.format_date_for_display(entry.end_date, self.dateformat)
                self.events_table.setItem(i, 1, QTableWidgetItem(start_date_text))
                self.events_table.setItem(i, 2, QTableWidgetItem(end_date_text))
                # Keyword as dropdown (combobox) for safer selection
                keyword_combo = QComboBox()
                keyword_combo.setFont(self.app_font)
                keyword_combo.addItems(EventConfig.KEYWORDS)
                if entry.keyword in EventConfig.KEYWORDS:
                    keyword_combo.setCurrentIndex(EventConfig.KEYWORDS.index(entry.keyword))
                keyword_combo.currentTextChanged.connect(lambda new_kw, eid=entry.id: self.on_keyword_changed_in_table(eid, new_kw))
                self.events_table.setCellWidget(i, 3, keyword_combo)
                
                # Relevant accounted time from stored time_period
                relevant_text = getattr(entry, 'time_period', "") or ""
                relevant_item = QTableWidgetItem(relevant_text)
                # Make computed column read-only
                relevant_item.setFlags(relevant_item.flags() & ~Qt.ItemIsEditable)
                self.events_table.setItem(i, 4, relevant_item)

                # Commentary
                commentary_text = getattr(entry, 'commentary', "") or ""
                commentary_item = QTableWidgetItem(commentary_text)
                self.events_table.setItem(i, 5, commentary_item)
                
                # Action buttons
                actions_widget = QWidget()
                actions_layout = QHBoxLayout()
                actions_layout.setContentsMargins(0, 0, 0, 0)
                
                modify_button = QPushButton("Editieren")
                modify_button.setFont(self.app_font)
                delete_button = QPushButton("Löschen")
                delete_button.setFont(self.app_font)
                
                # Use lambda with default argument to capture the correct event_id
                modify_button.clicked.connect(lambda checked, eid=entry.id: self.modify_event(eid))
                delete_button.clicked.connect(lambda checked, eid=entry.id: self.delete_event(eid))
                
                actions_layout.addWidget(modify_button)
                actions_layout.addWidget(delete_button)
                actions_widget.setLayout(actions_layout)
                
                self.events_table.setCellWidget(i, 6, actions_widget)
            # Adjust row heights after population to show wrapped text
            self.events_table.resizeRowsToContents()
        finally:
            self._suppress_item_changed = False

    def on_events_item_changed(self, item):
        # Avoid reacting to programmatic changes
        if self._suppress_item_changed:
            return
        row = item.row()
        col = item.column()
        # Ignore non-editable/computed/action columns
        if col in (0, 4, 6):
            return

        # Retrieve entry id
        id_item = self.events_table.item(row, 0)
        if id_item is None:
            return
        event_id = id_item.text()

        # Collect current row values
        start_text = self.events_table.item(row, 1).text() if self.events_table.item(row, 1) else ""
        end_text = self.events_table.item(row, 2).text() if self.events_table.item(row, 2) else ""
        # Keyword comes from the combobox cell widget
        keyword_widget = self.events_table.cellWidget(row, 3)
        keyword_text = keyword_widget.currentText() if isinstance(keyword_widget, QComboBox) else (self.events_table.item(row, 3).text() if self.events_table.item(row, 3) else "")
        commentary_text = self.events_table.item(row, 5).text() if self.events_table.item(row, 5) else ""

        # Normalize to ISO strings for backend
        try:
            start_iso = DateService.format_date_for_iso(DateService.parse_date_from_string(start_text)) if start_text else None
            end_iso = DateService.format_date_for_iso(DateService.parse_date_from_string(end_text)) if end_text else None
        except Exception as e:
            QMessageBox.warning(self, "Ungültiges Datum", f"Bitte ein gültiges Datum eingeben.\nFehler: {str(e)}")
            # Revert table to backend values
            self.update_events_table()
            return

        # Validate before applying
        errors = []
        if start_iso and end_iso:
            errors = self.calendar_manager.validate_entry_data(start_iso, end_iso, keyword_text)
        if errors:
            QMessageBox.warning(self, "Validierungsfehler", "\n".join(errors))
            self.update_events_table()
            return

        # Apply modification
        modified = self.calendar_manager.modify_entry(
            event_id,
            start_date=start_iso if start_iso else None,
            end_date=end_iso if end_iso else None,
            keyword=keyword_text if keyword_text else None,
            commentary=commentary_text if commentary_text is not None else None,
        )
        if modified is None:
            QMessageBox.critical(self, "Fehler", "Eintrag konnte nicht aktualisiert werden.")
            self.update_events_table()
            return

        # Refresh to reflect normalized display and recomputed values
        self.update_events_table()
        self.update_prediction()

    def on_keyword_changed_in_table(self, event_id, new_keyword):
        # Validate using current start/end from the entry
        entry = self.calendar_manager.get_entry_by_id(event_id)
        if not entry:
            return
        start_iso = DateService.format_date_for_iso(entry.start_date)
        end_iso = DateService.format_date_for_iso(entry.end_date)
        errors = self.calendar_manager.validate_entry_data(start_iso, end_iso, new_keyword)
        if errors:
            QMessageBox.warning(self, "Validierungsfehler", "\n".join(errors))
            # Re-render to revert combo to valid value
            self.update_events_table()
            return
        modified = self.calendar_manager.modify_entry(event_id, keyword=new_keyword)
        if modified is None:
            QMessageBox.critical(self, "Fehler", "Eintrag konnte nicht aktualisiert werden.")
            self.update_events_table()
            return
        self.update_events_table()
        self.update_prediction()
    
    def save_file(self):
        """Save the complete prediction state to a .prediction.json file"""
        file_path, _ = QFileDialog.getSaveFileName(
            self,
            "Zustand speichern",
            "",
            "Prediction State (*.prediction.json)"
        )
        if not file_path:
            return

        try:
            if self.prediction_controller.save_complete_state(file_path):
                target = file_path if file_path.endswith('.prediction.json') else file_path + '.prediction.json'
                QMessageBox.information(self, "Speichern erfolgreich", f"Komplettzustand gespeichert in {target}")
            else:
                QMessageBox.critical(self, "Error", "Speichern des Komplettzustands fehlgeschlagen")
        except Exception as e:
            QMessageBox.critical(self, "Error", f"Fehler beim Speichern des Komplettzustands: {str(e)}")
    
    def load_file(self):
        """Load the complete prediction state from a .prediction.json file"""
        file_path, _ = QFileDialog.getOpenFileName(
            self,
            "Zustand laden",
            "",
            "Prediction State (*.prediction.json)"
        )
        if not file_path:
            return

        try:
            success = self.prediction_controller.load_complete_state(file_path)
            if success:
                # Reflect restored parameters into UI
                launch_dt = self.prediction_controller.get_launch_date()
                duration = self.prediction_controller.get_duration()
                if launch_dt:
                    self.launch_date_edit.setDate(launch_dt)
                if duration is not None and hasattr(duration, 'years'):
                    self.duration_spin.setValue(max(1, duration.years))

                # Update views
                self.update_events_table()
                prediction_date = self.prediction_controller.get_prediction()
                if prediction_date:
                    self.prediction_result.setDate(prediction_date)
                QMessageBox.information(self, "Laden erfolgreich", f"Komplettzustand von {file_path} geladen")
            else:
                QMessageBox.warning(self, "Warnung", "Komplettzustand konnte nicht geladen werden")
        except Exception as e:
            QMessageBox.critical(self, "Error", f"Fehler beim Laden des Komplettzustands: {str(e)}")

    
    def clear_entries(self):
        """Clear all calendar entries"""
        reply = QMessageBox.question(self, "Einträge löschen", 
                                    "Alle Einträge löschen?",
                                    QMessageBox.Yes | QMessageBox.No)
        if reply == QMessageBox.Yes:
            try:
                self.calendar_manager.clear_entries()
                self.update_events_table()
                self.update_prediction()  # Auto-update prediction
                QMessageBox.information(self, "Erfolg", "Alle Einträge gelöscht!")
            except Exception as e:
                QMessageBox.critical(self, "Error", f"Failed to clear calendar: {str(e)}")


def main():
    app = QApplication(sys.argv)
    app.setStyle('Fusion')
    # Ensure Arial is available
    QFontDatabase.addApplicationFont("Arial")
    window = CalendarManagerGUI()
    window.show()
    sys.exit(app.exec_())


if __name__ == "__main__":
    main()