/*
    * Copyright (c) 2007 Creative Sphere Limited.
    * All rights reserved. This program and the accompanying materials
    * are made available under the terms of the Eclipse Public License v1.0
    * which accompanies this distribution, and is available at
    * http://www.eclipse.org/legal/epl-v10.html
    *
    * Contributors:
    *
   *   Creative Sphere - initial API and implementation
   *
   */
  package org.abstracthorizon.aequo.file.action;
  
  import java.awt.event.ActionEvent;
  import java.awt.event.KeyEvent;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.StringWriter;
  import java.nio.MappedByteBuffer;
  import java.nio.channels.FileChannel;
  
  import javax.swing.Action;
  import javax.swing.JOptionPane;
  import javax.swing.KeyStroke;
  import javax.swing.ListSelectionModel;
  import javax.swing.ProgressMonitor;
  
  import org.abstracthorizon.aequo.file.FileCompareEntry;
  import org.abstracthorizon.aequo.file.FilesModel;
  
  /**
   * Copy to other side action.
   *
   * @author Daniel Sendula
   */
  public class CopyToAction extends FileBaseAction {
  
      /**
       * Constructor
       */
      public CopyToAction() {
          setConfirmRequired(true);
          setDirectionalAction(true);
          setName("{0} Copy to {1}");
          setMessage("Do you want to copy files/folders to other side?");
          setDescription("Copying files and/or folders");
          putValue(Action.MNEMONIC_KEY, KeyEvent.VK_C);
      }
  
      /**
       * Sets the column and updates the accelerator keys
       * @param column column
       */
      public void setColumn(int column) {
          super.setColumn(column);
          if (column == 0) {
              putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, ActionEvent.CTRL_MASK));
          } else {
              putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, ActionEvent.CTRL_MASK));
          }
      }
  
      /**
       * Returns if selection is valid
       * @return <code>true</code> if selection is valid<
       */
      public boolean isEnabled() {
          return (column >= 0) && isSelectionValid();
      }
      
      /**
       * Copies files
       * @param e event
       * @param monitor monitor
       */
      public void perform(ActionEvent e, ProgressMonitor monitor) {
          int failed = 0;
          StringWriter failedDetails = new StringWriter();
  
          FilesModel model = getFilesModel();
          
          int first = 0;
          int last = -1;
          FileCompareEntry[] entries = getPreselectedEntries();
          if (entries.length > 0) {
              first = entries[0].getIndex();
              int i = entries.length - 1;
              while ((i >= 0) && (last < 0)) {
                  last = entries[i].getIndex();
                  i--;
              }
          }
  
          monitor.setMaximum(entries.length);
  
          ListSelectionModel selModel = model.getSelectionModel();
 
         selModel.setValueIsAdjusting(true);
         try {
             int i = 0;
             while (i < entries.length) {
                 FileCompareEntry entry = entries[i];
                 File[] data = entry.getData();
                 File fromFile = data[column];
                 File toFile = data[destColumn];
                 monitor.setNote(fromFile.getAbsolutePath() + " to " + toFile.getAbsolutePath());
                 if (fromFile.exists()) {
                     if (fromFile.isDirectory()) {
                         boolean err = false;
                         if (toFile.exists() && !toFile.isDirectory() && !toFile.delete()) {
                             failed = failed + 1;
                             failedDetails.append("Failed to delete ").append(toFile.getAbsolutePath());
                             err = true;
                         }
                         
                         if (!err && !toFile.exists()) {
                             if (!toFile.mkdirs()) {
                                 failed = failed + 1;
                                 failedDetails.append("Failed to created folder ").append(toFile.getAbsolutePath());
                             } else {
                                 toFile.setLastModified(fromFile.lastModified());
                             }
                         } else if (!err) {
                             toFile.setLastModified(fromFile.lastModified());
                         }
                     } else {
                         if (!copyFile(fromFile, toFile)) {
                             failed = failed + 1;
                             failedDetails.append("Failed creating directory ").append(toFile.getAbsolutePath());
                         } else {
                             toFile.setLastModified(fromFile.lastModified());
                         }
                     }
                     entry.updateEntryStatus();
                 }
                 monitor.setProgress(i);
                 i++;
             }
             if (entries.length > 0) {
                 model.notifyOfChange(first, last);
             }
         } finally {
             selModel.setValueIsAdjusting(false);
         }
         if (failed > 0) {
             JOptionPane.showMessageDialog(null, failedDetails.toString(), "Problem deleting files", JOptionPane.WARNING_MESSAGE, null);
         }
     }
 
     /**
      * Copies files and directories
      * @param fromFile source file/dir
      * @param toFile destination file/dir
      * @return
      */
     public static boolean copyFile(File fromFile, File toFile) {
         try {
             FileInputStream fromInputStream = new FileInputStream(fromFile);
             try {
                 FileOutputStream toOutputStream = new FileOutputStream(toFile);
                 try {
                     FileChannel inChannel = fromInputStream.getChannel();
                     try {
                         FileChannel outChannel = toOutputStream.getChannel();
                         try {
                             MappedByteBuffer buffer = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, inChannel.size());
             
                             outChannel.write(buffer);
                         } finally {
                             outChannel.close();
                         }
                     } finally {
                         inChannel.close();
                     }
                 } finally {
                     toOutputStream.close();
                 }
             } finally {
                 fromInputStream.close();
             }
             return true;
         } catch (IOException exc) {
             return false;
         }
     }
 }