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

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.util.GS3SQLConnection;
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", this.name);
      if (this.id != null) {
    tag = XMLTools.addAttribute(tag, "ID", this.id);
      }
      writer.println(tag);
            
      tag = XMLTools.getOpenTag("mets", "xmlData");
      writer.println(tag);
      
      Iterator keys = this.metadataMap.keySet().iterator();
      while (keys.hasNext())
      { String thisKey = keys.next().toString();
        this.writeItem(writer, thisKey);
      }

      writer.println(XMLTools.getCloseTag("mets", "xmlData"));
      
      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", this.name);
      if (this.id != null) {
    tag = XMLTools.addAttribute(tag, "ID", this.id);
      }
      writer.println(tag);

      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("         ");
    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.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);
  }
}