/* $Id: ImportCommon.java 17870 2010-01-12 20:49:32Z linus $

  *****************************************************************************

  * Copyright (c) 2009 Contributors - see below

  * 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:

  *    bobtarling

  *****************************************************************************

  *

  * Some portions of this file was previously release using the BSD License:

  */

 // Copyright (c) 2006, 2009 The Regents of the University of California. All

 // Rights Reserved. Permission to use, copy, modify, and distribute this

 // software and its documentation without fee, and without a written

 // agreement is hereby granted, provided that the above copyright notice

 // and this paragraph appear in all copies. This software program and

 // documentation are copyrighted by The Regents of the University of

 // California. The software program and documentation are supplied "AS

 // IS", without any accompanying services from The Regents. The Regents

 // does not warrant that the operation of the program will be

 // uninterrupted or error-free. The end-user understands that the program

 // was developed for research purposes and is advised not to rely

 // exclusively on the program for any reason. IN NO EVENT SHALL THE

 // UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,

 // SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,

 // ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF

 // THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF

 // SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY

 // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE

 // PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF

 // CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT,

 // UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

 package org.argouml.uml.reveng;

 import java.io.File;

 import java.io.PrintWriter;

 import java.io.StringWriter;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.HashSet;

 import java.util.Hashtable;

 import java.util.List;

 import java.util.StringTokenizer;

 import org.argouml.application.api.Argo;

 import org.argouml.cognitive.Designer;

 import org.argouml.configuration.Configuration;

 import org.argouml.i18n.Translator;

 import org.argouml.kernel.Project;

 import org.argouml.kernel.ProjectManager;

 import org.argouml.model.Model;

 import org.argouml.taskmgmt.ProgressMonitor;

 import org.argouml.ui.explorer.ExplorerEventAdaptor;

 import org.argouml.ui.targetmanager.TargetManager;

 import org.argouml.uml.diagram.ArgoDiagram;

 import org.argouml.uml.diagram.static_structure.ClassDiagramGraphModel;

 import org.argouml.uml.diagram.static_structure.layout.ClassdiagramLayouter;

 import org.argouml.util.SuffixFilter;

 import org.tigris.gef.base.Globals;

 /**

  * Source language import class - GUI independent superclass.

  * <p>

  * Specific Swing and SWT/Eclipse importers will extend this class.

  * <p>

  * <em>NOTE:</em>Any change to the public API here must be tested in both Swing

  * (standalone ArgoUML) and Eclipse (ArgoEclipse) environments.

  * 

  * @author Tom Morris

  */

 public abstract class ImportCommon implements ImportSettingsInternal {

     /**

      * The % maximum progress required to preparing for import.

      */

     protected static final int MAX_PROGRESS_PREPARE = 1;

     /**

      * The % maximum progress required to import.

      */

     protected static final int MAX_PROGRESS_IMPORT = 99;

     protected static final int MAX_PROGRESS = MAX_PROGRESS_PREPARE

             + MAX_PROGRESS_IMPORT;

     /**

      * keys are module name, values are PluggableImport instance.

      */

     private Hashtable<String, ImportInterface> modules;

     /**

      * Current language module.

      */

     private ImportInterface currentModule;

     /**

      * Imported directory.

      */

     private String srcPath;

     /**

      * Create a interface to the current diagram.

      */

     private DiagramInterface diagramInterface;

     private File[] selectedFiles;

     private SuffixFilter selectedSuffixFilter;

     protected ImportCommon() {

         super();

         modules = new Hashtable<String, ImportInterface>();

         for (ImportInterface importer : ImporterManager.getInstance()

                 .getImporters()) {

             modules.put(importer.getName(), importer);

         }

         if (modules.isEmpty()) {

             throw new RuntimeException("Internal error. "

                     + "No importer modules found.");

         }

         // "Java" is the default module for historical reasons,

         // but it's not required to be there

         currentModule = modules.get("Java");

         if (currentModule == null) {

             currentModule = modules.elements().nextElement();

         }

     }

     /*

      * @see org.argouml.uml.reveng.ImportSettings#getImportLevel()

      */

     public abstract int getImportLevel();

     /**

      * Compute and cache the current diagram interface.

      */

     protected void initCurrentDiagram() {

         diagramInterface = getCurrentDiagram();

     }

     /**

      * Set target diagram.<p>

      *

      * @return selected diagram, if it is class diagram,

      * else return null.

      */

     private DiagramInterface getCurrentDiagram() {

         DiagramInterface result = null;

         if (Globals.curEditor().getGraphModel()

                 instanceof ClassDiagramGraphModel) {

             result =  new DiagramInterface(Globals.curEditor());

         } else {

             Project p =  ProjectManager.getManager().getCurrentProject();

             TargetManager.getInstance().setTarget(p.getInitialTarget());

             // the previous line helps, but we better check again:

             if (Globals.curEditor().getGraphModel()

                     instanceof ClassDiagramGraphModel) {

                 result =  new DiagramInterface(Globals.curEditor());

             }

         }

         return result;

     }

     /*

      * @see org.argouml.uml.reveng.ImportSettings#getInputSourceEncoding()

      */

     public abstract String getInputSourceEncoding();

     /**

      * Get the files.  We generate it based on their specified

      * file suffixes.

      * @param monitor progress monitor which can be used to cancel long running 

      * request

      * @return the list of files to be imported

      */

     protected List<File> getFileList(ProgressMonitor monitor) {

         List<File> files = Arrays.asList(getSelectedFiles());

         if (files.size() == 1) {

             File file = files.get(0);

             SuffixFilter suffixFilters[] = {selectedSuffixFilter};

             if (suffixFilters[0] == null) {

                 // not a SuffixFilter selected, so we take all

                 suffixFilters = currentModule.getSuffixFilters();

             }

             files =

                 FileImportUtils.getList(

                         file, isDescendSelected(),

                         suffixFilters, monitor);

             if (file.isDirectory()) {

                 setSrcPath(file.getAbsolutePath());

             } else {

                 setSrcPath(null);

             }

         }

         if (isChangedOnlySelected()) {

             // filter out all unchanged files

             Object model =

                 ProjectManager.getManager().getCurrentProject().getModel();

             for (int i = files.size() - 1; i >= 0; i--) {

                 File f = files.get(i);

                 String fn = f.getAbsolutePath();

                 String lm = String.valueOf(f.lastModified());

                 if (Model.getFacade().getUmlVersion().charAt(0) == '1') {

                     // TODO: Not yet working for UML2

                     if (lm.equals(

                             Model.getFacade().getTaggedValueValue(model, fn))) {

                         files.remove(i);

                     }

                 }

             }

         }

         return files;

     }

     /**

      * Set path for processed directory.

      *

      * @param path the given path

      */

     public void setSrcPath(String path) {

         srcPath = path;

     }

     /**

      * @return path for processed directory.

      */

     public String getSrcPath() {

         return srcPath;

     }

     /*

      * Create a TaggedValue with a tag/type matching our source module

      * filename and a value of the file's last modified timestamp.

      *

      * TODO: This functionality needs to be moved someplace useful if

      * it's needed, otherwise it can be deleted. - tfm - 20070217

      */

     private void setLastModified(Project project, File file) {

         // set the lastModified value

         String fn = file.getAbsolutePath();

         String lm = String.valueOf(file.lastModified());

         if (lm != null) {

             Model.getCoreHelper()

                 .setTaggedValue(project.getModel(), fn, lm);

         }

     }

     /*

      * @see org.argouml.uml.reveng.ImportSettings#isCreateDiagramsSelected()

      */

     public abstract boolean isCreateDiagramsSelected();

     /*

      * @see org.argouml.uml.reveng.ImportSettings#isMinimiseFigsSelected()

      */

     public abstract boolean isMinimizeFigsSelected();

     /*

      * @see org.argouml.uml.reveng.ImportSettingsInternal#isDiagramLayoutSelected()

      */

     public abstract boolean isDiagramLayoutSelected();

     /*

      * @see org.argouml.uml.reveng.ImportSettingsInternal#isDescendSelected()

      */

     public abstract boolean isDescendSelected();

     /*

      * @see org.argouml.uml.reveng.ImportSettingsInternal#isChangedOnlySelected()

      */

     public abstract boolean isChangedOnlySelected();

     /**

      * Gets the specified import module.

      * 

      * @param importerName The import module's name

      * @return The found import module, otherwise null

      */

     public ImportInterface getImporter(String importerName) {

         return getModules().get(importerName);

     }

     /**

      * Sets the files that will be imported.

      * 

      * @param files The array of files.

      */

     public void setFiles(File[] files) {

         if (files != null) {

             setSelectedFiles(files);

         }

     }

     protected Hashtable<String, ImportInterface> getModules() {

         return modules;

     }

     protected void setSelectedFiles(final File[] files) {

         selectedFiles = files;

     }

     /**

      * Set the selected (file) suffix filter.

      * 

      * @param suffixFilter the (file) suffix filter

      */

     protected void setSelectedSuffixFilter(final SuffixFilter suffixFilter) {

         selectedSuffixFilter = suffixFilter;

     }

     protected File[] getSelectedFiles() {

         File[] copy = new File[selectedFiles.length];

         for (int i = 0; i < selectedFiles.length; i++) {

             copy[i] = selectedFiles[i];

         }

         return copy;

         //return Arrays.copyOf(selectedFiles, selectedFiles.length);

     }

     /**

      * Sets the current import module.

      * 

      * @param module

      */

     public void setCurrentModule(ImportInterface module) {

         currentModule = module;

     }

     protected ImportInterface getCurrentModule() {

         return currentModule;

     }

     /**

      * Returns the possible languages in which the user can import the sources.

      * @return a list of Strings with the names of the languages available

      */

     public List<String> getLanguages() {

         return Collections.unmodifiableList(

                 new ArrayList<String>(modules.keySet()));

     }

     /**

      * The flag for: descend directories recursively.

      * This should be asked by the GUI for initialization.

      * @return the flag stored in KEY_IMPORT_GENERAL_SETTINGS_FLAGS key or

      * true if this is null.

      */

     public boolean isDescend() {

         String flags =

                 Configuration.getString(

                         Argo.KEY_IMPORT_GENERAL_SETTINGS_FLAGS);

         if (flags != null && flags.length() > 0) {

             StringTokenizer st = new StringTokenizer(flags, ",");

             if (st.hasMoreTokens() && st.nextToken().equals("false")) {

                 return false;

             }

         }

         return true;

     }

     /**

      * The flag for: changed/new files only.

      * This should be asked by the GUI for initialization.

      * @return the flag stored in KEY_IMPORT_GENERAL_SETTINGS_FLAGS key or

      * true if this is null.

      */

     public boolean isChangedOnly() {

         String flags =

                 Configuration.getString(Argo.KEY_IMPORT_GENERAL_SETTINGS_FLAGS);

         if (flags != null && flags.length() > 0) {

             StringTokenizer st = new StringTokenizer(flags, ",");

             skipTokens(st, 1);

             if (st.hasMoreTokens() && st.nextToken().equals("false")) {

                 return false;

             }

         }

         return true;

     }

     /**

      * The flag for: create diagrams from imported code.

      * This should be asked by the GUI for initialization.

      * @return the flag stored in KEY_IMPORT_GENERAL_SETTINGS_FLAGS key or

      * true if this is null.

      */

     public boolean isCreateDiagrams() {

         String flags =

                 Configuration.getString(

                         Argo.KEY_IMPORT_GENERAL_SETTINGS_FLAGS);

         if (flags != null && flags.length() > 0) {

             StringTokenizer st = new StringTokenizer(flags, ",");

             skipTokens(st, 2);

             if (st.hasMoreTokens() && st.nextToken().equals("false")) {

                 return false;

             }

         }

         return true;

     }

     /**

      * The flag for: minimise class icons in diagrams.

      * This should be asked by the GUI for initialization.

      * @return the flag stored in KEY_IMPORT_GENERAL_SETTINGS_FLAGS key or

      * true if this is null.

      */

     public boolean isMinimizeFigs() {

         String flags =

                 Configuration.getString(

                         Argo.KEY_IMPORT_GENERAL_SETTINGS_FLAGS);

         if (flags != null && flags.length() > 0) {

             StringTokenizer st = new StringTokenizer(flags, ",");

             skipTokens(st, 3);

             if (st.hasMoreTokens() && st.nextToken().equals("false")) {

                 return false;

             }

         }

         return true;

     }

     private void skipTokens(StringTokenizer st, int count) {

         for (int i = 0; i < count; i++) {

             if (st.hasMoreTokens()) {

                 st.nextToken();

             }

         }

     }

     /**

      * The flag for: perform automatic diagram layout.

      * This should be asked by the GUI for initialization.

      * @return the flag stored in KEY_IMPORT_GENERAL_SETTINGS_FLAGS key or

      * true if this is null.

      */

     public boolean isDiagramLayout() {

         String flags =

                 Configuration.getString(

                         Argo.KEY_IMPORT_GENERAL_SETTINGS_FLAGS);

         if (flags != null && flags.length() > 0) {

             StringTokenizer st = new StringTokenizer(flags, ",");

             skipTokens(st, 4);

             if (st.hasMoreTokens() && st.nextToken().equals("false")) {

                 return false;

             }

         }

         return true;

     }

     /**

      * The default encoding. This should be asked by the GUI for

      * initialization.

      * @return the encoding stored in Argo.KEY_INPUT_SOURCE_ENCODING key or if

      * this is null the default system encoding

      */

     public String getEncoding() {

         String enc = Configuration.getString(Argo.KEY_INPUT_SOURCE_ENCODING);

         if (enc == null || enc.trim().equals("")) { //$NON-NLS-1$

             enc = System.getProperty("file.encoding"); //$NON-NLS-1$

         }

         return enc;

     }

     /**

      * Layouts the diagrams.

      *

      * @param monitor

      *            the progress meter.  Null if not progress updates desired.

      * @param startingProgress

      *            the actual progress until now

      */

     public void layoutDiagrams(ProgressMonitor monitor, int startingProgress) {

         if (diagramInterface == null) {

             return;

         }

 //        if (monitor != null) {

 //            monitor.updateSubTask(ImportsMessages.layoutingAction);

 //        }

         List<ArgoDiagram> diagrams = diagramInterface.getModifiedDiagramList();

         int total = startingProgress + diagrams.size()

                 / 10;

         for (int i = 0; i < diagrams.size(); i++) {

             ArgoDiagram diagram = diagrams.get(i);

             ClassdiagramLayouter layouter = new ClassdiagramLayouter(diagram);

             layouter.layout();

             int act = startingProgress + (i + 1) / 10;

             int progress = MAX_PROGRESS_PREPARE

                     + MAX_PROGRESS_IMPORT * act / total;

             if (monitor != null) {

                 monitor.updateProgress(progress);

             }

 //          iss.setValue(countFiles + (i + 1) / 10);

         }

     }

     /**

      * Import the selected source files. It calls the actual

      * parser methods depending on the type of the file.

      *

      * @param monitor

      *            a ProgressMonitor to both receive progress updates and to be

      *            polled for user requests to cancel.

      */

     public void doImport(ProgressMonitor monitor) {

         // Roughly equivalent to and derived from old Import.doFile()

         monitor.setMaximumProgress(MAX_PROGRESS);

         int progress = 0;

         monitor.updateSubTask(Translator.localize("dialog.import.preImport"));

         List<File> files = getFileList(monitor);

         progress += MAX_PROGRESS_PREPARE;

         monitor.updateProgress(progress);

         if (files.size() == 0) {

             monitor.notifyNullAction();

             return;

         }

         Model.getPump().stopPumpingEvents();

         boolean criticThreadWasOn = Designer.theDesigner().getAutoCritique();

         if (criticThreadWasOn) {

             Designer.theDesigner().setAutoCritique(false);

         }

         try {

             doImportInternal(files, monitor, progress);

         } finally {

             if (criticThreadWasOn) {

                 Designer.theDesigner().setAutoCritique(true);

             }

             // TODO: Send an event instead of calling Explorer directly

             ExplorerEventAdaptor.getInstance().structureChanged();

             Model.getPump().startPumpingEvents();

         }

     }

     /**

      * Do the import.

      * @param filesLeft the files to parse

      * @param monitor the progress meter

      * @param progress the actual progress until now

      */

     private void doImportInternal(List<File> filesLeft,

             final ProgressMonitor monitor, int progress) {

         Project project =  ProjectManager.getManager().getCurrentProject();

         initCurrentDiagram();

         final StringBuffer problems = new StringBuffer();

         Collection newElements = new HashSet();

         try {

             newElements.addAll(currentModule.parseFiles(

                     project, filesLeft, this, monitor));

         } catch (Exception e) {

             problems.append(printToBuffer(e));

         }

         // New style importers don't create diagrams, so we'll do it

         // based on the list of newElements that they created

         if (isCreateDiagramsSelected() && diagramInterface != null) {

             addFiguresToDiagrams(newElements);

         }

         // Do layout even if problems occurred during import

         if (isDiagramLayoutSelected()) {

             // TODO: Monitor is getting dismissed before layout is complete

             monitor.updateMainTask(

                     Translator.localize("dialog.import.postImport"));

             monitor.updateSubTask(

                     Translator.localize("dialog.import.layoutAction"));

             layoutDiagrams(monitor, progress + filesLeft.size());

         }

         // Add messages from caught exceptions

         if (problems != null && problems.length() > 0) {

             monitor.notifyMessage(

                     Translator.localize(

                             "dialog.title.import-problems"), //$NON-NLS-1$

                             Translator.localize(

                             "label.import-problems"),        //$NON-NLS-1$

                             problems.toString());

         }

         monitor.updateMainTask(Translator.localize("dialog.import.done"));

         monitor.updateSubTask(""); //$NON-NLS-1$

         monitor.updateProgress(MAX_PROGRESS);

     }

     /**

      * Create diagram figures for a collection of model elements.

      *

      * @param newElements

      *            the collection of elements for which figures should be

      *            created.

      */

     private void addFiguresToDiagrams(Collection newElements) {

         for (Object element : newElements) {

             if (Model.getFacade().isAClassifier(element)

                     || Model.getFacade().isAPackage(element)) {

                 Object ns = Model.getFacade().getNamespace(element);

                 if (ns == null) {

                     diagramInterface.createRootClassDiagram();

                 } else {

                     String packageName = getQualifiedName(ns);

                     // Select the correct diagram (implicitly creates it)

                     if (packageName != null

                             && !packageName.equals("")) {

                         diagramInterface.selectClassDiagram(ns,

                                 packageName);

                     } else {

                         diagramInterface.createRootClassDiagram();

                     }

                     // Add the element to the diagram

                     if (Model.getFacade().isAInterface(element)) {

                         diagramInterface.addInterface(element,

                                 isMinimizeFigsSelected());

                     } else if (Model.getFacade().isAClass(element)) {

                         diagramInterface.addClass(element,

                                 isMinimizeFigsSelected());

                     } else if (Model.getFacade().isAPackage(element)) {

                         diagramInterface.addPackage(element);

                     }

                 }

             }

         }

     }

     /**

      * Return the fully qualified name of a model element in Java (dot

      * separated) format.

      * <p>

      * TODO: We really need a language independent format here. Perhaps the list

      * of names that form the hierarchy? - tfm

      */

     private String getQualifiedName(Object element) {

         StringBuffer sb = new StringBuffer();

         Object ns = element;

         while (ns != null) {

             String name = Model.getFacade().getName(ns);

             if (name == null) {

                 name = "";

             }

             sb.insert(0, name);

             ns = Model.getFacade().getNamespace(ns);

             if (ns != null) {

                 sb.insert(0, ".");

             }

         }

         return sb.toString();

     }

     /*

      * Print an exception trace to a string buffer

      */

     private StringBuffer printToBuffer(Exception e) {

         StringWriter sw = new StringWriter();

         PrintWriter pw = new java.io.PrintWriter(sw);

         e.printStackTrace(pw);

         return sw.getBuffer();

     }

 }