source: trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/metadata/METSDescriptive.java@ 5800

package org.greenstone.gsdl3.gs3build.metadata;

import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;

import java.io.PrintWriter;

import java.sql.SQLException;

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.doctypes.DocumentInterface;

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

/**
 *  Support the descriptive metadata of a given document
 *
 *  The descriptive metadata can occur multiple times, so this 'wrapper' is
 *  in fact a holder for a number of individual metadata sets.  Individual
 *  metadata groups are found in METSNamespace items.
 *
 *  
 */

import org.greenstone.gsdl3.gs3build.util.MultiMap;

public class METSDescriptive
{   MultiMap map;
    String   ID;
    String   name;

    public METSDescriptive(String ID, String name)
    {   this.map  = new MultiMap();
        this.ID   = ID;
        this.name = name;
    }

    public String getID()
    {   return this.ID;
    }

    public String getName()
    {   return this.name;
    }

    public void addNamespace(METSNamespace namespace)
    {   this.map.put(namespace.getName(), namespace);
    }

    public METSNamespace getNamespace(String namespace)
    {   return (METSNamespace) this.map.get(namespace);
    }

    /**
     *  Get the version of a metadata namespace that can be used for
     *  adding new values to the document.  Remember, each namespace may
     *  occur more than once, but only one of the occurrences can be 'open'.
     *
     *  @param <code>String</code> the name of the namespace
     */
    public METSNamespace getOpenNamespace(String namespace)
    {   if (this.map.getAll(namespace) == null)
        { return null;
        }

        Iterator namespaces = ((List) this.map.getAll(namespace)).iterator();

        while (namespaces.hasNext())
        {   METSNamespace namespaceData = (METSNamespace) namespaces.next();

            if (namespaceData.isEditable())
            {   return namespaceData;
            }
        }
        return null;
    }

    /**
     *  Add a piece of metadata to this document.  Existing values are preserved.
     *
     *  @param <code>String</code> the namespace in which the metadata occurs
     *  @param <code>String</code> the label of the metadata

     *  @param <code>String</code> the value of the metadata
     */
    public void addMetadata(String namespace, String label, String value)
    { METSNamespace namespaceData = this.getOpenNamespace(namespace);

        if (namespaceData == null ||
                namespaceData.isEditable() == false) 
        {   namespaceData = NamespaceFactory.initNamespace(namespace);
            this.addNamespace(namespaceData);
        }
        namespaceData.addMetadata(label, value);
    }

    /**
     *  Add a piece of metadata to this document.  Existing values in editable
     *  parts of the document's metadata are destroyed.
     *
     *  @param <code>String</code> the namespace in which the metadata occurs
     *  @param <code>String</code> the label of the metadata

     *  @param <code>String</code> the value of the metadata
     */
    public void setMetadata(String namespace, String label, String value)
    { METSNamespace namespaceData = this.getOpenNamespace(namespace);

        if (namespaceData == null ||
                namespaceData.isEditable() == false) 
        {   namespaceData = NamespaceFactory.initNamespace(namespace);
            this.addNamespace(namespaceData);
        }
        namespaceData.setMetadata(label, value);
    }

    /**
     *  Fetch a <code>List</code> of the values matching the given label in
     *  the requisite namespace.
     *
     *  @param <code>String</code> namespace
     *  @param <code>String</code> label of metadata to match
     *
     *  @return <code>List</code> the corresponding values found.
     */
    public List getMetadata(String namespace, String label)
    {
        // Simple case - no metadata
        if (!this.map.containsKey(namespace))
        { return null;
        }

        // if there's just one instance of the requisite namespace,
        // then again it is a simple case
        if (this.map.getAll(namespace).size() == 1)
        {   return this.getNamespace(namespace).getMetadata(label);
        }

        // otherwise, step through and accumulate
        List accumulatedValues = new ArrayList();
        Iterator namespaceIterator = this.map.getAll(namespace).iterator();
        while (namespaceIterator.hasNext())
        {   METSNamespace localNamespace = (METSNamespace) namespaceIterator.next();

            List localList = localNamespace.getMetadata(label);
            if (localList != null && localList.size() > 0)
            {   accumulatedValues.addAll(localList);
            }
        }

        // if the result of the accumulation is empty, return a null item
        if (accumulatedValues.size() == 0)
        { return null;
        }

        return accumulatedValues;
    }

    /**
     *  Parse an XML Element as a METS Descriptive Metadata section
     *
     *  @param <code>Element</code> the XML element which represents the dmdSec itself
     */
    public static METSDescriptive parseXML(Element element)
    {   // Note: no parsing of attributes required, we just move onto the metadata
      //       namespaces/sections themselves
        String ID = element.getAttribute("ID");
        String label = element.getAttribute("GROUPID");
        METSDescriptive thisDescriptive = new METSDescriptive(ID, label);

        NodeList children = element.getChildNodes();
        
        for (int c = 0; c < children.getLength(); c ++)
        { if (children.item(c).getNodeType() != org.w3c.dom.Node.ELEMENT_NODE) {
                continue;
            }

            Element childElement = (Element) children.item(c);
            if (childElement.getNodeName().equals("mets:mdRef"))
            {   METSNamespace namespace = NamespaceFactory.parseXML(element);
            }
            else if (childElement.getNodeName().equals("mets:mdWrap"))
            {   METSNamespace namespace = NamespaceFactory.parseXML(element);
            }
            else
            {   // TODO: raise an error!
            }
        }
        return thisDescriptive;
    }


  /**
   *  Write the document metadata to a <code>PrintWriter</code> in METS
   *  XML format.
   *  
   *  @param <code>PrintWriter</code> the writer to use for output
   */
  public void write(PrintWriter output)
  { String tag = XMLTools.getOpenTag("mets", "dmdSec");
    tag = XMLTools.addAttribute(tag, "ID", this.ID);
    tag = XMLTools.addAttribute(tag, "GROUPID", this.name);
    output.println(tag);

    Iterator keys = this.map.keySet().iterator();

    // get the keys one by one
    while (keys.hasNext())
    { Object nextKey = keys.next();
      if (nextKey == null)
      { continue;
      }
      String key = nextKey.toString();

      // get every copy of the current namespace name - namespaces may
      // occur more than once, so this is a List
      Iterator namespaces = this.map.getAll(key).iterator();
      
      // namespaces will write themselves...
      while (namespaces.hasNext())
      { METSNamespace namespace = (METSNamespace) namespaces.next();
    
        namespace.write(output);
      }
    }

    tag = XMLTools.getCloseTag("mets", "dmdSec");
    output.println(tag);
  }

  public void writeSQL(DocumentInterface document, GS3SQLConnection connection)
  { // check if this node is in the
    int sqlId = 0;

    //    System.out.println("Writing " + connection.toString());

    GS3SQLSelect select = new GS3SQLSelect("metadata");
    select.addField("*");
    GS3SQLWhereItem whereItem = new GS3SQLWhereItem("MetaID", "=", this.ID);
    GS3SQLWhereItem item = new GS3SQLWhereItem("DocID", "=", document.getID().toString());
    GS3SQLWhere where = new GS3SQLWhere(whereItem);
    where.add(item);
    select.setWhere(where);

    connection.execute(select.toString());
    try {
    if (connection.getResultSet() != null &&
        connection.getResultSet().next()) {
        // the node already exists - no need to do anything as such
    }
    else
    {
        // It is a new node and needs writing
        GS3SQLInsert insert = new GS3SQLInsert("metadata");
        insert.addValue("DocID", document.getID().toString());
        insert.addValue("MetaID", this.ID);
        
        connection.execute(insert.toString());
        
        // now execute the select statement again to get the new identifier
        // 'MetadataRef'
        //      System.out.println(select.toString());
        connection.execute(select.toString());
    }

    // get the reference for this item...   
    connection.getResultSet().first();
    sqlId = connection.getResultSet().getInt("MetadataRef");
    }
    catch (SQLException sql)
    { System.out.println(sql);
    }

    Iterator keys = this.map.keySet().iterator();

    // get the keys one by one
    while (keys.hasNext())
    { Object nextKey = keys.next();
      if (nextKey == null)
      { continue;
      }
      String key = nextKey.toString();

      // get every current namespace - namespaces may
      // occur more than once, so this is a List
      Iterator namespaces = this.map.getAll(key).iterator();
    
      // namespaces will write themselves...
      while (namespaces.hasNext())
      { METSNamespace namespace = (METSNamespace) namespaces.next();
      
        namespace.writeSQL(sqlId, connection);
      }
    }
  }
}