source: trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/metadata/METSDivision.java@ 8461

package org.greenstone.gsdl3.gs3build.metadata;

import java.io.PrintWriter;

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

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

import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

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

public class METSDivision extends AbstractStructure
{
  String       order;       // see the METS documentation for the meaning of the different
  String       orderLabel;  // label types.
  String       userLabel;
  String       type;        // e.g. section, chapter, physical or logical, etc.
  List         metadataRefs;
  List         adminRefs;
  List         fileRefs;
 
  public static final String DIVISION_TYPE  = "Division";
  public static final String DIVISION_TAG   = "div";
  public static final String FPTR_TAG       = "fptr";

  public METSDivision(String ID, String order, String orderLabel, String userLabel, String type)
  { super(ID);

    this.order = order;
    this.orderLabel = orderLabel;
    this.userLabel = userLabel;
    this.type = type;
    this.fileRefs = new ArrayList();
    this.metadataRefs = new ArrayList();
  }

  public String getStructureType()
  { return DIVISION_TYPE;
  }

  public String getLabel()
  { return this.orderLabel;
  }

  /**
   *  Find all the divisions that match a given list of file group
   *  identifiers...
   *
   *  @param <code>List</code> the list of identifiers to find
   *  @param <code>List</code> the list into which to place any
   *         matching divisions.
   */
  public void findDivisionsForFiles(List listOfFileIdentifiers, List resultList)
  { Iterator iterator = this.fileRefs.iterator();
    
    // get the references on this division, and mark if necessary
    while (iterator.hasNext()) 
    { String reference = iterator.next().toString();

      Iterator fileIterator = listOfFileIdentifiers.iterator();
      while (fileIterator.hasNext())
      { String fileRef = fileIterator.next().toString();
      
        if (fileRef.equals(reference))
    { resultList.add(this);
    }
      }
    }
    
    // get the child groups, and check each in turn...
    Iterator groups = this.children.values().iterator();
    while (groups.hasNext())
    { METSDivision group = (METSDivision) groups.next();

      group.findDivisionsForFiles(listOfFileIdentifiers, resultList);
    }    
  }

  /**
   *  Get the namespace from the given set of descriptive blocks...
   */
  public METSNamespace findNamespace(String namespaceName, boolean isOpenNamespace, 
                     METSDescriptiveSet descriptiveSet)
  { METSNamespace namespace = null;

    // Special case - no existing metadata references
    if (this.metadataRefs.size() == 0) {
      // Create new Descriptive and add it to the descriptive set
      METSDescriptive descriptive = new METSDescriptive("DM"+this.ID, this.orderLabel);
      descriptiveSet.addDescriptive(descriptive);

      // Create the namespace and add it to the Descriptive
      namespace = NamespaceFactory.initNamespace(namespaceName);
      if (namespace != null)
      { descriptive.addNamespace(namespace);
      }

      return namespace;
    }

    Iterator descriptiveIterator = this.metadataRefs.iterator();

    while (descriptiveIterator.hasNext())
    { String descriptiveRef = descriptiveIterator.next().toString();

      METSDescriptive descriptive = descriptiveSet.getDescriptiveById(descriptiveRef);

      if (isOpenNamespace) {
    namespace = descriptive.getOpenNamespace(namespaceName);
      }
      else {
    namespace = descriptive.getNamespace(namespaceName);
      }
    
      if (namespace != null)
    break;
    }

    // Special case - no such namespace in any descriptive list...
    if (namespace == null)
    { // take the first descriptive area...
      METSDescriptive descriptive = descriptiveSet.getDescriptiveById(this.metadataRefs.get(0).toString());

      // create the namespace, and add it to the METSDescriptive
      namespace = NamespaceFactory.initNamespace(namespaceName);
      if (namespace != null)
      { descriptive.addNamespace(namespace);
      }
    }

    return namespace;
  }

  /**
   *  Add a new file reference to the structure
   *
   *  @param <code>METSFileID</code> the file to be referenced.
   */
  public void addFileReference(METSFileID fileRef)
  { this.addFileReference(fileRef.toString());
  }

  public void addFileReference(String fileRef)
  { this.fileRefs.add(fileRef);
  }

  /**
   *  Add a new metadata reference to the structure
   */
  public void addMetadataReference(String metadataRef)
  { // TODO: correct the type
    this.metadataRefs.add(metadataRef);
  }

  /**
   *  Get all the metadata references
   *
   *  @return <code>List</code> containing all the references
   */
  public List getMetadataReferences()
  { return this.metadataRefs;
  }

  /**
   *  Get all the default (first) metadata reference...
   *
   *  @return <code>List</code> containing all the references
   */
  //TODO: check for this first *open* metadata item...
  public String getDefaultMetadataReference()
  { if (this.metadataRefs.size() == 0) {
      return null;
    }
    return this.metadataRefs.get(0).toString();
  }

  /**
   *  Get all the default (first) first filegroup reference...
   *
   *  @return <code>List</code> containing all the references
   */
  public String getDefaultFileReference()
  { if (this.fileRefs.size() == 0) {
      return null;
    }
    return this.fileRefs.get(0).toString();
  }

  /**
   *  Get a child or descendant division
   *
   *  @param <code>String</code> the path to the child division
   *  @return <code>METSDivision</code> the division found.
   */
  public METSDivision getDivision(String divisionLabel)
  { // if the division ID equals this, then process it
    if (divisionLabel.equals(this.orderLabel)) {
      return this;
    }

    // if we just shouldn't be here, then error...
    if (!divisionLabel.startsWith(this.orderLabel + ".")) {
      return null;
    }

    // get the next division in the division path...
    String subdivisionPath = divisionLabel.substring(this.orderLabel.length() + 1);
    String nextDivision = getTopDivisionName(subdivisionPath);
    String nextLabel;

    // first try the current division name with an appended '.' and the next child id...
    METSDivision child = (METSDivision) this.children.get(this.orderLabel + "." + nextDivision);
    if (child == null)
    { // if that didn't work, try the next division on its own
      child = (METSDivision) this.children.get(nextDivision);

      // if neither worked, then abort...
      if (child == null) {
    return null;
      }
      else {
    // set the next identifier
    nextLabel = METSDivision.getSubDivisionName(divisionLabel);
      }
    } 
    else {
      // set the next identifier...
      nextLabel = divisionLabel;
    }

    return child.getDivision(nextLabel);
  }

  /**
   *  A convenience method for splitting a division name - this gives the name
   *  without the leading division label...  To be used when division identifiers
   *  are given as '.' separated paths and division names do not contain the
   *  full path of their parents.
   *
   *  @return <code>String</code>
   */
  public static String getSubDivisionName(String divisionName)
  { int at = divisionName.indexOf('.');

    if (at >= 0)
    { return divisionName.substring(at+1);
    }
    else
    { return null;
    }
  }

  /**
   *  Get the parent division name.  Division identifiers
   *  concatenate the ancestor's names with intervening
   *  '.' characters.
   *
   *  @return <code>String</code> the division name
   */
  public static String getParentName(String divisionName)
  { int at = divisionName.lastIndexOf('.');

    if (at >= 0) {
      return divisionName.substring(0, at);
    } 
    return "";
  }

  /**
   *  Get the top division name.
   *
   *  @return <code>String</code> the division name
   */
  public static String getTopDivisionName(String divisionName)
  { int at = divisionName.indexOf('.');

    if (at >= 0)
    { return divisionName.substring(0, at);
    }
    else
    { return divisionName;
    }
  }

      /*  Parse an XML Element as a METSDivision section
      *
      *  @param <code>Element</code> the XML element which represents
      *  the mets:div itself 
      */
    
     public static METSDivision parseXML(Element element) 
     {
    METSDivision thisDivision = null;
 
    String divId = element.getAttribute("ID");
    String divType = element.getAttribute("TYPE");
    String divOrder = element.getAttribute("ORDER");
    String divOrderLabel = element.getAttribute("ORDERLABEL");
    String divUserLabel = element.getAttribute("LABEL");
    String divMetaRef = element.getAttribute("DMDID");
    
    thisDivision = new METSDivision(divId, divOrder,divOrderLabel, divUserLabel, divType);
        
    thisDivision.addMetadataReference(divMetaRef);
 
    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 child = (Element) children.item(c);
        String childName = child.getNodeName();
 
        if (childName.equals("mets:fptr")) {
        
        METSDivision.fptr_parseXML(thisDivision, child);
        } else if (childName.equals("mets:div")) {
        METSDivision division = METSDivision.parseXML(child);
        thisDivision.addDivision(division);
        } else {
        System.err.println("Error: mets:div expected mets:div or mets:fptr, but got " + childName);
        } 
    }
    return thisDivision;
     }
 
 
 
     /**
      * Parse an XML element as a  METSFptr Section
      * @param <code>Element</code> the XML element which represents the mets:fptr itself
      */
     private static void fptr_parseXML(METSDivision thisDivision, Element element) 
     {
    String fileRef = element.getAttribute("FILEID");
    thisDivision.addFileReference(fileRef);
     }
 
     /**


  /**
   *  Write the METS file in an XML to a text-output sink.
   *
   *  @param <code>PrintWriter</code> the destination of the output
   */
  public boolean write(PrintWriter writer)
  { // Get the main tag for the division
    String tag = XMLTools.getOpenTag("mets", DIVISION_TAG);
    tag = XMLTools.addAttribute(tag, "ID", this.ID.toString());
    tag = XMLTools.addAttribute(tag, "TYPE", this.type);
    tag = XMLTools.addAttribute(tag, "ORDER", this.order);
    if (this.orderLabel != null)
    { tag = XMLTools.addAttribute(tag, "ORDERLABEL", this.orderLabel);
    }
    if (this.userLabel != null)
    { tag = XMLTools.addAttribute(tag, "LABEL", this.userLabel);
    }

    // Add a metadata reference attribute
    if (this.metadataRefs.size() > 0)
    { String metaList = this.writeList(this.metadataRefs);

      tag = XMLTools.addAttribute(tag, "DMDID", metaList);
    }

    // write the central tag
    writer.println(tag);

    // write the list of file pointers for this structural element
    if (this.fileRefs.size() > 0)
    { String fileList = this.writeTagList("mets", "fptr", "FILEID", this.fileRefs);

      writer.println(fileList);
    }

    // write out any children in turn
    Iterator groups = this.children.values().iterator();

    while (groups.hasNext())
    { METSDivision group = (METSDivision) groups.next();
    
      if (!group.write(writer)) {
    return false;
      }
    }
    
    // close the div element
    writer.println(XMLTools.getCloseTag("mets", DIVISION_TAG));

    return true;
  }

  /**
   *  A convenience method for writing a <code>List</code> as a series of tags...
   */
  private String writeTagList(String namespace, String tagname, 
                  String attribute, List list)
  { StringBuffer listString = new StringBuffer();
      
    Iterator iterator = list.iterator();
    while (iterator.hasNext())
    { String item = iterator.next().toString();

      String tag = XMLTools.getOpenTag(namespace, tagname);
      tag = XMLTools.addAttribute(tag, attribute, item);
      tag = XMLTools.makeSingleton(tag);

      listString.append(tag);
    }
    return listString.toString();
  }

  /**
   *  A convenience method for writing a <code>List</code> as a space-separated <code>String</code>.
   */
  private String writeList(List list)
  { StringBuffer listString = new StringBuffer();
      
    Iterator iterator = list.iterator();
    while (iterator.hasNext())
    { String item = iterator.next().toString();

      if (listString.length() > 0) {
    listString.append(" ");
      }

      listString.append(item);
    }
    return listString.toString();
  }

  public boolean writeSQL(DocumentID docId, int parentRef, boolean parentIsStructure, 
              GS3SQLConnection connection)
  { int sqlRef = -1;

    // set the "where" to find the reference for this division
    GS3SQLSelect select = new GS3SQLSelect("divisions");
    select.addField("DivisionRef");
    GS3SQLWhereItem whereItem = new GS3SQLWhereItem("ParentRef", "=", Integer.toString(parentRef), GS3SQLField.INTEGER_TYPE);
    GS3SQLWhereItem parentItem = new GS3SQLWhereItem("ParentType", "=", parentIsStructure ? METSStructure.STRUCTURE_TYPE : METSDivision.DIVISION_TYPE);
    GS3SQLWhereItem item = new GS3SQLWhereItem("SectionID", "=", this.ID.toString());
    GS3SQLWhere where = new GS3SQLWhere(whereItem);
    where.add(parentItem);
    where.add(item);
    select.setWhere(where);

    connection.execute(select.toString());

    // Do the actual writing
    GS3SQLAction action;

    ResultSet resultSet = connection.getResultSet();
    try {
      if (resultSet == null ||
      !resultSet.first())
      { resultSet = null;

        GS3SQLInsert insert = new GS3SQLInsert("divisions");
    insert.addValue("DocID", docId.toString());
    insert.addValue("SectionID", this.ID.toString());
    insert.addValue("ParentRef", Integer.toString(parentRef));
    insert.addValue("ParentType", parentIsStructure == true ? METSStructure.STRUCTURE_TYPE : METSDivision.DIVISION_TYPE);
    
    action = insert;
      }
      else {
    sqlRef = resultSet.getInt("DivisionRef");
    
    GS3SQLUpdate update = new GS3SQLUpdate("divisions");
    GS3SQLWhere  updateWhere = 
      new GS3SQLWhere(new GS3SQLWhereItem("DivisionRef", "=", Integer.toString(sqlRef), 
                          GS3SQLField.INTEGER_TYPE));
    update.setWhere(updateWhere);
    action = update;
      }
    }
    catch (SQLException sql) {
      System.err.println(sql + " " + select.toString());
      return false;
    }
      
    action.addValue("DivisionType", this.type.toString());
    action.addValue("LabelOrder", this.order);
    action.addValue("ShortLabel", this.orderLabel);
    action.addValue("UserLabel", this.userLabel);

    if (!connection.execute(action.toString()))
    { return false;
    }

    // if doing a fresh item, get the new structure reference...
    if (resultSet == null)
    { // get the new structure reference
      connection.execute(select.toString());

      // get the sql reference for the division
      try {
    // read in the structure reference
    resultSet = connection.getResultSet();
    if (resultSet == null) {
      return false;
    }
    resultSet.first();
    sqlRef = resultSet.getInt("DivisionRef");
    resultSet.close();
    resultSet = null;
      }
      catch (SQLException sqlex) {
    System.err.println("Unable to retrieve reference for Division " + sqlex);
    return false;
      }
    }
    // close the open resultSet, as we don't need it any longer...
    else {
      try {
    resultSet.close();
      }
      catch (SQLException sql) {
    System.err.println(sql + " " + select.toString());
      }
    }

    // delete the old file/metadata references
    GS3SQLWhere referenceWhere = 
      new GS3SQLWhere(new GS3SQLWhereItem("DivisionRef", "=", Integer.toString(sqlRef), 
                      GS3SQLField.INTEGER_TYPE));

    GS3SQLDelete delete = new GS3SQLDelete("divisionfilerefs");
    delete.setWhere(referenceWhere);
    connection.execute(delete.toString());

    delete = new GS3SQLDelete("divisionmetarefs");
    delete.setWhere(referenceWhere);
    connection.execute(delete.toString());

    // write the new file references
    if (this.fileRefs.size() > 0)
    { Iterator iterator = this.fileRefs.iterator();
    
      while (iterator.hasNext()) 
      { GS3SQLInsert fileinsert = new GS3SQLInsert("divisionfilerefs");
        fileinsert.addValue("DocID", docId.toString());
        fileinsert.addValue("DivisionRef", Integer.toString(sqlRef), GS3SQLField.INTEGER_TYPE);
    fileinsert.addValue("DivisionType", "Group");
    fileinsert.addValue("FileID", iterator.next().toString());
    connection.execute(fileinsert.toString());
      }
    }

    // write the metadata references
    if (this.metadataRefs.size() > 0)
    { Iterator iterator = this.metadataRefs.iterator();
    
      while (iterator.hasNext()) 
      { GS3SQLInsert metainsert = new GS3SQLInsert("divisionmetarefs");
        metainsert.addValue("DocID", docId.toString());
        metainsert.addValue("DivisionRef", Integer.toString(sqlRef), GS3SQLField.INTEGER_TYPE);
    metainsert.addValue("DivisionType", "Group");
    metainsert.addValue("MetaID", iterator.next().toString());
    connection.execute(metainsert.toString());
      }
    }

    // write out any children in turn
    Iterator groups = this.children.values().iterator();

    while (groups.hasNext())
    { METSDivision group = (METSDivision) groups.next();
    
      if (!group.writeSQL(docId, sqlRef, false, connection)) {
    return false;
      }
    }
    return true;
  }

  public static METSDivision readSQL(GS3SQLConnection connection, ResultSet resultSet)
  {
    METSLocation metsLocation = null;
    
    GS3SQLSelect select = null;
    try {
      // read the basic information
      String ID   = resultSet.getString("SectionID");
      String type = resultSet.getString("DivisionType");
      String order = resultSet.getString("LabelOrder"); 
      String orderLabel = resultSet.getString("ShortLabel");
      String userLabel  = resultSet.getString("UserLabel");
      
      // construct the division object
      METSDivision division = new METSDivision(ID, order, orderLabel, userLabel, type);
      
      // obtain a list of child divisions
      int divisionRef = resultSet.getInt("DivisionRef");

      select = new GS3SQLSelect("divisions");
      select.addField("*");
      GS3SQLWhereItem whereItem = new GS3SQLWhereItem("ParentRef", "=", Integer.toString(divisionRef),
                              GS3SQLField.INTEGER_TYPE);
      GS3SQLWhere where = new GS3SQLWhere(whereItem);
      whereItem = new GS3SQLWhereItem("ParentType", "=", METSDivision.DIVISION_TYPE);
      where.add(whereItem);
      select.setWhere(where);

      connection.execute(select.toString());
      
      // circulate through to obtain further children
      ResultSet childSet = connection.getResultSet();
      if (childSet.first())
      {
    do {
      METSDivision childDivision = METSDivision.readSQL(connection, childSet);
      division.addDivision(childDivision);
    }
    while (childSet.next());
      }

      select = new GS3SQLSelect("divisionfilerefs");
      select.addField("*");
      where = new GS3SQLWhere(new GS3SQLWhereItem("DivisionRef", "=", Integer.toString(divisionRef), 
                          GS3SQLField.INTEGER_TYPE));
      select.setWhere(where);

      connection.execute(select.toString());

      ResultSet fileSet = connection.getResultSet();
      if (fileSet != null && fileSet.first())
      { do 
    { String reference = fileSet.getString("FileID");
      division.fileRefs.add(reference);
    }
    while (fileSet.next());  
      }

      select = new GS3SQLSelect("divisionmetarefs");
      select.addField("*");
      where = new GS3SQLWhere(new GS3SQLWhereItem("DivisionRef", "=", Integer.toString(divisionRef), 
                          GS3SQLField.INTEGER_TYPE));
      select.setWhere(where);

      connection.execute(select.toString());

      ResultSet metaSet = connection.getResultSet();
      if (metaSet != null && metaSet.first())
      { do 
    { String reference = metaSet.getString("MetaID");
      division.metadataRefs.add(reference);
    }
    while (metaSet.next());  
      }
        
      return division;
    }
    catch (SQLException sqlEx)
    { System.out.println(sqlEx + " " +select.toString());
    }    
    return null;
  }
}