package bluej.groupwork.actions;

import java.io.File;
import java.io.IOException;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import javafx.application.Platform;

import bluej.Config;
import bluej.collect.DataCollector;
import bluej.groupwork.Repository;
import bluej.groupwork.TeamSettingsController;
import bluej.groupwork.TeamUtils;
import bluej.groupwork.TeamworkCommand;
import bluej.groupwork.TeamworkCommandResult;
import bluej.pkgmgr.PkgMgrFrame;
import bluej.pkgmgr.Project;
import bluej.utility.Debug;
import bluej.utility.DialogManager;
import bluej.utility.Utility;

import threadchecker.OnThread;
import threadchecker.Tag;




| An action to share a project into a repository.
|
| @author Kasper
|
@OnThread(Tag.FXPlatform)
public class ShareAction
extends TeamAction{    
   public ShareAction()
   {
      super("team.share", true);     
      }
    
   
   @Override
   
   public void actionPerformed(PkgMgrFrame pmf)
   {
      Project project = pmf.getProject();
        
      if (project == null) {            
         return;         
         }

      doShare(pmf, project);     
      }

   
   private void doShare(final PkgMgrFrame pmf, final Project project)
   {        
      
      
      final TeamSettingsController tsc = new TeamSettingsController(project.getProjectDir());
      Repository repository = tsc.trytoEstablishRepository(true);
      if (repository == null) {            
         
         return;         
         }
       
      try {
      project.saveAll();
      project.saveAllEditors();         
      }
       
   catch(IOException ioe) {
      String msg = DialogManager.getMessage("team-error-saving-project");
      if (msg != null) {
         String finalMsg = Utility.mergeStrings(msg, ioe.getLocalizedMessage());
         DialogManager.showErrorTextFX(pmf.getFXWindow(), finalMsg);
               
         return;             
         }         
      }
   pmf.setStatus(Config.getString("team.sharing"));
   pmf.startProgress();
        
       
   Thread thread = new Thread() {                         
      TeamworkCommandResult result = null;

      @OnThread(value = Tag.Worker, ignoreParent = true)
           
      public void run()
           {                
         
         TeamworkCommand command = repository.shareProject();
         result = command.getResult();

         if (! result.isError())
               {                    
            
            CompletableFuture<Set<File>> filesFuture = new CompletableFuture<>();
                   
            CompletableFuture<Boolean> isDVCSFuture = new CompletableFuture<>();

            Platform.runLater( () -> {
            project.setTeamSettingsController(tsc);
            Set<File> projFiles = tsc.getProjectFiles(true);
                       
            
            filesFuture.complete(new HashSet<>(projFiles));
            isDVCSFuture.complete(tsc.isDVCS());                     
            });
         try {
         Set<File> files = filesFuture.get();
         Boolean isDVCS = isDVCSFuture.get();

                       
         Set<File> newFiles = new LinkedHashSet<>(files);
         Set<File> binFiles = TeamUtils.extractBinaryFilesFromSet(newFiles);
         command = repository.commitAll(newFiles, binFiles, Collections.emptySet(),
         files, Config.getString("team.share.initialMessage"));
         result = command.getResult();
                       
         
         if (isDVCS){
            command = repository.pushChanges();
            result = command.getResult();                         
            }                     
         }
                   
      catch (InterruptedException | ExecutionException e)
                   {
         Debug.reportError(e);                     
         }                 
      }

   Platform.runLater(() -> {
   TeamUtils.handleServerResponseFX(result, pmf.getFXWindow());
   pmf.stopProgress();
   if (!result.isError())
                   {
      pmf.setStatus(Config.getString("team.shared"));
      DataCollector.teamShareProject(project, repository);                     
      }
                   

   else
                   {
      pmf.clearStatus();                     
      }                 
   });
}         
};
thread.start();     
} 
}