source: trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/metadata/SimpleNamespace.java@ 8742

package org.greenstone.gsdl3.gs3build.metadata;

import java.io.PrintWriter;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.ArrayList;
import java.util.HashMap;

import java.sql.SQLException;
import java.sql.ResultSet;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;

import org.greenstone.gsdl3.gs3build.util.MultiMap;
import org.greenstone.gsdl3.gs3build.util.XMLTools;
import org.greenstone.gsdl3.gs3build.database.*;

/**
 *  Implement a simple, unordered, namespace in METS.
 *
 *  @see: org.greenstone.gsdl3.gs3build.metadata.METSNamespace
 */

public class SimpleNamespace extends METSNamespace
{
    MultiMap metadataMap;
    
    public SimpleNamespace(String name)
    { 
    super(name);
    this.metadataMap = new MultiMap();
    }
    
    public SimpleNamespace(String name, METSLocation location)
    { 
    super(name, location);
    this.metadataMap = new MultiMap();
    }
    
    public SimpleNamespace(String name, Element mdWrapTag)
    { 
    super(name);
    this.metadataMap = new MultiMap();
    
    NodeList childNodes = mdWrapTag.getChildNodes();
    for (int c = 0; c < childNodes.getLength(); c ++) {
        // a metadata node
        if (childNodes.item(c).getNodeType() == org.w3c.dom.Node.ELEMENT_NODE) {
        // get the name of the metadata from the node
        String metadataLabel = childNodes.item(c).getNodeName();
        
        // skip blank labels
        // TODO: raise an error: metadata item without metadata label set
        if (metadataLabel == null || metadataLabel.length() == 0) {
            continue;
        }
        
        // build the value
        String metadataValue = "";
        
        Element childElement = (Element) childNodes.item(c);
        for (int i = 0; i < childElement.getChildNodes().getLength(); i ++) {
            metadataValue = metadataValue + childElement.getChildNodes().item(i).toString();
        }
        
        // trim any leading namespace identifiers in "namespace:label" metadata
        if (metadataLabel.startsWith(this.name + ":")) {
            metadataLabel = metadataLabel.substring(this.name.length() + 1);
        }
        
        this.addMetadata(metadataLabel, metadataValue);
        }
    }
    }
    
    public boolean validate(String field, String value)
    { 
    return true;
    }
    
    /**
     *  Add a metadata item.  Whether the field and value validate for this
     *  schema will also be tested.
     *
     *  @param <code>String</code> the name of the field to be given the value
     *  @param <code>String</code> the value to be assigned
     *
     *  @return <code>boolean</code> whether the field value was added.  This
     *          would return <code>false</code> if the values did not validate,
     *          for example.
     */
    public boolean addMetadata(String label, String value)
    {
    if (!this.validate(label, value)) {
        return false;
    }
    
    this.metadataMap.put(label, value);
    return true;
    }
    
    /**
     *  Assign a metadata item.  Whether the field and value validate for this
     *  schema will also be tested.  Any existing metadata for that field will
     *  be destroyed if the new value validates.
     *
     *  @param <code>String</code> the name of the field to be given the value
     *  @param <code>String</code> the value to be assigned
     *
     *  @return <code>boolean</code> whether the field value was added.  This
     *          would return <code>false</code> if the values did not validate,
     *          for example.
     */
    public boolean setMetadata(String label, String value)
    { 
    if (!this.validate(label, value)) {
        return false;
    }
    
    this.metadataMap.setOnly(label, value);
    return true;
    }
    
    /**
     *  Remove all metadata values for a given field name
     *
     *  @param <code>String</code> the field to delete
     *
     *  @return <code>boolean</code> whether the field was actually deleted; 
     *          will return <code>true</code> if the field was already empty.
     */
    public boolean removeMetadata(String label)
    { 
    this.metadataMap.remove(label);
    return true;
    }
    
    /**
     *  Remove a particular incidence of a given metadata field for a document.
     *  If an exact match for the given value is not found, nothing changes.
     *  N.B. if a value occurs twice, only the first incidence of it will be
     *  deleted from the list.
     *
     *  @param <code>String</code> the field to have the value removed
     *  @param <code>String</code> the value to be removed from a given field
     *
     *  @return <code>boolean</code> <code>true</code> if an actual metadata text
     *          is matched against the given value and is thus deleted.
     */
    public boolean removeMetadata(String label, String value)
    { 
    return this.metadataMap.remove(label, value);
    }
    
    /**
     *  Get the metadata items for a particular label
     *
     *  @param <code>String</code> the label to fetch values for
     *  
     *  @return <code>List</code> the list of corresponding values.  May be
     *          <code>null</code>
     */
    public List getMetadata(String label)
    { 
    return this.metadataMap.getAll(label);
    }
    
    public Iterator getMetadataNames() 
    {
    return this.metadataMap.keySet().iterator();
    }
    
    /**
     *  Write out the metadata to an XML file through a <code>PrintWriter</code>.
     *
     *  @param <code>PrintWriter</code> the writer to use.
     */
    public boolean write(PrintWriter writer)
    { 
    // if this is a non-file block of metadata, write it out in long hand
    if (this.location == null){
        String tag = XMLTools.getOpenTag("mets", "mdWrap");
        
        tag = XMLTools.addAttribute(tag, "MDTYPE", "OTHER");
        tag = XMLTools.addAttribute(tag, "OTHERMDTYPE", this.name);
        if (this.id != null) {
        this.id = "gsdl"+this.id;
        tag = XMLTools.addAttribute(tag, "ID", this.id);
        }
        writer.print("   ");  //indentation
        writer.println(tag);
        
        tag = XMLTools.getOpenTag("mets", "xmlData");
        writer.print("      ");  //indentation 
        writer.println(tag);
        
        Iterator keys = this.metadataMap.keySet().iterator();
        while (keys.hasNext()){
        String thisKey = keys.next().toString();
        writer.print("         "); //indentation
        this.writeItem(writer, thisKey);
        }
        
        writer.print("      ");  //indentation 
        writer.println(XMLTools.getCloseTag("mets", "xmlData"));
        
        writer.print("   ");  //indentation
        writer.println(XMLTools.getCloseTag("mets", "mdWrap"));
    }
    // otherwise, drop the metadata out in a simplified file-reference
    // form only
    else
        { 
        String tag = XMLTools.getOpenTag("mets","mdRef");
        tag = XMLTools.addAttribute(tag, "LOCTYPE", "URL");
        tag = XMLTools.addAttribute(tag, "xlink:href", location.getLocation().toString());
        //tag = XMLTools.addAttribute(tag, "MDTYPE", "OTHER");
        //tag = XMLTools.addAttribute(tag, "OTHERMDTYPE", this.name);
        tag = XMLTools.addAttribute(tag, "MDTYPE", this.name);  
        if (this.id != null) {
            tag = XMLTools.addAttribute(tag, "ID", this.id);
        }
        writer.println(tag);
        writer.print("   ");  //indentation 
        writer.println("</mets:mdRef>");
        }
    return true;
    }
    
    /**
     *  Write out a single element - this may be overloaded to provide for the
     *  appropriate formatting for this metadata.
     */
    protected boolean writeItem(PrintWriter writer, String label)
    { 
    if (this.location == null) {
        // just place the metadata in a simple wrapper
        Iterator values = this.metadataMap.getAll(label).iterator();
        
        while (values.hasNext()) {
        String value = values.next().toString();
        String metaTagName = "Metadata name=" +'"'+ label +'"';
        //writer.write(XMLTools.getOpenTag(this.name, label));
        writer.write(XMLTools.getOpenTag(this.name, metaTagName));
        writer.write(value);
        
        //writer.println(XMLTools.getCloseTag(this.name, label));
        writer.println(XMLTools.getCloseTag(this.name, "Metadata"));
        }
    }
    else {
        String tag = XMLTools.getOpenTag("mets", "mdRef");
        tag = XMLTools.addAttribute(tag, "LOCTYPE", this.location.getType());
        tag = XMLTools.addAttribute(tag, "xlink:href", this.location.getLocation().toString());
        tag = XMLTools.addAttribute(tag, "MDTYPE", this.getName());
        tag = XMLTools.makeSingleton(tag);
        writer.print("      "); //indentation 
        writer.println(tag);
    }
    return true;
    }
    
    /**
     *  Write out the metadata to an SQL database through a <code>GS3SQLConnection</code>.
     *
     *  @param <code>GS3SQLConnection</code> the SQL database to use.
     */
    public boolean writeSQL(int parentId, GS3SQLConnection connection)
    { 
    // write the general stuff
    String sqlId;
    
    if (!super.writeSQL(parentId, connection)) {
        return false;
    }
    
    try {
        if (this.id == null) {
        GS3SQLSelect select = new GS3SQLSelect("namespaces");
        select.setWhere(new GS3SQLWhere(new GS3SQLWhereItem("MetadataRef", "=", Integer.toString(parentId), GS3SQLField.INTEGER_TYPE)));
        select.addField("NamespaceRef");
        connection.execute(select.toString());
        
        ResultSet results = connection.getResultSet();
        results.first();
        sqlId = Integer.toString(results.getInt("NamespaceRef"));
        }
        else {
        sqlId = this.id;
        }
        
        // clear all the existing metadata items for this namespace
        GS3SQLDelete delete = new GS3SQLDelete("mdvalues");
        GS3SQLWhere where = new GS3SQLWhere(new GS3SQLWhereItem("NamespaceRef", "=", sqlId, GS3SQLField.INTEGER_TYPE));
        delete.setWhere(where);
        connection.execute(delete.toString());
        
        // write out the metadata for this namespace
        Iterator keys = this.metadataMap.keySet().iterator();
        while (keys.hasNext()){
        String thisKey = keys.next().toString();
        
        Iterator values = this.metadataMap.getAll(thisKey).iterator();
        
        while (values.hasNext()){
            String value = values.next().toString();
            
            GS3SQLInsert insert = new GS3SQLInsert("mdvalues");
            insert.addValue("NamespaceRef", sqlId, GS3SQLField.INTEGER_TYPE);
            insert.addValue("Label", thisKey);
            insert.addValue("Value", value);
            connection.execute(insert.toString());
        }
        }
    }
    catch (SQLException sql) {
        System.out.println(sql);
    }
    return true;
    }
    
    
    /**
     *  <p>Indicate whether this metadata is open to being changed or not.</p>
     *  <p>Metadata which is created from a distinct file cannot be changed,
     *  only those which have no associated file can be modified.
     *
     *  @return <code>boolean</code> whether this namespace can be altered.
     */
    public boolean isEditable()
    { 
    return (this.location == null);
    }
}