/*
    * 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.IOException;
  import java.io.StringWriter;
  
  import javax.swing.Action;
  import javax.swing.JOptionPane;
  import javax.swing.KeyStroke;
  import javax.swing.ListSelectionModel;
  import javax.swing.ProgressMonitor;
  
  import org.abstracthorizon.aequo.CompareEntry;
  import org.abstracthorizon.aequo.file.FileCompareEntry;
  import org.abstracthorizon.aequo.file.FilesModel;
  
  /**
   * Copy to other side action.
   *
   * @author Daniel Sendula
   */
  public class BinaryComparisonAction extends FileBaseAction {
  
      /** Default buffer size */
      public static final int DEFAULT_BUFFER_SIZE = 10240;
      // TODO move this to global context
      
      /**
       * Constructor
       */
      public BinaryComparisonAction() {
          setName("Compare Contents");
          setMessage("Comparing contents");
          setDescription("Comparing contents");
          putValue(Action.MNEMONIC_KEY, KeyEvent.VK_C);
          putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_SLASH, ActionEvent.SHIFT_MASK));
      }
  
      /**
       * Returns if selection is valid
       * @return <code>true</code> if selection is valid<
       */
      public boolean isEnabled() {
          return isSelectionValid();
      }
      
      /**
       * Compares two sets of 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[0]; // TODO 0 and 1? Should be all... or loop... or something
                  File toFile = data[1];
                  monitor.setNote(fromFile.getAbsolutePath() + " to " + toFile.getAbsolutePath());
                  if (fromFile.exists() && toFile.exists() && fromFile.isFile() && toFile.isFile()) {
                      try {
                         if (same(fromFile, toFile)) {
                             if ((entry.getStatus(0) != CompareEntry.EQUAL) 
                                 || (entry.getStatus(1) != CompareEntry.EQUAL)) {
                                 entry.setStatus(0, CompareEntry.EQUAL);
                                 entry.setStatus(1, CompareEntry.EQUAL);
                                 entry.updateEntryStatus(true);
                             }
                         } else {
                             if ((entry.getStatus(0) == CompareEntry.EQUAL) 
                                     || (entry.getStatus(1) == CompareEntry.EQUAL)) {
                                 entry.setStatus(0, CompareEntry.DIFFERENT);
                                 entry.setStatus(1, CompareEntry.DIFFERENT);
                                 entry.updateEntryStatus(true);
                             }
                         }
                     } catch (IOException ignore) {
                         // TODO is that ok?
                     }
                 }
                 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);
         }
     }
 
     /**
      * Checks if two files are the same
      * @param f1 first file
      * @param f2 second file
      * @return <code>true</cod> if two files are the same
      * @throws IOException
      */
     public static boolean same(File f1, File f2) throws IOException {
         FileInputStream fis1 = new FileInputStream(f1);
         try {
             FileInputStream fis2 = new FileInputStream(f2);
             try {
                 return same(fis1, fis2);
             } finally {
                 fis2.close();
             }
         } finally {
             fis1.close();
         }
     }
 
     /**
      * Checks if two streams are the same. It doesn't close the streams
      * @param f1 first file
      * @param f2 second file
      * @return <code>true</cod> if two files are the same
      * @throws IOException
      */
     public static boolean same(FileInputStream fis1, FileInputStream fis2) throws IOException {
         byte[] buf1 = new byte[DEFAULT_BUFFER_SIZE];
         byte[] buf2 = new byte[DEFAULT_BUFFER_SIZE];
 
         int r1 = fis1.read(buf1);
         int r2 = fis2.read(buf2);
         while ((r1 == r2) && (r1 >= 0) && equals(buf1, buf2, r1)) {
             r1 = fis1.read(buf1);
             r2 = fis2.read(buf2);
         }
         if ((r1 == r2) && (r1 < 0)) {
             return true;
         } else {
             return false;
         }
     }
 
     /**
      * Checks if two arrays of bytes are the same
      * @param a1 first array
      * @param a2 second array
      * @param len number of bytes in the array
      * @return <code>true</code> if they are the same
      */
     public static boolean equals(byte[] a1, byte[] a2, int len) {
         for (int i = 0; i < len; i++) {
             if (a1[i] != a2[i]) {
                 return false;
             }
         }
         return true;
     }
 
 
 }