package bluej.groupwork.actions;

import bluej.Config;
import bluej.collect.DataCollector;
import bluej.groupwork.StatusHandle;
import bluej.groupwork.TeamUtils;
import bluej.groupwork.TeamworkCommand;
import bluej.groupwork.TeamworkCommandResult;
import bluej.groupwork.ui.CommitAndPushFrame;
import bluej.pkgmgr.PkgMgrFrame;
import bluej.pkgmgr.Project;
import bluej.utility.FXWorker;

import java.io.File;
import java.util.HashSet;
import java.util.Set;
import javafx.application.Platform;

import threadchecker.OnThread;
import threadchecker.Tag;




| This class implements the push action.
| @author Fabio Heday
|
@OnThread(Tag.FXPlatform)
public class PushAction
extends TeamAction{    
   private CommitAndPushFrame commitCommentsFrame;
   
   private Set<File> filesToPush;
   
   private PushWorker worker;
   @OnThread(value = Tag.Any, requireSynchronized = true)
   
   private StatusHandle statusHandle;

   
   public PushAction(CommitAndPushFrame frame)
   {
      super(Config.getString("team.push"), false);
       
      commitCommentsFrame = frame;
       
      this.filesToPush = new HashSet<>();     
      }

   
   


| Cancel the push, if it is running.
|
public void cancel()
   {
      setEnabled(true);
      if (worker != null) {
         worker.abort();
           
         worker = null;         
         }     
      }

   
   


| Set the status handle to use in order to perform the commit operation.
| @param statusHandle
|
@OnThread(Tag.Worker)
   
   public synchronized void setStatusHandle(StatusHandle statusHandle)
   {        
      this.statusHandle = statusHandle;     
      }

   
   @Override
   
   protected void actionPerformed(Project project)
   {
      commitCommentsFrame.startProgress();
      commitCommentsFrame.displayMessage(Config.getString("team.push.statusMessage"));
      setEnabled(false);
      this.filesToPush.clear();
      filesToPush.addAll(commitCommentsFrame.getFilesToPush());

       
      worker = new PushAction.PushWorker(project);
      worker.start();     
      }

   
   


| Worker thread to perform commit operation
|
| @author Fabio Heday
|
private class PushWorker
extends FXWorker
   {        
      private TeamworkCommand command;
       
      private TeamworkCommandResult result = null;
       
      private final boolean hasPassword;
       
      private boolean aborted;

      @OnThread(Tag.FXPlatform)
       
      public PushWorker(Project project)
       {
         command = statusHandle.pushAll(filesToPush);

           
         
         if (!project.getTeamSettingsController().hasPasswordString()) {                
            
            if ( ! project.getTeamSettingsDialog().showAndWait().isPresent() ) {                    
               
               commitCommentsFrame.setVisible(true);
                   
               hasPassword = false;
                   
               return;                 
               }
               
            
            statusHandle.getRepository().setPassword(commitCommentsFrame.getProject().getTeamSettingsController().getTeamSettingsDialog().getSettings());             
            }
           
         hasPassword = true;         
         }

       
      @Override
      @OnThread(Tag.Worker)
       
      public Object construct()
       {
         if (!hasPassword)
           {
            Platform.runLater(this::abort);
               
            return null;             
            }
         result = command.getResult();
           
         return result;         
         }

       
      public void abort()
       {
         command.cancel();
           
         aborted = true;         
         }

       
      @Override
       
      public void finished()
       {
         final Project project = commitCommentsFrame.getProject();

         if (!aborted) {
            commitCommentsFrame.stopProgress();
            if (!result.isError()) {
               if ( !result.wasAborted()) {
                  DataCollector.teamPushProject(project, statusHandle.getRepository(), filesToPush);
                  commitCommentsFrame.displayMessage(Config.getString("team.push.statusDone"));                     
                  }                 
               }
               

            else { 
            commitCommentsFrame.displayMessage(Config.getString("team.push.error"));                 
            }             
         }

      TeamUtils.handleServerResponseFX(result, commitCommentsFrame.asWindow());

      if (!aborted) {
         setEnabled(true);
         if (project.getTeamSettingsController().isDVCS()){                    
            
            commitCommentsFrame.setVisible(true);                
            }

         else {
                   
         
         commitCommentsFrame.setVisible(false);                 
         }             
      }         
   }     
} 
}