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

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