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

package org.greenstone.gsdl3.gs3build.metadata;

import java.io.PrintWriter;

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

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

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

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

public class METSStructure extends AbstractStructure
{
  String label;
  String type;
    METSDivision divGroup;

  public static final String STRUCTURE_TYPE = "Structure";
  
  public METSStructure(String id, String label, String type)
  { super(id);

    this.label    = label;
    this.type     = type;
    this.divGroup = null;
  }

  /**
   *  Show what sort of <code>AbstractStructure</code> this structure is...
   *
   *  @return <code>String The identifying string for a <code>METSStructure</code> type.
   */
  public String getStructureType()
  { return STRUCTURE_TYPE;
  }
  
  /**
   *  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 identifiers.
   */
  public void findDivisionsForFiles(List listOfFileIdentifiers, List resultList)
  { Iterator groups = this.children.values().iterator();
    while (groups.hasNext())
    { METSDivision group = (METSDivision) groups.next();

      group.findDivisionsForFiles(listOfFileIdentifiers, resultList);
    }    
  }

  /**
   *  Add a division further into this structure.
   *
   *  @param <code>String</code> the identifier label for the division
   *         within which the division is to be added.
   *  @param <code>METSDivision</code> the division to add.   
   */
  public void addSubDivision(String divisionLabel, METSDivision division)
  { String topDivision = METSDivision.getTopDivisionName(divisionLabel);

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

    child = child.getDivision(divisionLabel);

    if (child != null) {
      child.addDivision(division);
    }
  }

  /**
   *  Get a subdivision of a given identifier...
   * 
   *  @param <code>String</code> the identifier of the division
   *  @return <code>METSDivision</code> the division, which will be
   *          <code>null</code> if it is not found.
   */
  public METSDivision getDivision(String divisionLabel)
  { String topDivision = METSDivision.getTopDivisionName(divisionLabel);

  if (!topDivision.equals("All"))
    System.out.println("Top division is " + topDivision);
    METSDivision child = (METSDivision) this.children.get(topDivision);
    if (child == null)
      { System.out.println("No child found");
      Iterator groups = this.children.keySet().iterator();
      while (groups.hasNext()) {
    System.out.println(groups.next().toString());
      }
      return null;
    }


    child = child.getDivision(divisionLabel);

    return child;
  }


     /*
      *
      * parse an XML Element as a METSStructure Section
      *
      * @param <code>Element</code> the XML element which represents
      *  the mets:structMap itself 
      */
    
     public static METSStructure parseXML(Element element) 
     {
    String structId = element.getAttribute("ID");
    String structType = element.getAttribute("TYPE");
    String structLabel = element.getAttribute("LABEL");
 
    METSStructure thisStruct = new METSStructure (structId, structType, structLabel);
    
    NodeList divSecs = element.getChildNodes();
    if (divSecs != null) {
        for (int c = 0; c < divSecs.getLength(); c++) {
        if (divSecs.item(c).getNodeType() != org.w3c.dom.Node.ELEMENT_NODE){
            continue;
        }
        Element divElement = (Element) divSecs.item(c);
        String divName = divElement.getNodeName();
        if (divName.equals("mets:div")) {
            METSDivision division = METSDivision.parseXML(divElement);
            thisStruct.addDivision(division);
        } else {
            System.err.println("Error: mets:structMap was expecting mets:div but got "+divName);
        }
        }
    }
    return thisStruct;
     }
 
  /**
   *  Write this structure in XML(METS) format to a <code>PrintWriter</code>
   */
  public void write(PrintWriter writer)
  { Iterator groups = this.children.values().iterator();

    String tag = XMLTools.getOpenTag("mets", "structMap");
    tag = XMLTools.addAttribute(tag, "ID", this.ID.toString());
    tag = XMLTools.addAttribute(tag, "TYPE", this.type);
    tag = XMLTools.addAttribute(tag, "LABEL", this.label);
        
    writer.println(tag);
    while (groups.hasNext())
    { METSDivision group = (METSDivision) groups.next();

      group.write(writer);
    }
    writer.println("</mets:structMap>");
  }


  /**
   *  Write this METSStructure to an SQL database....
   *
   *  @param <code>DocumentInterface</code> the enclosing document.
   *  @param <code>GS3SQLConnection</code> the SQL database connection.
   */
  public boolean writeSQL(DocumentInterface document, GS3SQLConnection connection)
  { int sqlRef = -1;
    ResultSet results;

    // Prepare query to see if this structure has already been written
    GS3SQLSelect select = new GS3SQLSelect("structure");
    select.addField("StructureRef");
    GS3SQLWhereItem whereItem = new GS3SQLWhereItem("DocID", "=", document.getID().toString());
    GS3SQLWhereItem item = new GS3SQLWhereItem("StructureID", "=", this.ID.toString());
    GS3SQLWhere where = new GS3SQLWhere(whereItem);
    where.add(item);
    select.setWhere(where);

    // attempt to execute the query & get the current structure's reference
    try {
      connection.execute(select.toString());
      results = connection.getResultSet();
      if (results != null &&
      results.first())
      { sqlRef = results.getInt("structureRef");
      }
      else 
      { results = null;
      }
      
      if (results != null) {
    results.close();
      }
    }
    catch (SQLException sqlEx) {
      System.err.print(sqlEx);
      return false;
    }

    // insert a new structure if it wasn't there previously
    if (results == null) {
      GS3SQLInsert insert = new GS3SQLInsert("structure");
      insert.addValue("DocID", document.getID().toString());
      insert.addValue("StructureID", this.ID.toString());
      insert.addValue("StructureType", this.type);
      insert.addValue("Label", this.label);
      
      if (!connection.execute(insert.toString())) {
    return false;
      }

      // get the new structure reference by re-running the original select object
      connection.execute(select.toString());

      try {
    results = connection.getResultSet();
    results.first();
    sqlRef = results.getInt("StructureRef");
      }
      catch (SQLException sql) {
    System.err.println(sql);
    return false;
      }
    }
    else {
      GS3SQLUpdate update = new GS3SQLUpdate("structure");
      update.setWhere(where);

      update.addValue("StructureType", this.type);
      update.addValue("Label", this.label);

      connection.execute(update.toString());
    }
      
    // write out the child groups (Divisions) now...    
    Iterator groups = this.children.values().iterator();

    while (groups.hasNext())
    { METSDivision group = (METSDivision) groups.next();

      if (!group.writeSQL(document.getID(), sqlRef, true, connection))
      { return false;
      }
    }
    return true;
  }

  /**
   *  Read a METSStructure from a database - on entry, the current item in the
   *  <code>ResultSet</code> holds the row in the database with the structure's
   *  data.
   *
   *  @param <code>DocumentInterface</code> the document which owns the structure
   *  @param <code>GS3SQLConnection</code> the database connection itself, to load
   *         child objects through, etc.
   *  @param <code>ResultSet</code> pointing to the current row in the database.
   */
  public static METSStructure readSQL(DocumentInterface document, GS3SQLConnection connection,
                      ResultSet resultSet)
  {
    GS3SQLSelect select = null;

    try {
      String ID    = resultSet.getString("StructureID");
      String type  = resultSet.getString("StructureType");
      String label = resultSet.getString("Label");

      // create the metadata block object
      METSStructure structure = new METSStructure(ID, label, type);
      
      // get its metadata reference to retrieve divisions
      int structureRef = resultSet.getInt("StructureRef");

      // query the database for matching division for this structure block
      select = new GS3SQLSelect("divisions");
      select.addField("*");
      GS3SQLWhereItem whereItem = new GS3SQLWhereItem("ParentRef", "=", Integer.toString(structureRef),
                              GS3SQLField.INTEGER_TYPE);
      GS3SQLWhere where = new GS3SQLWhere(whereItem);
      whereItem = new GS3SQLWhereItem("ParentType", "=", METSStructure.STRUCTURE_TYPE);
      where.add(whereItem);
      select.setWhere(where);

      connection.execute(select.toString());

      // parse through the divisions
      ResultSet divisionSet = connection.getResultSet();
      if (divisionSet != null && divisionSet.first()) {
    do {
      METSDivision division = METSDivision.readSQL(connection, divisionSet);
      if (division != null) {
        structure.addDivision(division);
      }
    }
    while (divisionSet.next());
      }

      return structure;
    }
    catch (SQLException sqlEx)
    { System.out.println(sqlEx + " " + select.toString());
      System.exit(1);
    }
    return null;
  }
}