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

package org.greenstone.gsdl3.gs3build.metadata;

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

import java.net.URL;

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

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


import java.io.PrintWriter;

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

import org.greenstone.gsdl3.gs3build.doctypes.DocumentInterface;

/**
 *  Child groups are indicated by colons.  E.g. Chapter1:Section1 would indicate
 *  the group "Section1" inside the "Chapter1" group...
 */

public class METSFileGroup
{ List   children;
  List   childGroups;
  String id;

  public static final String SECTION_PARENT = "Section";
  public static final String GROUP_PARENT = "Group";

  public METSFileGroup(String id)
  { this.children = new ArrayList();
    this.childGroups = new ArrayList();
    this.id = id;
  }

  /**
   *  Get the modified datestamp that applies for this file group.  An empty group
   *  will return <code>0</code>.
   *
   *  @return <code>long</code> the date modified as milliseconds from the 1st January 1970
   */
  public long getModifiedDatestamp()
  { long reply = 0; // empty groups reply '0'

    Iterator childIter = children.iterator();
    while (childIter.hasNext())
    { METSFile file = (METSFile) childIter.next();
      long fileStamp = file.getModifiedDatestamp();
      if (fileStamp > reply) {
    reply = fileStamp;
      }
    }

    childIter = childGroups.iterator();
    while (childIter.hasNext())
    { METSFileGroup fileGroup = (METSFileGroup) childIter.next();
      long fileStamp = fileGroup.getModifiedDatestamp();
      if (fileStamp > reply) {
    reply = fileStamp;
      }
    }

    return reply;
  }
    
  /**
   *  Find all the occurrences of a given file, and place them
   *  in a <code>List</code>.
   */
  public void findGroups(URL findFile, List resultList)
  { 
    // find in this particular group
    Iterator childIter = children.iterator();
    while (childIter.hasNext())
    { METSFile file = (METSFile) childIter.next();
      if (file.equals(findFile))
      { resultList.add(this.id);
      }
    }

    // iterate over the child groups
    childIter = childGroups.iterator();
    while (childIter.hasNext())
    { METSFileGroup fileGroup = (METSFileGroup) childIter.next();

      fileGroup.findGroups(findFile, resultList);
    }
  }

  /**
   *  Get a sub group of this METSFileGroup.
   *
   *  @param <code>String</code> the name of the subgroup
   *  @return <code>METSFileGroup</code> the child group, which will
   *          be <code>null</code> if the group is not known.
   */
  public METSFileGroup getSubgroup(String id)
  { String childId;
  
    int dotAt = id.indexOf(':');
    if (dotAt == -1)
    { childId = null;
    }
    else
    { childId = id.substring(dotAt+1);
      id = id.substring(0, dotAt);
    }
    
    // iterate over the child groups
    Iterator childIter = childGroups.iterator();
    while (childIter.hasNext())
    { METSFileGroup group = (METSFileGroup) childIter.next();
    
      if (group.id.equals(id)) {
    if (childId == null) {
      return group;
    }
    else {
      return group.getSubgroup(childId);
    }
      }
    }
    return null;
  }

  /**
   *  Add a filegroup to this group of files.
   *
   *    @param <code>METSFileGroup</code> the filegroup.
   */
  public void addGroup(METSFileGroup group)
  { this.childGroups.add(group);
  }

  /**
   *  Add a file to this group of files.
   *
   *    @param <code>METSFile</code> the file in a METS File object.
   */
  public void addFile(METSFile file)
  { this.children.add(file);
    file.setGroup(this);
    if (!file.getID().isDefined())
    { file.setID(new METSFileID(this.id + "." + Integer.toString(this.children.size())));
    }
  }

  /**
   *  Get the nth child of the group
   *
   *  @param <code>int</code> the index into the group
   *  @return <code>METSFile</code> the corresponding child.  This may be <code>null</code>
   *          particularly if the index given falls outside of the valid range of child
   *          indexes.
   */
  public METSFile getFile(int index)
  { if (index < 0 || index >= this.children.size())
    { return null;
    }
  
    return (METSFile) this.children.get(index);
  }

  /**
   *  Get all the files in the group as a <code>List</code>
   *
   *  @return <code>List</code> the file childen of the group.
   */
  public List getFiles()
  { return this.children;
  }

  /**
   *  Get all the subgroups as a <code>List</code>
   */
  public List getSubgroups()
  { return this.childGroups;
  }

  /**
   *  Get the number of files in the group
   *
   *  @return <code>int</code> the count
   */
  public int noOfFiles()
  { return this.children.size();
  }

  /**
   *  Get the number of subgroups.
   */
  public int noOfSubgroups()
  { return this.childGroups.size();
  }

  /**
   *  @return <code>String</code> the name of this group
   */
  public String getId()
  { return this.id;
  }

     public static METSFileGroup parse_groupXML(Element element, METSFileSet set, String parseFilePath, METSFileGroup group)
     {
    //deal with mets:fileGrp
    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:fileGrp")) {
        String groupId = child.getAttribute("ID");
        METSFileGroup childGroup = new METSFileGroup(groupId);
 
        if (group != null){
            group.addGroup(childGroup);
        } else {
            set.addGroup(childGroup);
        }
        METSFile file = METSFile.parse_file(child, childGroup, parseFilePath);
        }
    }
    return group;
     }

  /**
   *  Write the object in an XML METS format.
   *
   *  @param <code>PrintWriter</code> the printwriter being used to write the object
   */
  public void write(PrintWriter writer)
  { String tag = XMLTools.getOpenTag("mets","fileGrp");
    tag = XMLTools.addAttribute(tag, "ID", this.id);
    writer.println(tag);
        
    Iterator childIter = children.iterator();
    while (childIter.hasNext())
    { METSFile file = (METSFile) childIter.next();
      file.write(writer);
    }
    writer.println(XMLTools.getCloseTag("mets","fileGrp"));
  }

  public boolean writeSQL(DocumentInterface document, String parentRef, boolean parentIsSection, 
              GS3SQLConnection connection)
  { int sqlId = -1;

    // check if this node is in the database already
    GS3SQLSelect select = new GS3SQLSelect("filegroups");
    select.addField("*");
    GS3SQLWhereItem whereItem = new GS3SQLWhereItem("FileGroupID", "=", this.id);
    GS3SQLWhereItem whereDoc  = new GS3SQLWhereItem("DocID", "=", document.getID().toString());
    GS3SQLWhere where = new GS3SQLWhere(whereItem);
    where.add(whereDoc);
    select.setWhere(where);

    connection.execute(select.toString());

    ResultSet selectResult = connection.getResultSet();

    try {
      if (selectResult == null ||
      !selectResult.first()) {
    GS3SQLInsert insert = new GS3SQLInsert("filegroups");

    insert.addValue("DocID", document.getID().toString());
    insert.addValue("FileGroupID", this.id);
    insert.addValue("ParentRef", parentRef, GS3SQLField.INTEGER_TYPE);
    insert.addValue("ParentType", parentIsSection ? SECTION_PARENT : GROUP_PARENT);
    
    if (!connection.execute(insert.toString())) {
      return false;
    }
      }
      else {
    // TODO: update the data for this file group...
      }
    }
    catch (SQLException ex)
    { System.err.println(ex);
      return false;
    }
        
    // get the filegroup reference now
    connection.execute(select.toString());
    
    try {
      ResultSet results = connection.getResultSet();
      if (results == null) {
    return false;
      }
      results.first();
      sqlId = results.getInt("FileGroupRef");
    }
    catch (SQLException sqlex) {
      System.out.println(sqlex);
      return false;
    }

    // iterate over the child groups
    Iterator childIter = childGroups.iterator();
    while (childIter.hasNext())
    { METSFileGroup fileGroup = (METSFileGroup) childIter.next();

      if (!fileGroup.writeSQL(document, Integer.toString(sqlId), false, connection))
      { return false;
      }
    }

    // iterate over the child files
    childIter = children.iterator();
    while (childIter.hasNext())
    { METSFile file = (METSFile) childIter.next();
    
      if (!file.writeSQL(sqlId, connection))
      { return false;
      }
    }

    return true;
  }

  public static METSFileGroup readSQL(DocumentInterface document, GS3SQLConnection connection,
                      ResultSet resultSet)
  {
    try {
      String ID         = resultSet.getString("FileGroupID");
      String parentType = resultSet.getString("ParentType");
      String parentRef  = resultSet.getString("ParentRef");

      // create the metadata block object
      METSFileGroup group = new METSFileGroup(ID);
      
      // get its metadata reference to retrieve divisions
      int groupRef = resultSet.getInt("FileGroupRef");

      // query the database for matching groups which are children of this one
      GS3SQLSelect select = new GS3SQLSelect("filegroups");
      select.addField("*");
      GS3SQLWhereItem whereItem = new GS3SQLWhereItem("ParentRef", "=", Integer.toString(groupRef),
                              GS3SQLField.INTEGER_TYPE);
      GS3SQLWhere where = new GS3SQLWhere(whereItem);
      whereItem = new GS3SQLWhereItem("ParentType", "=", METSFileGroup.GROUP_PARENT);
      where.add(whereItem);
      select.setWhere(where);

      connection.execute(select.toString());

      // parse through the child groups
      ResultSet childSet = connection.getResultSet();
      if (childSet.first()) {
    do {
      METSFileGroup fileGroup = METSFileGroup.readSQL(document, connection, childSet);
      if (fileGroup != null) {
        group.addGroup(fileGroup);
      }
    }
    while (childSet.next());
      }

      // now scan for file members
      select = new GS3SQLSelect("files");
      select.addField("*");
      whereItem = new GS3SQLWhereItem("FileGroupRef", "=", Integer.toString(groupRef),
                      GS3SQLField.INTEGER_TYPE);
      where = new GS3SQLWhere(whereItem);
      select.setWhere(where);
      connection.execute(select.toString());

      ResultSet childFileSet = connection.getResultSet();
      if (childFileSet != null && childFileSet.first()) {
    do {
      METSFile file = METSFile.readSQL(connection, childFileSet);
      if (file != null) {
        group.addFile(file);
      }
    }
    while (childFileSet.next());
      }

      return group;
    }
    catch (SQLException sqlEx)
    { System.out.println(sqlEx);
      System.exit(1);
    }
    return null;
  }
}