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

package org.greenstone.gsdl3.gs3build.metadata;

/**
 *  A class to hold all the alternative file structures
 *  for a particular METS Document
 */

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

import java.io.File;
import java.io.PrintWriter;

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

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


import java.net.URL;

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

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

public class METSFileSet
{ Map    fileGroups;
  String reference;
  FileIdentifierFactory identifierFactory;
  FileGroupIdentifierFactory groupIdentifierFactory;

  class FileGroupIdentifierFactory extends AbstractIdentifierFactory
  { public static final String FILEGROUP_PRELUDE = "FG";

    public FileGroupIdentifierFactory()
    { super("FILEGROUP_PRELUDE");
    }
  }

  public METSFileSet()
  { this.fileGroups = new HashMap();
    this.fileGroups.put("default", new METSFileGroup("default"));
    this.reference = null;
    this.identifierFactory = new FileIdentifierFactory();
    this.groupIdentifierFactory = new FileGroupIdentifierFactory();
  }

  public long getModifiedDatestamp()
  { long reply = 0;

    Iterator groupsIter = this.fileGroups.values().iterator();
    while (groupsIter.hasNext())
    { METSFileGroup group = (METSFileGroup) groupsIter.next();

      long groupStamp = group.getModifiedDatestamp();
      if (groupStamp > reply)
      { reply = groupStamp;
      }
    }

    return reply;
  }
    

  /**
   *  Get a new FileGroup to lie within this fileset.  The group is not initialised with
   *  a parent, etc. - all that is done is the allocation of a unique group identifier.
   *
   *  @return <code>METSFileGroup</code> the new group.
   */
  public METSFileGroup createGroup()
  { METSFileGroup group = new METSFileGroup(this.groupIdentifierFactory.getNextIdentifier());
    return group;
  }

  public METSFile createFile(METSFilePos filePos, String type)
  { METSFile file = new METSFile(new METSFileID(this.identifierFactory.getNextIdentifier()), filePos, type);
    return file;
  }
  
  /**
   *  Get the group that corresponds to the given name...
   *
   *  @param <code>String</code> the name of the group.
   *  @return <code>METSFileGroup</code> the group object - this will be
   *          <code>null</code> if the group is not found
   */
  public METSFileGroup getGroup(String name)
  { if (!this.fileGroups.containsKey(name))
    { return null;
    }
    return (METSFileGroup) this.fileGroups.get(name);
  }

  /**
   *  Get the Nth file from the default group...
   *
   *  @param <code>int</code> the index into the default group to use...
   *  @return <code>METSFile</code> the file.
   */
  public METSFile getFile(int index)
  { METSFileGroup group = this.getGroup("default");

    if (group == null)
    { return null;
    }
    return group.getFile(0);
  }

  /**
   *  Add a file to the default file group
   */
  public void addFile(METSFile file)
  { METSFileGroup defaultGroup = (METSFileGroup) this.fileGroups.get("default");
    defaultGroup.addFile(file);
  }

  /**
   *  Add a file to the default file group
   *
   *  @return <code>METSFile</code> an object that wraps the given url into
   *          a METS file object
   */
  public METSFile addFile(URL url)
  { METSFile file = METSFile.makeMETSFile(url);
    this.addFile(file);
    return file;
  }

  public void addFile(METSFile file, String toGroup)
  { METSFileGroup destGroup = (METSFileGroup) this.fileGroups.get(toGroup);

    if (destGroup == null)
    { destGroup = new METSFileGroup(toGroup);
      this.fileGroups.put(destGroup.getId(), destGroup);
    }
        
    destGroup.addFile(file);
  }

  public void addFile(URL url, String toGroup)
  { METSFile file = METSFile.makeMETSFile(url);
    this.addFile(file, toGroup);
  }

  /**
   *  Add a group at the top level of the METS File set.
   *
   *  @param <code>METSFileGroup</code> the file group to add.
   */
  public void addGroup(METSFileGroup group)
  { this.fileGroups.put(group.getId(), group);
  }

  /**
   *  Get all the groups that contain a given URL/file.
   *
   *  @param <code>URL</code> the location of the file.
   *  @return <code>List</code> the list of group references that contain the file.
   */
  public List findGroups(URL file)
  { List resultList = new ArrayList();

    Iterator groups = this.fileGroups.values().iterator();

    while (groups.hasNext())
    { METSFileGroup group = (METSFileGroup) groups.next();
      
      group.findGroups(file, resultList);
    }
    return resultList;
  }
    
    /*
     *
     *
     */
    public static METSFileSet parseXML(NodeList fileSecs, METSFileSet fileSet, String parseFilePath) {
    
    //METSFileSet set = new METSFileSet();> 
    // this is in effect a group without a sense of 'self'...
    for (int c = 0; c < fileSecs.getLength(); c++) {
        if (fileSecs.item(c).getNodeType() != org.w3c.dom.Node.ELEMENT_NODE){
        continue;
        }
        
        METSFileGroup groups = METSFileGroup.parse_groupXML((Element)fileSecs.item(c), fileSet, parseFilePath, null);
    }
    return fileSet;
    }
    

  public void write(PrintWriter writer)
  { Iterator groups = this.fileGroups.values().iterator();

    writer.println("<mets:fileSec>");
    while (groups.hasNext())
    { METSFileGroup group = (METSFileGroup) groups.next();

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

  public boolean writeSQL(DocumentInterface document, GS3SQLConnection connection)
  { Iterator groups = this.fileGroups.values().iterator();

    // write the set if the reference does not already exist...
    if (this.reference == null)
    { // Insert the file section into the database
      GS3SQLInsert insert = new GS3SQLInsert("filesection");
      insert.addValue("DocID", document.getID().toString());
      insert.addValue("FileSecID", "test"); // TODO: remove magic string

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

      // find the file section number
      GS3SQLSelect select = new GS3SQLSelect("filesection");
      select.addField("*");
      GS3SQLWhereItem whereItem = new GS3SQLWhereItem("FileSecID", "=", "test");
      GS3SQLWhereItem whereDoc  = new GS3SQLWhereItem("DocID", "=", document.getID().toString());
      GS3SQLWhere where = new GS3SQLWhere(whereItem);
      where.add(whereDoc);
      select.setWhere(where);

      try {
    connection.execute(select.toString());
    
    ResultSet set = connection.getResultSet();
    set.first();
    int sectionRef = set.getInt("FileSectionRef");

    this.reference = Integer.toString(sectionRef);
      }
      catch (SQLException ex)
      { System.out.println(ex);
        return false;
      }
    }
    
    // write out the children
    while (groups.hasNext())
    { METSFileGroup group = (METSFileGroup) groups.next();
      
      if (!group.writeSQL(document, this.reference, true, connection))
      { return false;
      }
    }

    return true;
  }

  public static METSFileSet readSQL(DocumentInterface document, GS3SQLConnection connection)
  { 
    METSFileSet set = new METSFileSet();    

    // Get file sections from the filesection table (currently redundant)
    GS3SQLSelect select = new GS3SQLSelect("filesection");
    select.addField("*");
    GS3SQLWhereItem whereItem = new GS3SQLWhereItem("DocID", "=", document.getID().toString());
    select.setWhere(new GS3SQLWhere(whereItem));
    connection.execute(select.toString());
    
    // Get the identifier for this file set, etc.
    ResultSet sections = connection.getResultSet();
    int fileSetRef;
    try {
      sections.first();
      fileSetRef     = sections.getInt("FileSectionRef");
      set.reference = Integer.toString(fileSetRef);
    }
    catch (SQLException ex)
    { System.out.println(ex);
      return null;
    }
    
    // Get child file groups
    select = new GS3SQLSelect("filegroups");
    select.addField("*");
    whereItem = new GS3SQLWhereItem("DocID", "=", document.getID().toString());    
    GS3SQLWhere where = new GS3SQLWhere(whereItem);
    whereItem = new GS3SQLWhereItem("ParentRef", "=", Integer.toString(fileSetRef), 
                    GS3SQLField.INTEGER_TYPE);
    where.add(whereItem);
    whereItem = new GS3SQLWhereItem("ParentType", "=", METSFileGroup.SECTION_PARENT);
    where.add(whereItem);
    select.setWhere(where);
    connection.execute(select.toString());

    // start going through the matching file groups
    try {
      ResultSet resultSet = connection.getResultSet();
      resultSet.first();
      do {
    METSFileGroup filegroup = METSFileGroup.readSQL(document, connection, resultSet);
    if (filegroup != null) {
      set.addGroup(filegroup);
    }
      } while (resultSet.next());
    }
    catch (SQLException sqlEx) {
      System.out.println(sqlEx);
      System.exit(1);
    }

    return set;
  }

}