source: trunk/gli/src/org/greenstone/gatherer/gems/MetadataSetManager.java@ 8809

/**
 *#########################################################################
 *
 * A component of the Gatherer application, part of the Greenstone digital
 * library suite from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * <BR><BR>
 *
 * Author: John Thompson, Greenstone Digital Library, University of Waikato
 *
 * <BR><BR>
 *
 * Copyright (C) 1999 New Zealand Digital Library Project
 *
 * <BR><BR>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * <BR><BR>
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * <BR><BR>
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *########################################################################
 */
package org.greenstone.gatherer.gems;

import java.io.*;
import java.util.*;
import java.util.StringTokenizer;
import javax.swing.*;
import javax.swing.filechooser.*;
import javax.swing.tree.TreePath;
import org.greenstone.gatherer.Configuration;
import org.greenstone.gatherer.DebugStream;
import org.greenstone.gatherer.util.Utility;
import org.greenstone.gatherer.collection.CollectionManager;
import org.greenstone.gatherer.file.*;
import org.greenstone.gatherer.util.XMLTools;
import org.apache.xerces.parsers.*;
import org.apache.xml.serialize.*;
import org.w3c.dom.*;
import org.xml.sax.*;

/** This class is responsible for managing all the metadata sets in the collection and for providing methods for manipulating the aforementioned sets contents. 
 * @author John Thompson, Greenstone Digital Library, University of Waikato
 * @version 2.3b
 */
public class MetadataSetManager {

    /** The character used to separate name space from metadata element. */
    static public char NS_SEP= '.';
    /** The character used to separate subfields from metadata element. */
    static public String SF_SEP= "#";

    /** The name of the hidden, or system, metadata set. */
    static final public String HIDDEN = "hidden";
    static final public int MAX_LOADED_SETS = 64;
    static public CollectionManager col_man = null;
    /** A mapping from metadata namespace to metadata set. */
    static private Hashtable mds_hashtable = new Hashtable();
    public GEMS gemsptr;
    
    /** The profiler is responsible for remembering what actions a user has requested when importing metadata, so as to prevent the user needlessly re-entering this information for each import. */
    // public MSMProfiler profiler = null;


    /** Constructor. */
    public MetadataSetManager(GEMS gemscopy) {
        gemsptr = gemscopy;
        col_man = new CollectionManager();
    }


    public MetadataSet addSet(String namespace, String name) {
    MetadataSet mds = new MetadataSet(GEMS.METADATA_SET_TEMPLATE);
    mds.setAttribute("creator", "The Greenstone Librarian Interface");
    // Calculate lastchanged to right now on this machine by this user
    String user_name = System.getProperty("user.name");
    String machine_name = Utility.getMachineName();
    mds.setAttribute("lastchanged", Utility.getDateString() + " - " + user_name + " on " + machine_name);
    // And the remaining attributes.
    //mds.setAttribute("name", name);
    mds.setAttribute("namespace", namespace);
    // Add the name element.
    mds.setName(name);
    // this is the location for a global metadata set
    File mds_file = new File(Utility.METADATA_DIR, namespace + ".mds");
    mds.setFile(mds_file);
    mds_hashtable.put(namespace, mds);
    // fireSetChanged(mds);
    return mds;
    }
    public Vector getVectorSets() {   
        Vector sets = new Vector();
        
        File metadata_directory = new File(Utility.METADATA_DIR);
    if (metadata_directory.exists()) {
        // Load just those .mds files in this directory, and return them
        File[] directory_files = metadata_directory.listFiles();
        for (int i = 0; i < directory_files.length; i++) {
        File child_file = directory_files[i];
        if (!child_file.isDirectory() && child_file.getName().endsWith(".mds")) {
            System.err.println("Found mds file: " + child_file);
            MetadataSet metadata_set = loadMetadataSet(child_file);
                  //  metadata_set.getName();
                    sets.add(new String(child_file.toString() + " ^ " + metadata_set.getName()));
            //model.add(null, metadata_set, GEMSNode.SET);
        }
        }
    }
        return sets;
    }
    public Object [] getVectorSetsToStringArray() {
        
        return getSets().toArray();    
    }
    /** Add a value tree to a given metadata element represented as a GValueModel
     * @param model The <strong>GValueTree</strong> model
     */
    public void addValueTree(GValueModel model) {
    ElementWrapper element = model.getElement();
    String namespace = element.getNamespace();
    MetadataSet mds = (MetadataSet) mds_hashtable.get(namespace);
    if(mds != null) {
        mds.addValueTree(element, model);
    }
    }


    /** Destructor. 
     */
    public void destroy() {
    mds_hashtable.clear();
    }


    /** Used to get all the (non-hidden) elements in this manager.
     * @return A Vector of ElementWrappers.
     */
    public Vector getElements() {
    return getElements(false);
    }

    public Vector getElements(boolean all) {
    return getElements(all, false);
    }

    /** Used to get all the elements in this manager.
     * @param all <i>true</i> if all elements, including hidden, should be returned.
     * @return A Vector of ElementWrappers.
     */
    public Vector getElements(boolean all, boolean force_extracted) {
    Vector all_elements = new Vector();
    for(Enumeration keys = mds_hashtable.keys(); keys.hasMoreElements(); ) {
        MetadataSet mds = (MetadataSet)mds_hashtable.get(keys.nextElement());
        if((!mds.getNamespace().equals(Utility.EXTRACTED_METADATA_NAMESPACE) && !mds.getNamespace().equals(HIDDEN)) 
           || (mds.getNamespace().equals(Utility.EXTRACTED_METADATA_NAMESPACE) && (Configuration.get("general.view_extracted_metadata", Configuration.COLLECTION_SPECIFIC) || force_extracted)) 
           || (mds.getNamespace().equals(Utility.EXTRACTED_METADATA_NAMESPACE) && mds.getNamespace().equals(HIDDEN) && all)) {
        NodeList set_elements = mds.getElements();
        ///ystem.err.println("The set " + mds + " has " + set_elements.getLength() + " elements.");
        for(int i = 0; i < set_elements.getLength(); i++) {
            Element raw_element = (Element)set_elements.item(i);
            ElementWrapper element = new ElementWrapper(raw_element);
            // For now we do not add subfield elements and their parents, just the subfields.
            NodeList child_elements = raw_element.getElementsByTagName("Element");
            if(child_elements.getLength() == 0) {
            all_elements.add(element);
            }
        }
        }
    }
    Collections.sort(all_elements);
    return all_elements;
    }

    /** Retrieve a metadata element by its index.
     * @param index The specified index as an int.
     * @return An ElementWrapper containing the specied element, or <i>null</i> is no such element exists.
     */
    public ElementWrapper getElement(int index) {
    Vector elements = getElements(false);
    ElementWrapper result = null;
    if(0 <= index && index < elements.size()) {
        result = (ElementWrapper) elements.get(index);
    }
    return result;
    }
    /** Retrieve a metadata element by looking at the current metadata element. Note that this 'index' element may now be disconnected from the DOM model, so we have to reload the target element by the string method.
     * @param element The possibly out-of-data MetadataElement.
     * @return An ElementWrapper containing the specied element, or <i>null</i> is no such element exists.
     */
    public ElementWrapper getElement(ElementWrapper element) {
    return getElement(element.toString());
    }
    /** Retrieve a metadata element by its fully qualified name.
     * @param name The elements name as a String.
     * @return An ElementWrapper containing the specied element, or <i>null</i> is no such element exists.
     */
    public ElementWrapper getElement(String name) {
    return getElement(name, false);
    }

    public ElementWrapper getElement(String name, boolean perfect) {
    ///ystem.err.println("Retrieve element " + name);
    if(name == null) {
        ///ystem.err.println("No name!");
        return null;
    }
    ElementWrapper result = null;
    MetadataSet set = null;
    String element = null;
    // First we seperate off what set it is in, where we have '<set><namespace_separator><element>'.
    if(name.indexOf(NS_SEP) != -1) {
        String namespace = name.substring(0, name.indexOf(NS_SEP));
        // Retrieve the correct set if possible.
        set = (MetadataSet)mds_hashtable.get(namespace);
        namespace = null;
        // Now retrieve the element name.
        element = name.substring(name.indexOf(NS_SEP) + 1);
    }
    // If we are looking for a perfect match, we can assume that no namespace means extracted metadata
    else if(!perfect) {
        // No namespace so assume that its extracted metadata.
        set = (MetadataSet)mds_hashtable.get(Utility.EXTRACTED_METADATA_NAMESPACE);
        element = name;
    }
    if(set != null) {
        // Now we have a set we are ready to locate the requested element. Break the remaining element name down by the subfield separator, attempting to retrieve the element indicated by each step.
        if(element.indexOf(SF_SEP) != -1) {
        StringTokenizer tokenizer = new StringTokenizer(element, SF_SEP);
        // Has to be at least two tokens
        if(tokenizer.countTokens() >= 2) {
            Element current_element = set.getElement(tokenizer.nextToken());
            while(current_element != null && tokenizer.hasMoreTokens()) {
            current_element = set.getElement(current_element, tokenizer.nextToken());
            }
            if(current_element != null) {
            result = new ElementWrapper(current_element);
            current_element = null;
            }
        }
        tokenizer = null;
        }
        // No subfields - much easier.
        if(result == null) {
        ///ystem.err.print("Trying to match element " + element +"?");
        Element temp = set.getElement(element);
        if(temp != null) {
            result = new ElementWrapper(temp);
        }
        temp = null;
        }
        set = null;
    }
    element = null;
    return result;
    }
    /** Retrieve a certain named element from a certain named set.
     * @param set The metadata set whose element you want.
     * @param name The name of the element.
     * @return An ElementWrapper around the requested element, or null if no such set or element.
     */
    public ElementWrapper getElement(String set, String name) {
    if(mds_hashtable.containsKey(set)) {
        MetadataSet temp = (MetadataSet)mds_hashtable.get(set);
        return new ElementWrapper(temp.getElement(name));
    }
    return null;
    }

    /** Retrieve the named metadata set.
     * @param name The sets name as a String.
     * @return The MetadataSet as named, or null if no such set.
     */
    public MetadataSet getSet(String namespace) {
    if(mds_hashtable.containsKey(namespace)) {
        return (MetadataSet) mds_hashtable.get(namespace);
    }
//  else if(name.equals(HIDDEN)) {
//      return createHidden();
//  }
    return null;
    }

    /** Method to retrieve all of the metadata sets loaded in this collection. 
     * @return A Vector of metadata sets.
     */
    public Vector getSets() {
    return getSets(true);
    }

    public Vector getSets(boolean include_greenstone_extracted) {
    Vector result = new Vector();
    for(Enumeration keys = mds_hashtable.keys(); keys.hasMoreElements(); ) {
        MetadataSet set = (MetadataSet)mds_hashtable.get(keys.nextElement());
        if(!set.getNamespace().equals(HIDDEN) && (include_greenstone_extracted || !set.getNamespace().equals(Utility.EXTRACTED_METADATA_NAMESPACE))) {
        result.add(set);
        }
    }
    return result;
    }
  

    /** Get the value tree that matches the given element.
     * @param element The ElementWrapper representing the element.
     * @return The GValueModel representing the value tree or null.
     */
    public GValueModel getValueTree(ElementWrapper element) {
    GValueModel value_tree = null;
    if(element != null) {
        String namespace = element.getNamespace();
        if(namespace.length() > 0) {
        MetadataSet mds = (MetadataSet) mds_hashtable.get(namespace);
        if(mds != null) {
            value_tree = mds.getValueTree(element);
        }
        }
    }
    return value_tree;
    }


    public MetadataSet loadMetadataSet(File metadata_set_file)
    {
        File[] all_sets = new File[MAX_LOADED_SETS];
        MetadataSet tempSet;
        int i = 0;
        System.err.println("Loading metadata set file " + metadata_set_file + "...");
    MetadataSet metadata_set = new MetadataSet(metadata_set_file);
        
        //write out existing namespaces to all_sets[]...we use this to determine if a set is
        //already loaded-Attila 
        for(Enumeration keys = mds_hashtable.keys(); keys.hasMoreElements(); ) {
        tempSet = (MetadataSet)mds_hashtable.get(keys.nextElement());  
            
            all_sets[i] = tempSet.getFile();
            i++;
    }
        
        //Now check our metadata.set's namespace to see if it is already loaded in all_sets
        for(int p = 0 ; p < i; p++) {
  
                if(metadata_set.getFile().compareTo(all_sets[p]) == 0) {
                   // System.err.println("Not loading set: "+ metadata_set.getNamespace() + " is already loaded.\n");
                   // JOptionPane.showMessageDialog(self, Dictionary.get("MEM.Cannot_Add_Elements_To_Greenstone_MDS"), Dictionary.get("General.Error"), JOptionPane.ERROR_MESSAGE);
                    gemsptr.warn_cant_load_set();
                   
                    return null; 
                 }
               
        }
    
        //check if this metadata set belongs to a collection
        //if so, then change the metadata set's name in the interface to (collection) dublic core...
     // System.out.println(new String("asdfd" + metadata_set.getFile().separator));
    String sep = new String(metadata_set.getFile().separator);
       StringTokenizer st = new StringTokenizer(metadata_set.getFile().toString(), sep);
       String colName = new String("");
       
        while ( st.hasMoreTokens() )
        {
           if(st.nextToken().compareTo("collect") == 0) {
            colName = st.nextToken();  
           // metadata_set.old_filename = metadata_set.getName();
           // metadata_set.setName(new String("(" + colName + ") " + metadata_set.getName()) );
            break;
           }   
        }

        //Actual set loading code(if it gets this far-Attila
    //**************
    //mds_hashtable.put(metadata_set.getNamespace(), metadata_set);
    if (colName.equals("")) {
        mds_hashtable.put(colName+":"+metadata_set.getNamespace(), metadata_set);
    } else {
        metadata_set.setCollection(colName);
        mds_hashtable.put(metadata_set.getNamespace(), metadata_set);
    }
    return metadata_set;
    }


    public void removeElement(ElementWrapper element) {
    // Retrieve the metadata set this element belongs to.
    String namespace = element.getNamespace();
    MetadataSet set = (MetadataSet) mds_hashtable.get(namespace);
    if(set != null) {
        // Bugger. Get the old name -before- we remove the element from the set.
        String old_name = element.toString();
        // Remove the element.
        set.removeElement(element.getElement());
    }
    else {
        ///ystem.err.println("no such set " + namespace);
    }
    // No such set. No such element.
    }
/*Following write() and write() and save() were taken from msm/metadatasetmanager.java and converted to 
 *the gems standard
 */
     private void write(ElementWrapper element, GValueModel model, String etc_dir) {
    try {
        File out_file = new File(etc_dir + element.getName() + ".txt");
        FileOutputStream fos = new FileOutputStream(out_file);
        OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
        BufferedWriter bw = new BufferedWriter(osw, Utility.BUFFER_SIZE);
        Vector all_values = model.traverseTree();
        for(int i = 0; i < all_values.size(); i++) {
        GValueNode node = (GValueNode)all_values.get(i);
        TreePath path = new TreePath(node.getPath());
        String full_value = node.getFullPath(false);
        String index = model.getHIndex(full_value);

        write(bw, "\"" + full_value + "\"\t" + index + "\t\"" + node.toString(GValueNode.GREENSTONE) + "\"");
        }
        // Very important we do this, or else buffer may not be flushed
        bw.flush();
        bw.close();
    }
    catch(Exception error) {
        error.printStackTrace();
    }
    }

    private void write(Writer w, String text)
    throws Exception {
    text = text + "\r\n";
    char buffer[] = text.toCharArray();
    w.write(buffer, 0, buffer.length);
    }
 public void save() {
     // Create the correct file to save these sets to...
     //File file = new File(Gatherer.self.getCollectionMetadata());
     //File file = new File(GEMS.config.gsdl_path + "/gli/metadata");
     File file = new File(Utility.METADATA_DIR);

     
     if (!file.exists()) {
     //DebugStream.println("trying to save a collection and the metadata directory does not exist - creating it!");
     System.out.println("trying to save a collection and the metadata directory does not exist - creating it!");
     
     file.mkdir();
     }
     // And make back ups of all existing metadata set files.
     File temp[] = file.listFiles();
     
     //Null ptr exception here? Didnt see it, -Attila
     /*for(int i = temp.length - 1; i >= 0; i--) {
     // System.out.println("Itter: " + i);
     if(temp[i].getName().endsWith(".mds") ) {
     File backup = new File(temp[i].getAbsolutePath() + "~bak");
                
                //System.out.println(temp[i].getAbsolutePath()+ "asdf\n backupfile:"+ backup.toString());
                
                
        //backup.deleteOnExit();
               
        if(!temp[i].renameTo(backup)) {
            DebugStream.println("Error in MetadataSetManager.save(): FileRenamedException");
                    System.out.println("Error in MetadataSetManager.save(): FileRenamedException");
        }
        }
    }*/
     // Now save the latest versions of the metadata sets.
     for(Enumeration keys = mds_hashtable.keys(); keys.hasMoreElements(); ) {
     String namespace = (String) keys.nextElement();
     MetadataSet set = (MetadataSet) mds_hashtable.get(namespace);
            //
            //col_man.loadCollection(GEMS.config.getString("general.open_collection",true));
            //
     try {
         // this won't work if we have collection metadata open
         //File mds_file = new File(file, set.getNamespace() + ".mds");
                
                //set.setName(set.old_filename);
                
                //set has not changed(or has been recently saved
              
             
             /*
                if(set.getSetChanged() == false){
                  continue;   
                }*/
                
         // just use the existing file path
         File mds_file = set.getFile();
                //System.out.println(mds_file.toString() + "a\n");
               //Saves the DOM obj that set.getDocument returns to mds_file name
               // set.getF
               // System.out.println(keys.toString());
                
               
            // System.out.println("::: " + mds_file.toString());
         XMLTools.export(set.getDocument(), mds_file);
             
             set.setSetChanged(false);
         //What does setfile do?
         //set.setFile(mds_file);
         //}
        // Now for each element attempt to save its value tree.
        //NodeList elements = set.getElements();
        //for(int i = elements.getLength() - 1; i >= 0; i--) {
          //  ElementWrapper value_element = new ElementWrapper((Element)elements.item(i));
            //if(value_element.hasValueTree()) {
            //GValueModel value_tree = set.getValueTree(value_element);
            //if(value_tree != null) {
                //File value_file = new File(file, value_element.getName() + ".mdv");
                ///ystem.err.println("Saving value file: " + value_file.toString());
                //Utility.export(value_tree.getDocument(), value_file);
                // If this is a hierarchy element, write hierarchy file.
                //if(value_element.getNamespace().equals(MetadataSetManager.HIDDEN) || value_tree.isHierarchy()) {
                //System.out.println("Val Tree: " +value_file.toString() + "\n");
                               // value_element.
                               // System.out.println(col_man.getCollectionEtc() + "<--getColEtc\n");
                          //      write(value_element, value_tree, new String("/home/arosmain/gsdl/gli/"));
                //}
            //}
            //}
                    //System.out.println("Val element: "+value_element.toString() + "\n");
        //}
        }
        catch (Exception error) {
        error.printStackTrace();
        }
    }
    //profiler.save();
    }
    public void removeSet(MetadataSet set) {
    mds_hashtable.remove(set.getNamespace());
        File f =  set.getFile();
        f.delete();
        //System.out.println(f.toString() + Utility.METADATA_DIR);
    // fireSetChanged(set);
    }
}