/* $Id: PersistenceManager.java 17832 2010-01-12 19:02:29Z 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) 2004-2008 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.persistence;

 import java.awt.Component;

 import java.io.ByteArrayOutputStream;

 import java.io.File;

 import java.io.PrintStream;

 import java.io.UnsupportedEncodingException;

 import java.net.URI;

 import java.net.URISyntaxException;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Iterator;

 import java.util.List;

 import javax.swing.JFileChooser;

 import javax.swing.JOptionPane;

 import javax.swing.filechooser.FileFilter;

 import org.argouml.application.api.Argo;

 import org.argouml.configuration.Configuration;

 import org.argouml.configuration.ConfigurationKey;

 import org.argouml.i18n.Translator;

 import org.argouml.kernel.Project;

 import org.tigris.gef.util.UnexpectedException;

 /**

  * This class shall be the only one that knows in which file formats

  * ArgoUML is able to save and load. And all that knowledge is

  * concentrated in the constructor... <p>

  *

  * The PersisterManager manages the list of persisters. <p>

  *

  * This class is a singleton, since this allows external modules to

  * add extra persisters to the ArgoUML application.

  *

  * @author mvw@tigris.org

  */

 public final class PersistenceManager {

     /**

      * The singleton instance.

      */

     private static final PersistenceManager INSTANCE =

         new PersistenceManager();

     private AbstractFilePersister defaultPersister;

     private List<AbstractFilePersister> otherPersisters = 

         new ArrayList<AbstractFilePersister>();

     private UmlFilePersister quickViewDump;

     private XmiFilePersister xmiPersister;

     private XmiFilePersister xmlPersister;

     private UmlFilePersister umlPersister;

     private ZipFilePersister zipPersister;

     private AbstractFilePersister savePersister;

     /**

      * The configuration key for the project file location.

      */

     public static final ConfigurationKey KEY_PROJECT_NAME_PATH =

         Configuration.makeKey("project", "name", "path");

     /**

      * The configuration key for the "open project" file location.

      */

     public static final ConfigurationKey KEY_OPEN_PROJECT_PATH =

         Configuration.makeKey("project", "open", "path");

     /**

      * The configuration key for the "import xmi" file location.

      */

     public static final ConfigurationKey KEY_IMPORT_XMI_PATH =

         Configuration.makeKey("xmi", "import", "path");

     /**

      * Create the default diagram persister.

      */

     private DiagramMemberFilePersister diagramMemberFilePersister

         = new DiagramMemberFilePersister();

     /**

      * @return returns the singleton

      */

     public static PersistenceManager getInstance() {

         return INSTANCE;

     }

     /**

      * The constructor.

      */

     private PersistenceManager() {

         // These are the file formats I know about:

         defaultPersister = new OldZargoFilePersister();

         quickViewDump = new UmlFilePersister();

         xmiPersister = new XmiFilePersister();

         otherPersisters.add(xmiPersister);

         xmlPersister = new XmlFilePersister();

         otherPersisters.add(xmlPersister);

         umlPersister = new UmlFilePersister();

         otherPersisters.add(umlPersister);

         zipPersister = new ZipFilePersister();

         otherPersisters.add(zipPersister);

     }

     /**

      * This function allows to add new persisters. This can be done e.g.

      * by plugins/modules.

      *

      * @param fp the persister

      */

     public void register(AbstractFilePersister fp) {

         otherPersisters.add(fp);

     }

     /**

      * @param name the filename

      * @return the persister

      */

     public AbstractFilePersister getPersisterFromFileName(String name) {

         if (defaultPersister.isFileExtensionApplicable(name)) {

             return defaultPersister;

         }

         for (AbstractFilePersister persister : otherPersisters) {

             if (persister.isFileExtensionApplicable(name)) {

                 return persister;

             }

         }

         return null;

     }

     /**

      * @param chooser the filechooser of which the filters will be set

      * @param fileName the filename of the file to be saved (optional)

      */

     public void setSaveFileChooserFilters(JFileChooser chooser, 

             String fileName) {

         chooser.addChoosableFileFilter(defaultPersister);

         AbstractFilePersister defaultFileFilter = defaultPersister;

         for (AbstractFilePersister fp : otherPersisters) {

             if (fp.isSaveEnabled()

                     && !fp.equals(xmiPersister)

                     && !fp.equals(xmlPersister)) {

                 chooser.addChoosableFileFilter(fp);

                 if (fileName != null 

                         && fp.isFileExtensionApplicable(fileName)) {

                     defaultFileFilter = fp;

                 }

             }

         }

         chooser.setFileFilter(defaultFileFilter);

     }

     /**

      * @param chooser the filechooser of which the filters will be set

      */

     public void setOpenFileChooserFilter(JFileChooser chooser) {

         MultitypeFileFilter mf = new MultitypeFileFilter();

         mf.add(defaultPersister);

         chooser.addChoosableFileFilter(mf);

         chooser.addChoosableFileFilter(defaultPersister);

         Iterator iter = otherPersisters.iterator();

         while (iter.hasNext()) {

             AbstractFilePersister ff = (AbstractFilePersister) iter.next();

             if (ff.isLoadEnabled()) {

                 mf.add(ff);

                 chooser.addChoosableFileFilter(ff);

             }

         }

         chooser.setFileFilter(mf);

     }

     /**

      * @param chooser the filechooser of which the filters will be set

      */

     public void setXmiFileChooserFilter(JFileChooser chooser) {

         chooser.addChoosableFileFilter(xmiPersister);

         chooser.setFileFilter(xmiPersister);

     }

     /**

      * @return the extension of the default persister

      *         (just the text, not the ".")

      */

     public String getDefaultExtension() {

         return defaultPersister.getExtension();

     }

     /**

      * @return the extension of the xmi persister

      *         (just the text, not the ".")

      */

     public String getXmiExtension() {

         return xmiPersister.getExtension();

     }

     /**

      * @param in the input file or path name which may or may not

      *           have a recognised extension

      * @return the amended file or pathname, guaranteed to have

      *         a recognised extension

      */

     public String fixExtension(String in) {

         if (getPersisterFromFileName(in) == null) {

             in += "." + getDefaultExtension();

         }

         return in;

     }

     /**

      * @param in the input file or path name which may or may not

      *           have a "xmi" extension

      * @return the amended file or pathname, guaranteed to have

      *         a "xmi" extension

      */

     public String fixXmiExtension(String in) {

         if (getPersisterFromFileName(in) != xmiPersister) {

             in += "." + getXmiExtension();

         }

         return in;

     }

     /**

      * @param in the input uri which may or may not have a recognised extension

      * @return the uri with default extension added,

      *         if it did not have a valid extension yet

      */

     public URI fixUriExtension(URI in) {

         URI newUri;

         String n = in.toString();

         n = fixExtension(n);

         try {

             newUri = new URI(n);

         } catch (java.net.URISyntaxException e) {

             throw new UnexpectedException(e);

         }

         return newUri;

     }

     /**

      * Find the base name of the given filename.<p>

      *

      * This is the name minus any valid file extension.

      * Invalid extensions are left alone.

      *

      * @param n the given file name

      * @return the name (a String) without extension

      */

     public String getBaseName(String n) {

         AbstractFilePersister p = getPersisterFromFileName(n);

         if (p == null) {

             return n;

         }

         int extLength = p.getExtension().length() + 1;

         return n.substring(0, n.length() - extLength);

     }

     /**

      * @param p the project

      * @return the basename of the project

      */

     public String getProjectBaseName(Project p) {

         URI uri = p.getUri();

         String name = Translator.localize("label.projectbrowser-title");

         if (uri != null) {

             name = new File(uri).getName();

         }

         return getBaseName(name);

     }

     /**

      * @param n the new project name

      * @param p the project that receives the name

      * @throws URISyntaxException if the URI is malformed

      */

     public void setProjectName(final String n, Project p)

         throws URISyntaxException {

         String s = "";

         if (p.getURI() != null) {

             s = p.getURI().toString();

         }

         s = s.substring(0, s.lastIndexOf("/") + 1) + n;

         setProjectURI(new URI(s), p);

     }

     /**

      * @param theUri the URI for the project

      * @param p the project that receives the URI

      */

     public void setProjectURI(URI theUri, Project p) {

         if (theUri != null) {

             theUri = fixUriExtension(theUri);

         }

         p.setUri(theUri);

     }

     /**

      * Generates a String dump of the current model for quick viewing.

      *

      * @param project The project to generate.

      * @return The whole model in a String.

      */

     public String getQuickViewDump(Project project) {

         ByteArrayOutputStream stream = new ByteArrayOutputStream();

         try {

             quickViewDump.writeProject(project, stream, null);

         } catch (Exception e) {

             // If anything goes wrong return the stack

             // trace as a string so that we get some

             // useful feedback.

             e.printStackTrace(new PrintStream(stream));

         }

         try {

             return stream.toString(Argo.getEncoding());

         } catch (UnsupportedEncodingException e) {

             return e.toString();

         }

     }

     /**

      * Get the file persister for diagrams.

      *

      * @return the diagram file persister.

      */

     DiagramMemberFilePersister getDiagramMemberFilePersister() {

             return diagramMemberFilePersister;

     }

     /**

      * Set an alternative file persister for diagrams.

      *

      * @param persister the persister to use instead of the default

      */

     public void setDiagramMemberFilePersister(

             DiagramMemberFilePersister persister) {

             diagramMemberFilePersister = persister;

     }

     /**

      * Returns true if we are allowed to overwrite the given file.

      *

      * @param overwrite if true, then the user is not asked

      * @param file the given file

      * @return true if we are allowed to overwrite the given file

      * @param frame the Component to display the confirmation dialog on

      */

     public boolean confirmOverwrite(Component frame, 

             boolean overwrite, File file) {

         if (file.exists() && !overwrite) {

             String sConfirm =

                 Translator.messageFormat(

                     "optionpane.confirm-overwrite",

                     new Object[] {file});

             int nResult =

                 JOptionPane.showConfirmDialog(

                         frame,

                         sConfirm,

                         Translator.localize(

                             "optionpane.confirm-overwrite-title"),

                         JOptionPane.YES_NO_OPTION,

                         JOptionPane.QUESTION_MESSAGE);

             if (nResult != JOptionPane.YES_OPTION) {

                 return false;

             }

         }

         return true;

     }

     /**

      * Sets the currently used persister for saving.

      * 

      * @param persister the persister

      */

     public void setSavePersister(AbstractFilePersister persister) {

         savePersister = persister;

     }

     /**

      * Gets the currently used persister for saving.

      * 

      * @return the persister or null

      */

     public AbstractFilePersister getSavePersister() {

         return savePersister;

     }

     /**

      * Figs are stored by class name and recreated by reflection. If the class

      * name changes or moves this provides a simple way of translating from

      * class name at time of save to the current class name without need for

      * XSL.

      * @param originalClassName The class name that may be in the save file

      * @param newClassName The class name to use in preference

      */

     public void addTranslation(

             final String originalClassName,

             final String newClassName) {

         getDiagramMemberFilePersister().addTranslation(

                 originalClassName,

                 newClassName);

     }

 }

 /**

  * Composite file filter which will accept any

  * file type added to it.

  */

 class MultitypeFileFilter extends FileFilter {

     private ArrayList<FileFilter> filters;

     private ArrayList<String> extensions;

     private String desc;

     /**

      * Constructor

      */

     public MultitypeFileFilter() {

         super();

         filters = new ArrayList<FileFilter>();

         extensions = new ArrayList<String>();

     }

     /**

      * Add a FileFilter to list of file filters to be accepted

      * 

      * @param filter FileFilter to be added

      */

     public void add(AbstractFilePersister filter) {

         filters.add(filter);

         String extension = filter.getExtension();

         if (!extensions.contains(extension)) {

             extensions.add(filter.getExtension());

             desc =

                 ((desc == null)

                     ? ""

                     : desc + ", ")

                 + "*." + extension;

         }

     }

     /**

      * Return all added FileFilters.

      * 

      * @return collection of FileFilters

      */

     public Collection<FileFilter> getAll() {

         return filters;

     }

     /**

      * Accept any file that any of our filters will accept.

      *

      * {@inheritDoc}

      */

     @Override

     public boolean accept(File arg0) {

         for (FileFilter ff : filters) {

             if (ff.accept(arg0)) {

                 return true;

             }

         }

         return false;

     }

     /*

      * @see javax.swing.filechooser.FileFilter#getDescription()

      */

     @Override

     public String getDescription() {

         Object[] s = {desc};

         return Translator.messageFormat("filechooser.all-types-desc", s);

     }

 }