/*
    * 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.text;
  
  import java.beans.PropertyChangeListener;
  import java.beans.PropertyChangeSupport;
  import java.io.File;
  import java.io.FileReader;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.io.Reader;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.List;
  
  import org.abstracthorizon.aequo.CompareEntry;
  import org.abstracthorizon.aequo.DefaultCompareModel;
  import org.abstracthorizon.aequo.file.FileCompareEntry;
  import org.incava.util.diff.Diff;
  import org.incava.util.diff.Difference;
  
  /**
   * Model of two sets of lines.
   *
   * @author Daniel Sendula
   */
  public class TextModel extends DefaultCompareModel<String, TextCompareEntry> {
  
      /** Read buffer size */
      public static int BUFFER_SIZE = 10240;
  
      /** Empty string */
      protected static final String EMPTY_STRING = "";
  
      /** Left file */
      protected File fileLeft;
      
      /** Right file */
      protected File fileRight;
  
      /** First difference block in model */
      protected int firstDifferenceBlock;
      
      /** Last difference block in model */
      protected int lastDifferenceBlock;
      
      /** Property change support */
      protected PropertyChangeSupport propertyChangeSupport = new PropertyChangeSupport(this);
      
      /** Is left file dirty */
      protected boolean leftFileDirty;
      
      /** Is right file dirty */
      protected boolean rightFileDirty;
      
      /** File entry this text model is created of */
      protected FileCompareEntry fileEntry;
      
      /**
       * Constructor
       * @param leftFile left file
       * @param rightFile right file
       */
      public TextModel(File leftFile, File rightFile) {
          super(2);
          this.fileLeft = leftFile;
          this.fileRight = rightFile;
      }
      
      /**
       * Constructor
       * @param fileCompareEntry file compare entry
       */
      public TextModel(FileCompareEntry fileCompareEntry) {
          this(fileCompareEntry.getData(0), fileCompareEntry.getData(1));
          this.fileEntry = fileCompareEntry;
      }
      
      /**
       * Returns left file
       * @return left file
       */
      public File getLeftFile() {
          return fileLeft;
      }
      
      /**
       * Returns right file
       * @return right file
      */
     public File getRightFile() {
         return fileRight;
     }
 
     /**
      * Has left file been changed
      * @return <code>true</code> if left file has been changed
      */
     public boolean isLeftFileDirty() {
         return leftFileDirty;
     }
     
     /**
      * Sets if left file is dirty
      * @param leftFileDirty is left file dirty
      */
     public void setLeftFileDirty(boolean leftFileDirty) {
         if (this.leftFileDirty != leftFileDirty) {
             boolean oldValue = this.leftFileDirty;
             this.leftFileDirty = leftFileDirty;
             propertyChangeSupport.firePropertyChange("leftFileDirty", oldValue, leftFileDirty);
         }
     }
     
     /**
      * Has left file been changed
      * @return <code>true</code> if left file has been changed
      */
     public boolean isRightFileDirty() {
         return rightFileDirty;
     }
     
     /**
      * Sets if right file is dirty
      * @param rightFileDirty is right file dirty
      */
     public void setRightFileDirty(boolean rightFileDirty) {
         if (this.rightFileDirty != rightFileDirty) {
             boolean oldValue = this.rightFileDirty;
             this.rightFileDirty = rightFileDirty;
             propertyChangeSupport.firePropertyChange("rightFileDirty", oldValue, rightFileDirty);
         }
     }
     
     /**
      * Sets file for given column as dirty
      * @param column column 
      */
     public void setFileDirty(int column) {
         if (column == 0) {
             setLeftFileDirty(true);
         } else if (column == 1) {
             setRightFileDirty(true);
         }
     }
     
     /**
      * Refreshes file entry with new status if different after comparing
      */
     protected void refreshFileEntry() {
         if (getSize() > 0) {
             boolean equals = true;
             int i = 0;
             while (equals && (i < getSize())) {
                 CompareEntry<String> entry = get(i);
                 i++;
                 equals = ((entry.getStatus(0) == entry.getStatus(1)) && (entry.getStatus(0) == CompareEntry.EQUAL));
             }
             
             if (equals) {
                 if ((fileEntry.getStatus(0) != CompareEntry.EQUAL)
                     || (fileEntry.getStatus(1) != CompareEntry.EQUAL)) {
                     fileEntry.setStatus(0, CompareEntry.EQUAL);
                     fileEntry.setStatus(1, CompareEntry.EQUAL);
                     fileEntry.updateEntryStatus(true);
                 }
             } else {
                 if ((fileEntry.getStatus(0) == CompareEntry.EQUAL)
                     || (fileEntry.getStatus(1) == CompareEntry.EQUAL)) {
     
                     fileEntry.setStatus(0, CompareEntry.DIFFERENT);
                     fileEntry.setStatus(1, CompareEntry.DIFFERENT);
                     fileEntry.updateEntryStatus(true);
                 }
             }
         }
     }
     
     /* Property support */
     
     /**
      * Adds property change listener
      * @param listener listener
      */
     public void addPropertyChangeListener(PropertyChangeListener listener) {
         propertyChangeSupport.addPropertyChangeListener(listener);
     }
     
     /**
      * Adds property change listener
      * @param propertyName property name
      * @param listener listener
      */
     public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
         propertyChangeSupport.addPropertyChangeListener(propertyName, listener);
     }
     
     /**
      * Removes property change listener
      * @param listener listener
      */
     public void removePropertyChangeListener(PropertyChangeListener listener) {
         propertyChangeSupport.removePropertyChangeListener(listener);
     }
     
     /**
      * Removes property change listener
      * @param propertyName property name
      * @param listener listener
      */
     public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
         propertyChangeSupport.removePropertyChangeListener(propertyName, listener);
     }
 
     
     /* Methods */
     
     /**
      * Saves changes of both files
      * @throws IOException
      */
     public void saveAll() throws IOException {
         saveLeft();
         saveRight();
     }
 
     /**
      * Saves left file
      * @throws IOException
      */
     public void saveLeft() throws IOException {
         if (fileLeft == null) {
             throw new IllegalArgumentException("File name is not suppliled");
         }
         List<String> dataLeft = getAsList(0);
         saveFile(fileLeft, dataLeft);
         setLeftFileDirty(false);
         if (fileEntry != null) {
             refreshFileEntry();
         }
     }
 
 
     /**
      * Saves right file
      * @throws IOException
      */
     public void saveRight() throws IOException {
         if (fileRight == null) {
             throw new IllegalArgumentException("File name is not suppliled");
         }
         List<String> dataRight = getAsList(1);
         saveFile(fileRight, dataRight);
         setRightFileDirty(false);
         if (fileEntry != null) {
             refreshFileEntry();
         }
     }
 
     /**
      * Loads both files
      * @throws IOException
      */
     public void load() throws IOException {
 
         final List<String> dataLeft = loadFile(fileLeft);
         final List<String> dataRight = loadFile(fileRight);
         refresh(dataLeft, dataRight);
         setLeftFileDirty(false);
         setRightFileDirty(false);
         if (fileEntry != null) {
             refreshFileEntry();
         }
     }
     
     /**
      * Refreshes the model by comparing two data lists
      * @param dataLeft left list
      * @param dataRight right list
      */
     public void refresh(final List<String> dataLeft, final List<String> dataRight) {
         entries.clear();
         Runnable process = new Runnable() {
 
             int ls = 0;
             int rs = 0;
             int le = 0;
             int re = 0;
 
             int l = 0;
             int r = 0;
 
             public void run() {
                 Diff<String> diff = new Diff<String>(dataLeft, dataRight);
                 List<Difference> diffs = diff.diff();
 
                 for (Difference d : diffs) {
                     rs = d.getAddedStart();
                     ls = d.getDeletedStart();
                     progressTo(ls, rs);
 
                     re = d.getAddedEnd();
                     le = d.getDeletedEnd();
                     progressTo(le, re);
                 }
 
                 int s1 = dataLeft.size();
                 int s2 = dataRight.size();
 
                 progressTo(s1, s2);
 
             }
 
             protected void progressTo(int le, int re) {
                 while ((le > l) || (re > r)) {
                     TextCompareEntry entry;
                     if ((le > l) && (re > r)) {
                         entry = new TextCompareEntry(new String[]{dataLeft.get(l), dataRight.get(r)}, new int[]{l, r});
                         entry.updateEntryStatus();
                         l = l + 1;
                         r = r + 1;
                     } else if (le > l) {
                         entry = new TextCompareEntry(new String[]{dataLeft.get(l), null}, new int[]{l, r});
                         entry.updateEntryStatus();
                         l = l + 1;
                     } else {
                         entry = new TextCompareEntry(new String[]{null, dataRight.get(r)}, new int[]{l, r});
                         entry.updateEntryStatus();
                         r = r + 1;
                     }
                     addImpl(entry);
                 }
             }
         };
 
         process.run();
     }
 
     
     /**
      * Refreshes the model by comparing two data lists
      * @param dataLeft left list
      * @param dataRight right list
      */
     public void refreshRange(final int start, final int end) {
         Runnable process = new Runnable() {
 
             int ls = 0;
             int rs = 0;
             int le = 0;
             int re = 0;
 
             int l = 0;
             int r = 0;
 
             List<String> dataLeft;
             List<String> dataRight;
             
             public void run() {
                 dataLeft = getAsSubList(0, start, end);
                 dataRight = getAsSubList(1, start, end);
 
                 for (int i = end; i >= start; i--) {
                     removeImpl(i);
                 }
                 
                 int current = start;
                 
                 Diff<String> diff = new Diff<String>(dataLeft, dataRight);
                 List<Difference> diffs = diff.diff();
 
                 for (Difference d : diffs) {
                     rs = d.getAddedStart();
                     ls = d.getDeletedStart();
                     current = progressTo(current, ls, rs);
 
                     re = d.getAddedEnd();
                     le = d.getDeletedEnd();
                     current = progressTo(current, le, re);
                 }
 
                 int s1 = dataLeft.size();
                 int s2 = dataRight.size();
 
                 current = progressTo(current, s1, s2);
                 updateLineNumbers(start, end);
                 getSelectionModel().setSelectionInterval(start, current - 1);
             }
 
             protected int progressTo(int current, int le, int re) {
                 while ((le > l) || (re > r)) {
                     TextCompareEntry entry;
                     int[] lineNumbers = new int[]{-1, -1};
                     if ((le > l) && (re > r)) {
                         entry = new TextCompareEntry(new String[]{dataLeft.get(l), dataRight.get(r)}, lineNumbers);
                         entry.updateEntryStatus();
                         l = l + 1;
                         r = r + 1;
                     } else if (le > l) {
                         entry = new TextCompareEntry(new String[]{dataLeft.get(l), null}, lineNumbers);
                         entry.updateEntryStatus();
                         l = l + 1;
                     } else {
                         entry = new TextCompareEntry(new String[]{null, dataRight.get(r)}, lineNumbers);
                         entry.updateEntryStatus();
                         r = r + 1;
                     }
                     addImpl(current, entry);
                     current++;
                 }
                 return current;
             }
         };
 
         process.run();
     }
 
     /**
      * Saves given list to a file
      * @param file file
      * @param data list
      * @throws IOException
      */
     public static void saveFile(File file, List<String> data) throws IOException {
         FileWriter fileWriter = new FileWriter(file);
         try {
             for (String line : data) {
                 fileWriter.write(line);
                 fileWriter.write('\n');
             }
         } finally {
             fileWriter.close();
         }
     }
 
     /**
      * Loads file to a list
      * @param file file
      * @return file as a list of lines
      * @throws IOException
      */
     public static List<String> loadFile(File file) throws IOException {
         if (file.exists() && file.isFile()) {
             FileReader in = new FileReader(file);
             return loadFile(in);
         } else {
             return Collections.emptyList();
         }
     }
 
     /**
      * Loads lines from a reader to a list
      * @param in reader
      * @return list of lines
      * @throws IOException
      */
     public static List<String> loadFile(Reader in) throws IOException {
         ArrayList<String> list = new ArrayList<String>();
 
         StringBuffer sb = null;
         char buf[] = new char[BUFFER_SIZE];
         try {
             int start = 0;
             int r = in.read(buf);
             while (r > 0) {
                 int i = 0;
                 while (i < r) {
                     if (buf[i] == '\n') {
                         if (i == start) {
                             if (sb == null) {
                                 list.add(EMPTY_STRING);
                             } else {
                                 list.add(sb.toString());
                                 sb = null;
                             }
                         } else {
                             if (sb == null) {
                                 list.add(new String(buf, start, i - start));
                             } else {
                                 sb.append(buf, start, i - start);
                                 list.add(sb.toString());
                                 sb = null;
                             }
                         }
 
                         start = i + 1;
                     }
                     i = i + 1;
                 } // while
 
                 if (start < r) {
                     if (sb == null) {
                         sb = new StringBuffer(buf.length - start + (buf.length - start) / 2);
                         sb.append(buf, start, buf.length - start);
                     }
                     start = 0;
                 }
                 r = in.read(buf);
             } // while
         } finally {
             in.close();
         }
 
         return list;
     }
     
     /**
      * Updates line numbers with in given range
      * @param start start index
      * @param end end index. Can be -1 which means to the end of the list
      */
     public void updateLineNumbers(int start, int end) {
         if (end < 0) {
             end = getSize() - 1;
         }
         int leftLineNumber = 1;
         int rightLineNumber = 1;
         if (start > 0) {
             TextCompareEntry entry = get(start -1);
             leftLineNumber = entry.getLineNumber(0) + 1;
             rightLineNumber = entry.getLineNumber(1) + 1;
         }
         for (int i = start; i <= end; i++) {
             TextCompareEntry entry = get(i);
             entry.setLineNumber(0, leftLineNumber);
             entry.setLineNumber(1, rightLineNumber);
             if (entry.getData(0) != null) {
                 leftLineNumber++;
             }
             if (entry.getData(1) != null) {
                 rightLineNumber++;
             }
         }
     }
 
 }