ReportController.java

// Copyright 2019 doubleSlash Net Business GmbH
//
// This file is part of KeepTime.
// KeepTime 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 <http://www.gnu.org/licenses/>.

package de.doubleslash.keeptime.view;

import java.io.IOException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.*;
import java.util.stream.Collectors;

import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.scene.image.Image;
import javafx.scene.input.KeyCode;
import javafx.scene.input.KeyEvent;
import javafx.scene.layout.*;
import javafx.scene.shape.SVGPath;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import de.doubleslash.keeptime.common.DateFormatter;
import de.doubleslash.keeptime.common.Resources;
import de.doubleslash.keeptime.common.Resources.RESOURCE;
import de.doubleslash.keeptime.common.SvgNodeProvider;
import de.doubleslash.keeptime.controller.Controller;
import de.doubleslash.keeptime.exceptions.FXMLLoaderException;
import de.doubleslash.keeptime.model.Model;
import de.doubleslash.keeptime.model.Project;
import de.doubleslash.keeptime.model.Work;
import de.doubleslash.keeptime.view.worktable.ProjectTableRow;
import de.doubleslash.keeptime.view.worktable.TableRow;
import de.doubleslash.keeptime.view.worktable.WorkTableRow;
import javafx.beans.property.ReadOnlyObjectWrapper;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.scene.Node;
import javafx.scene.canvas.Canvas;
import javafx.scene.control.*;
import javafx.scene.control.Alert.AlertType;
import javafx.scene.control.cell.TreeItemPropertyValueFactory;
import javafx.scene.control.skin.DatePickerSkin;
import javafx.scene.input.Clipboard;
import javafx.scene.input.ClipboardContent;
import javafx.scene.shape.Circle;
import javafx.stage.Stage;
import javafx.util.Callback;

import static de.doubleslash.keeptime.App.showErrorDialogAndWait;
import static de.doubleslash.keeptime.view.ViewController.createFXMLLoader;

@Component
public class ReportController {

   public static final String NOTE_DELIMETER = "; ";

   public static final String EMPTY_NOTE = "- No notes -";

   private static final String FX_BACKGROUND_COLOR_NOT_WORKED = "-fx-background-color: #BBBBBB;";

   private static final String FX_BACKGROUND_COLOR_WORKED = "-fx-background-color: #00a5e1;";

   private static final String EDIT_WORK_DIALOG_TITLE = "Edit work";

   @FXML
   private BorderPane topBorderPane;

   @FXML
   private Label currentDayLabel;
   @FXML
   private Label currentDayWorkTimeLabel;
   @FXML
   private Label currentDayTimeLabel;

   @FXML
   private TreeTableView<TableRow> workTableTreeView;

   @FXML
   private AnchorPane reportRoot;

   @FXML
   private Canvas colorTimeLineCanvas;

   @FXML
   private Button expandCollapseButton;

   @FXML
   private Button heimatSyncButton;

   @FXML
   private Button addWorkButton;

   private static final Logger LOG = LoggerFactory.getLogger(ReportController.class);

   private final Model model;

   private final Controller controller;

   private Stage stage;

   private ColorTimeLine colorTimeLine;

   private LocalDate currentReportDate;

   private final TreeItem<TableRow> rootItem = new TreeItem<>();

   private boolean expanded = true;
   private List<Work> currentWorkItems;

   public ReportController(final Model model, final Controller controller) {
      this.model = model;
      this.controller = controller;
   }

   @FXML
   private void initialize() {
      LOG.info("Init reportController");
      currentReportDate = LocalDate.now();

      colorTimeLine = new ColorTimeLine(colorTimeLineCanvas);

      expandCollapseButton.setOnMouseClicked(event ->toggleCollapseExpandReport());
      if (addWorkButton != null) {
         addWorkButton.setOnAction(e -> onAddWork());
      }
      initTableView();
      initHeimatIntegration();
   }

   private void onAddWork() {
      // Default values: current report date window or now if today
      final boolean isToday = LocalDate.now().equals(currentReportDate);
      final LocalDateTime now = LocalDateTime.now();
      final LocalDateTime defaultStart = isToday ? now.minusMinutes(15) : currentReportDate.atTime(LocalTime.of(9, 0));
      final LocalDateTime defaultEnd = isToday ? now : currentReportDate.atTime(LocalTime.of(10, 0));

      final Project defaultProject = model.activeWorkItem.get() != null
            ? model.activeWorkItem.get().getProject()
            : model.getIdleProject();

      final Work newWorkDefaults = new Work(defaultStart, defaultEnd, defaultProject, "");
      final Dialog<Work> dialog = setupAddWorkDialog(newWorkDefaults);

      final Optional<Work> result = dialog.showAndWait();
      result.ifPresent(createdWork -> {
         controller.addWork(createdWork);
         this.update();
      });
   }

   private void initHeimatIntegration() {
      heimatSyncButton.setVisible(model.getHeimatSettings().isHeimatActive());
      final SVGPath svgNodeWithScale = SvgNodeProvider.getSvgNodeWithScale(RESOURCE.SVG_ROTATE_ICON, 0.03, 0.03);
      svgNodeWithScale.setStyle("-fx-fill: #00759e");
      heimatSyncButton.setMaxSize(25,25);
      heimatSyncButton.setMinSize(25, 25);
      heimatSyncButton.setGraphic(svgNodeWithScale);
      heimatSyncButton.setContentDisplay(ContentDisplay.GRAPHIC_ONLY);
      heimatSyncButton.setTooltip(new Tooltip("Synchronize to HEIMAT..."));
      heimatSyncButton.setOnAction(ae-> {
         try {
            showSyncStage();
         } catch (FXMLLoaderException e) {
            LOG.error("Error while loading sync stage", e);
            showErrorDialogAndWait("Error", "Could not load sync stage", "Please make sure your AccessToken is valid and you have internet.", e, this.stage);
         }
      });
   }

   private void showSyncStage(){
      try{
         // Settings stage
         final FXMLLoader fxmlLoader2 = createFXMLLoader(RESOURCE.FXML_EXT_PROJECT_SYNC);
         fxmlLoader2.setControllerFactory(model.getSpringContext()::getBean);
         final Parent syncRoot = fxmlLoader2.load();
         ExternalProjectsSyncController syncController = fxmlLoader2.getController();
         syncController.initForDate(currentReportDate, currentWorkItems);
         Stage syncStage = new Stage();
         syncController.setStage(syncStage);
         syncStage.initOwner(this.stage);
         syncStage.setTitle("External Project Sync");
         syncStage.setResizable(true);
         syncStage.getIcons().add(new Image(Resources.getResource(RESOURCE.ICON_MAIN).toString()));

         final Scene settingsScene = new Scene(syncRoot);
         settingsScene.addEventFilter(KeyEvent.KEY_PRESSED, ke -> {
            if (ke.getCode() == KeyCode.ESCAPE) {
               LOG.info("pressed ESCAPE");
               syncStage.close();
            }
         });

         syncStage.setScene(settingsScene);
         syncStage.showAndWait();
      } catch (final Exception e) {
         throw new FXMLLoaderException(e);
      }
   }


   private void initTableView() {
      final TreeTableColumn<TableRow, TableRow> noteColumn = new TreeTableColumn<>("Notes");
      noteColumn.setCellFactory(new Callback<TreeTableColumn<TableRow, TableRow>, TreeTableCell<TableRow, TableRow>>() {
         @Override
         public TreeTableCell<TableRow, TableRow> call(final TreeTableColumn<TableRow, TableRow> column) {
            return new TreeTableCell<TableRow, TableRow>() {
               @Override
               protected void updateItem(final TableRow item, final boolean empty) {
                  super.updateItem(item, empty);
                  if (item == null || empty) {
                     setGraphic(null);
                     setText(null);
                  } else {
                     final String notes = item.getNotes();
                     final String text = notes.isEmpty() ? EMPTY_NOTE : notes;
                     this.setText(text);
                     if (item.getProjectColor() != null) {
                        final Circle circle = new Circle(6, item.getProjectColor());
                        this.setGraphic(circle);
                     } else {
                        this.setGraphic(null);
                     }
                  }
               }
            };
         }

      });
      noteColumn.setCellValueFactory(
            (final TreeTableColumn.CellDataFeatures<TableRow, TableRow> entry) -> new ReadOnlyObjectWrapper<>(
                  entry.getValue().getValue()));
      noteColumn.setMinWidth(200);
      noteColumn.setReorderable(false);
      this.workTableTreeView.getColumns().add(noteColumn);

      final TreeTableColumn<TableRow, String> timeRangeColumn = new TreeTableColumn<>("Timeslot");
      timeRangeColumn.setCellValueFactory(new TreeItemPropertyValueFactory<TableRow, String>("timeRange"));
      timeRangeColumn.setMinWidth(120);
      timeRangeColumn.setReorderable(false);
      this.workTableTreeView.getColumns().add(timeRangeColumn);

      final TreeTableColumn<TableRow, TableRow> timeSumColumn = new TreeTableColumn<>("Duration");
      timeSumColumn.setCellFactory(new Callback<>() {
         @Override
         public TreeTableCell<TableRow, TableRow> call(
               TreeTableColumn<TableRow, TableRow> tableRowStringTreeTableColumn) {

            return new TreeTableCell<>() {

               @Override
               protected void updateItem(TableRow workItem, boolean empty) {
                  super.updateItem(workItem, empty);

                  if (workItem == null || empty) {
                     this.setGraphic(null);
                     this.setText(null);
                  } else {
                     this.setText(workItem.getTimeSum());
                     this.setUnderline(workItem.isUnderlined());
                  }
               }
            };
         }
      });
      timeSumColumn.setCellValueFactory(
            (final TreeTableColumn.CellDataFeatures<TableRow, TableRow> entry) -> new ReadOnlyObjectWrapper<>(
                  entry.getValue().getValue()));
      timeSumColumn.setMinWidth(60);
      timeSumColumn.setReorderable(false);
      this.workTableTreeView.getColumns().add(timeSumColumn);

      final TreeTableColumn<TableRow, Button> buttonColumn = new TreeTableColumn<>("Controls");
      buttonColumn.setCellValueFactory(new TreeItemPropertyValueFactory<>("buttonBox"));
      buttonColumn.setMinWidth(95);
      buttonColumn.setSortable(false);
      buttonColumn.setReorderable(false);
      this.workTableTreeView.getColumns().add(buttonColumn);

      workTableTreeView.setShowRoot(false);

      workTableTreeView.setRoot(rootItem);
      rootItem.setExpanded(true);
   }

   private void toggleCollapseExpandReport(){

      if(expanded){
         expandAll(false);
         expandCollapseButton.setText("Expand");

      }else {
         expandAll(true);
         expandCollapseButton.setText("Collapse");
      }
      expanded = !expanded;
   }

   private void expandAll(boolean expand){
      for (int i=0; i<rootItem.getChildren().size(); i++){
         rootItem.getChildren().get(i).setExpanded(expand);
      }
   }
   private void updateReport(final LocalDate dateToShow) {
      this.currentReportDate = dateToShow;
      rootItem.getChildren().clear();
      reportRoot.requestFocus();

      this.currentDayLabel.setText(DateFormatter.toDayDateString(this.currentReportDate));
      currentWorkItems = model.getWorkRepository()
                                               .findByStartDateOrderByStartTimeAsc(this.currentReportDate);

      colorTimeLine.update(currentWorkItems, controller.calcSeconds(currentWorkItems));

      final SortedSet<Project> workedProjectsSet = currentWorkItems.stream()
                                                                   .map(Work::getProject)
                                                                   .collect(Collectors.toCollection(() -> new TreeSet<>(
                                                                         Comparator.comparing(Project::getIndex))));

      long currentWorkSeconds = 0;
      long currentSeconds = 0;

      for (final Project project : workedProjectsSet) {
         final List<Work> onlyCurrentProjectWork = currentWorkItems.stream()
                                                                   .filter(w -> w.getProject() == project)
                                                                   .collect(Collectors.toList());

         final long projectWorkSeconds = controller.calcSeconds(onlyCurrentProjectWork);

         currentSeconds += projectWorkSeconds;
         if (project.isWork()) {
            currentWorkSeconds += projectWorkSeconds;
         }

         final HBox projectButtonBox = new HBox();
         projectButtonBox.getChildren().add(createCopyProjectNameButton(project.getName()));
         projectButtonBox.getChildren().add(createCopyProjectNotesButton(onlyCurrentProjectWork));

         final TreeItem<TableRow> projectRow = new TreeItem<>(
               new ProjectTableRow(project, projectWorkSeconds, projectButtonBox));

         for (final Work w : onlyCurrentProjectWork) {
            final HBox workButtonBox = new HBox(5.0);
            if(w.getId()==model.activeWorkItem.get().getId()){
               Label label = new Label("Active Work");
               label.setTooltip(new Tooltip("The active work item cannot be edited as it is currently active. To edit it you need to switch to another work first."));
               label.setStyle("-fx-font-weight: bold");
               workButtonBox.getChildren().add(label);
            }else {
               workButtonBox.getChildren().add(createCopyWorkButton(w));
               workButtonBox.getChildren().add(createEditWorkButton(w));
               workButtonBox.getChildren().add(createDeleteWorkButton(w));
            }
            final TreeItem<TableRow> workRow = new TreeItem<>(new WorkTableRow(w, workButtonBox));
            projectRow.getChildren().add(workRow);
         }

         projectRow.setExpanded(expanded);
         rootItem.getChildren().add(projectRow);

      }

      this.currentDayTimeLabel.setText(DateFormatter.secondsToHHMMSS(currentSeconds));
      this.currentDayWorkTimeLabel.setText(DateFormatter.secondsToHHMMSS(currentWorkSeconds));

      loadCalenderWidget();

   }

   private void loadCalenderWidget() {
      final DatePicker myDatePicker = new DatePicker(this.currentReportDate);
      myDatePicker.valueProperty().addListener((observable, oldvalue, newvalue) -> {
         LOG.info("Datepicker selected value changed to {}", newvalue);
         updateReport(newvalue);
      });

      // HACK to show calendar from datepicker
      // https://stackoverflow.com/questions/34681975/javafx-extract-calendar-popup-from-datepicker-only-show-popup
      final DatePickerSkin datePickerSkin = new DatePickerSkin(myDatePicker);
      final Callback<DatePicker, DateCell> dayCellFactory = callback -> new DateCell() {
         @Override
         public void updateItem(final LocalDate item, final boolean empty) {
            super.updateItem(item, empty);
            if (model.getWorkRepository().findByStartDateOrderByStartTimeAsc(item).isEmpty()) {
               setDisable(true);
               setStyle(FX_BACKGROUND_COLOR_NOT_WORKED);
            } else {
               setDisable(false);
               setStyle(FX_BACKGROUND_COLOR_WORKED);
            }
         }

      };
      myDatePicker.setDayCellFactory(dayCellFactory);
      final Node popupContent = datePickerSkin.getPopupContent();
      this.topBorderPane.setRight(popupContent);

   }

   private Button createDeleteWorkButton(final Work w) {
      final Button deleteButton = new Button("",
            SvgNodeProvider.getSvgNodeWithScale(RESOURCE.SVG_TRASH_ICON, 0.03, 0.03));
      deleteButton.setMaxSize(20, 18);
      deleteButton.setMinSize(20, 18);
      deleteButton.setContentDisplay(ContentDisplay.GRAPHIC_ONLY);
      deleteButton.getStyleClass().add("tertiary-button");

      deleteButton.setOnAction(e -> {
         LOG.info("Delete work clicked.");
         final Alert alert = new Alert(AlertType.CONFIRMATION);
         alert.setTitle("Delete Work");
         alert.setHeaderText("Delete work item");
         alert.setContentText(w.toString());
         alert.initOwner(stage);

         final Optional<ButtonType> result = alert.showAndWait();

         result.ifPresent(buType -> {
            if (buType.equals(ButtonType.OK)) {
               controller.deleteWork(w);
               this.update();
            }
         });
      });
      return deleteButton;
   }

   private Button createEditWorkButton(final Work work) {
      final Button editButton = new Button("",
            SvgNodeProvider.getSvgNodeWithScale(RESOURCE.SVG_PENCIL_ICON, 0.03, 0.03));
      editButton.setMaxSize(20, 18);
      editButton.setMinSize(20, 18);
      editButton.setContentDisplay(ContentDisplay.GRAPHIC_ONLY);
      editButton.getStyleClass().add("tertiary-button");

      editButton.setOnAction(e -> {
         LOG.info("Edit work clicked.");
         final Dialog<Work> dialog = setupEditWorkDialog(work);

         final Optional<Work> result = dialog.showAndWait();

         result.ifPresent(editedWork -> {
            controller.editWork(work, editedWork);

            this.update();
         });
      });
      return editButton;
   }

   private Dialog<Work> setupEditWorkDialog(final Work work) {
      final Dialog<Work> dialog = new Dialog<>();
      dialog.initOwner(stage);
      dialog.setTitle(EDIT_WORK_DIALOG_TITLE);
      dialog.setHeaderText(EDIT_WORK_DIALOG_TITLE);
      dialog.getDialogPane().getButtonTypes().addAll(ButtonType.OK, ButtonType.CANCEL);

      final GridPane grid = setUpEditWorkGridPane(work, dialog);
      dialog.getDialogPane().setContent(grid);

      return dialog;
   }

   private Dialog<Work> setupAddWorkDialog(final Work work) {
      final Dialog<Work> dialog = new Dialog<>();
      dialog.initOwner(stage);
      dialog.setTitle("Add work");
      dialog.setHeaderText("Add work");
      dialog.getDialogPane().getButtonTypes().addAll(ButtonType.OK, ButtonType.CANCEL);

      final GridPane grid = setUpEditWorkGridPane(work, dialog);
      dialog.getDialogPane().setContent(grid);

      return dialog;
   }

   private GridPane setUpEditWorkGridPane(final Work work, final Dialog<Work> dialog) {
      final GridPane grid;
      final FXMLLoader loader = new FXMLLoader(Resources.getResource(RESOURCE.FXML_MANAGE_WORK));
      try {
         grid = loader.load();
      } catch (final IOException e) {
         throw new FXMLLoaderException("Error while loading '" + Resources.RESOURCE.FXML_MANAGE_WORK + "'.", e);
      }
      final ManageWorkController manageWorkController = loader.getController();
      manageWorkController.setModel(model);
      manageWorkController.initializeWith(work);

      dialog.getDialogPane()
            .lookupButton(ButtonType.OK)
            .disableProperty()
            .bind(manageWorkController.validProperty().not());

      dialog.setResultConverter(dialogButton -> {
         if (dialogButton == ButtonType.OK) {
            return manageWorkController.getWorkFromUserInput();
         }
         return null;
      });

      return grid;
   }

   private Button createCopyProjectNotesButton(final List<Work> projectWork) {
      final Button copyNotesButton = new Button("", SvgNodeProvider.getSvgNodeWithScale(RESOURCE.SVG_MULTIPLE_CLIPBOARD_ICON, 0.03, 0.03));
      copyNotesButton.setMaxSize(20, 18);
      copyNotesButton.setMinSize(20, 18);
      copyNotesButton.setContentDisplay(ContentDisplay.GRAPHIC_ONLY);
      copyNotesButton.setTooltip(new Tooltip("Copy Project Notes"));
      copyNotesButton.getStyleClass().add("tertiary-button");

      final EventHandler<ActionEvent> eventListener = actionEvent -> {
         LOG.debug("Copy to Clipboard clicked.");
         final ProjectReport pr = new ProjectReport();
         for (int j = 0; j < projectWork.size(); j++) {
            final Work work = projectWork.get(j);
            final String currentWorkNote = work.getNotes();
            pr.appendToWorkNotes(currentWorkNote);
         }
         copyToClipboard(pr.getNotes());
      };

      copyNotesButton.setOnAction(eventListener);
      return copyNotesButton;
   }
   private Button createCopyProjectNameButton(String projectName) {
      final Button copyProjectNameButton = new Button("", SvgNodeProvider.getSvgNodeWithScale(RESOURCE.SVG_CLIPBOARD_ICON, 0.03, 0.03));
      copyProjectNameButton.setMaxSize(20, 18);
      copyProjectNameButton.setMinSize(20, 18);
      copyProjectNameButton.setContentDisplay(ContentDisplay.GRAPHIC_ONLY);
      copyProjectNameButton.setTooltip(new Tooltip("Copy Project Name"));
      copyProjectNameButton.getStyleClass().add("tertiary-button");

      final EventHandler<ActionEvent> eventListener = actionEvent -> {
         LOG.debug("Copy to Clipboard clicked.");
         copyToClipboard(projectName);
      };

      copyProjectNameButton.setOnAction(eventListener);
      return copyProjectNameButton;
   }

   public static void copyToClipboard(final String stringToCopy) {
      final Clipboard clipboard = Clipboard.getSystemClipboard();
      final ClipboardContent content = new ClipboardContent();
      content.putString(stringToCopy);
      clipboard.setContent(content);
   }

   private Node createCopyWorkButton(final Work w) {
      final Button copyButton = new Button("", SvgNodeProvider.getSvgNodeWithScale(RESOURCE.SVG_CLIPBOARD_ICON, 0.03, 0.03));
      copyButton.setMaxSize(20, 18);
      copyButton.setMinSize(20, 18);
      copyButton.setContentDisplay(ContentDisplay.GRAPHIC_ONLY);
      copyButton.getStyleClass().add("tertiary-button");

      final EventHandler<ActionEvent> eventListener = actionEvent -> {
         LOG.debug("Copy to Clipboard clicked.");
         copyToClipboard(w.getNotes());
      };

      copyButton.setOnAction(eventListener);
      return copyButton;
   }

   public void update() {
      heimatSyncButton.setVisible(model.getHeimatSettings().isHeimatActive());
      // TODO save work so it appears directly in report. Quick fixes #170. Use #176 for this instead.
      controller.saveCurrentWork();
      updateReport(this.currentReportDate);
   }

   public void setStage(final Stage stage) {
      this.stage = stage;
   }
}