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

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.HashMap;

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

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
{
  String       ID;          // the unique identifier for this division (unique within the
                            // document, not necessarily unique within the collection).
  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;
  Map          children;
 
  public static final String STRUCTURE_PARENT = "Structure";
  public static final String DIVISION_PARENT  = "Division";

  public METSDivision(String ID, String order, String orderLabel, String userLabel, String type)
  { this.ID = ID;
    this.order = order;
    this.orderLabel = orderLabel;
    this.userLabel = userLabel;
    this.type = type;
    this.fileRefs = new ArrayList();
    this.metadataRefs = new ArrayList();
    this.children = new HashMap();
  }

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

  /**
   *  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>METSFileRef</code> the file to be referenced.
   */
  public void addFileReference(METSFileID 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);
  }

  /**
   *  Add a child division, or sub-division to the document.  For example,
   *  sections within a chapter.
   *
   *  @param <code>METSDivision</code> the child division.
   */
  public void addSubDivision(METSDivision child)
  { this.children.put(child.getID(), child);
  }

  /**
   *  Add a child division to a descendent of this division.
   *
   *  @param <code>String</code> the path to the division into which the
   *         subdivision will be added.
   *  @param <code>METSDivision</code> the division to be added
   */
  public void addSubDivision(String divisionID, METSDivision division)
  { String topDivision = METSDivision.getTopDivisionName(divisionID);

    METSDivision child = (METSDivision) this.children.get(topDivision);
    if (child == null)
    { return;
    }

    String subDivisionID = METSDivision.getSubDivisionName(divisionID);
    if (subDivisionID == null)
    { child.addSubDivision(division);
    }
    else
    { child.addSubDivision(subDivisionID, division);
    }
  }

  public METSDivision getDivision(String divisionID)
  { String topDivision = METSDivision.getTopDivisionName(divisionID);

    METSDivision child = (METSDivision) this.children.get(topDivision);
    if (child == null)
    { return null;
    }

    String subDivision = METSDivision.getSubDivisionName(divisionID);
    if (subDivision != null)
    { child = child.getDivision(subDivision);
    }
    
    return child;
  }

  public static String getSubDivisionName(String divisionName)
  { int at = divisionName.indexOf('.');

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

  public static String getTopDivisionName(String divisionName)
  { int at = divisionName.indexOf('.');

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

  /**
   *  Write the METS file in an XML to a text-output sink
   *
   *  @param <code>PrintWriter</code> the destination of the output
   */
  public void write(PrintWriter writer)
  { String tag = XMLTools.getOpenTag("mets", "div");
    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);
    }
    writer.println(tag);

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

      tag = XMLTools.addAttribute(tag, "FILEID", fileList);
      
      tag = XMLTools.makeSingleton(tag);
      writer.println(tag);
    }

    // ..and then the metadata - this is the same code at present,
    // but is replicated here in case of future amendment.
    if (this.metadataRefs.size() > 0)
    { tag = XMLTools.getOpenTag("mets", "mptr");

      String metaList = this.writeList(this.metadataRefs);
      tag = XMLTools.addAttribute(tag, "METAID", metaList);
      tag = XMLTools.makeSingleton(tag);
      writer.println(tag);
    }
      
    // close the div element
    writer.println(XMLTools.getCloseTag("mets", "div"));
  }

  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 ? "Structure" : "Division");
    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 ? STRUCTURE_PARENT : DIVISION_PARENT);
    
    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);
      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);
      }
    }

    // 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;
    
    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");

      GS3SQLSelect 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", "=", DIVISION_PARENT);
      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.addSubDivision(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);
    }    
    return null;
  }
}