source: trunk/gsdl3/src/java/org/greenstone/gsdl3/gs3build/doctypes/DocumentList.java@ 5944

package org.greenstone.gsdl3.gs3build.doctypes;

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

import java.io.PrintWriter;
import java.io.FileWriter;
import java.io.File;
import java.io.IOException;

import java.net.URL;

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

import org.greenstone.gsdl3.gs3build.util.GS3SQLConnection;
import org.greenstone.gsdl3.gs3build.database.GS3SQLSelect;
import org.greenstone.gsdl3.gs3build.database.GS3SQLWhereItem;
import org.greenstone.gsdl3.gs3build.database.GS3SQLWhere;
import org.greenstone.gsdl3.gs3build.database.GS3SQLField;

public class DocumentList
{
  DocumentInterface []       list;       // what is currently cached
  int                        size;       // the maximum number in the cache
  int                        used;       // the actual number in the cache
  int                        count;      // the total number of known documents
  DocumentIDFactoryInterface idFactory;  // A manufacturer of novel document IDs
  GS3SQLConnection           connection; // used to query the SQL database

  private static final int maxSize = 10;

  public DocumentList(GS3SQLConnection connection)
  { this.idFactory = null;
    this.list  = new DocumentInterface[10];
    this.used  = 0;
    this.size  = 10;
    this.count = 0;
    this.connection = connection;
  }

  public DocumentList(DocumentIDFactoryInterface idFactory, GS3SQLConnection connection)
  { this.idFactory = idFactory;
    this.list  = new DocumentInterface[10];
    this.used  = 0;
    this.size  = 10;
    this.count = 0;
    this.connection = connection;
  }

  /**
   *  Write the document into the document list (cache) and the database.
   *
   *  @param <code>DocumentInterface</code> the document itself
   */
  public void addDocument(DocumentInterface document)
  { // increase cache size, etc. as necessary
    if (this.used == this.size) {
      if (this.size >= maxSize) {
    for (int i = 0; i < this.size - 1; i ++) {
      this.list[i] = this.list[i+1];
    }
    this.used --;
      }
      else {
    this.ensureSize((this.size * 2) > maxSize ? maxSize : (this.size * 2));
      }
    }
    
    // insert the document itself
    this.list[this.used] = document;

    // set the document identifier, if not already set
    if (document.getID() == null) {
      DocumentID id = this.idFactory.getNewDocumentID(document);
      document.setID(id);
    }

    // add to the database as well
    document.getSQLWriter().writeDocument(document, this.connection);

    // Remember that we've used one more item from the cache.
    this.used ++;

    // Note additional document
    this.count ++;
  }

  /**
   *  Note that an individual document is modified, and act accordingly
   *
   *  @param <code>DocumentInterface</code> the document
   */
  public void modifiedDocument(DocumentInterface document)
  { document.getSQLWriter().writeDocument(document, this.connection);
  }

  /**
   *  Get an iterator across all the documents, not merely those in
   *  the cache.  Note that this <code>Iterator</code> does <b>not</b>
   *  support the <code>remove()</code> function, and will raise an
   *  <code>UnsupportedOperationException</code> if you attempt to do
   *  so.
   *
   *  @return <code>Iterator</code> the iterator across the documents.
   */
  public Iterator iterator()
  { return new DocumentListIterator(connection);
  }

  /**
   *  Get the nth member of the <b>cached</b> document list.
   *
   *  @deprecated
   */
  public DocumentInterface getDocument(int index)
  { if (index < 0 || index >= this.used)
    { return null;
    }
    return this.list[index];
  }

  /**
  public DocumentID getDocumentID(int index)
  { if (index < 0 || index >= this.used)
    { return null;
    }
    return this.list[index].getID();
  }
  */

  protected void ensureSize(int size)
  { DocumentInterface [] newList = new DocumentInterface[size];
    System.arraycopy(this.list, 0, newList, 0, this.size);
    this.list = newList;
    this.size = size;
  }

  public void writeDocuments(File directory)
  { Iterator documents = this.iterator();
    int item = 0;

    while (documents.hasNext())
    { DocumentInterface document = (DocumentInterface) documents.next();
      try
      { item ++;
    File localFile = new File(directory, "Doc"+Integer.toString(item)+".xml");
    FileWriter fileWriter = new FileWriter(localFile);
    PrintWriter writer = new PrintWriter(fileWriter);
    document.getMETSWriter().writeDocument(document, writer);
    writer.close();
    fileWriter.close();
      }
      catch (IOException io)
      { 
      }
    }
  }

  public void writeSQLDocuments(GS3SQLConnection connection)
  { for (int i = 0; i < this.used; i ++)
    { this.list[i].getSQLWriter().writeDocument(this.list[i], connection);
    }
  }

  public static DocumentList readSQLDocuments(GS3SQLConnection connection)
  { DocumentList list = new DocumentList(connection);

    GS3SQLSelect select = new GS3SQLSelect("document");
    select.addField("*");
    
    ResultSet documents;
    try {
      connection.execute(select.toString());
      documents = connection.getResultSet();

      if (documents.first())
      { do
    { DocumentInterface document = AbstractDocument.readSQL(connection, documents);
          list.addDocument(document);
    }
    while (documents.next());
      }
    }
    catch (java.sql.SQLException ex)
    { System.out.println(ex);
      return null;
    }

    return list;
  }

  public int getCount()
  { return this.count;
  }

  public int size()
  { return this.used;
  }
}

class DocumentListIterator implements Iterator
{
  private boolean hasNext;
  private ResultSet resultSet;
  private GS3SQLConnection connection;

  public DocumentListIterator(GS3SQLConnection connection)
  {
    this.connection = connection;

    GS3SQLSelect select = new GS3SQLSelect("document");
    select.addField("*");

    try {
      connection.execute(select.toString());
      this.resultSet = connection.getResultSet();
      this.hasNext = this.resultSet.first();
    } catch (SQLException ex) {
      this.hasNext = false;
    }
  }

  public boolean hasNext()
  { return this.hasNext;
  }

  public Object next()
  {
    // get the 'next' document first
    DocumentInterface document = AbstractDocument.readSQL(connection, this.resultSet);

    // now actually step forward to the next item, so that we know if we have one!
    try {
      this.hasNext = this.resultSet.next();

      if (!this.hasNext) {
    this.resultSet.close(); // be a good citizen & close used result sets
      }
    } catch (SQLException ex) {
      this.hasNext = false;
    }
    return document;
  }
  
  public void remove() throws UnsupportedOperationException
  { throw new UnsupportedOperationException("DocumentList does not support iterator removal of documents");
  }

  public List getDocumentIdsWithFile(URL fileLocation)
  { List reply = new ArrayList();

    GS3SQLSelect select = new GS3SQLSelect("files");
    select.addField("*");
    GS3SQLWhere  where  = new GS3SQLWhere(new GS3SQLWhereItem("FileLocation", "=", fileLocation.toString()));
    select.setWhere(where);

    this.connection.execute(select.toString());

    ResultSet results = this.connection.getResultSet();
    if (results != null) {
      select = new GS3SQLSelect("filegroups");
      select.addField("DocID");
      select.setDistinct(true);
      
      where = new GS3SQLWhere();
      where.setCondition(GS3SQLWhere.OR_CONDITION);

      GS3SQLWhereItem whereItem = null;

      try {
    results.first();
    do {
      int fileGroupRef = results.getInt("FileGroupRef");
      whereItem = new GS3SQLWhereItem("FileGroupRef", "=", Integer.toString(fileGroupRef), GS3SQLField.INTEGER_TYPE);
      where.add(whereItem);
    }
    while (results.next());
    select.setWhere(where);
    results.close();
    
    this.connection.execute(select.toString());
    
    results = this.connection.getResultSet();
    results.first();
    do {
      String docId = results.getString("DocID");
      reply.add(docId);
    } while (results.next());
      } 
      catch (SQLException sqlEx)
      { System.err.println(sqlEx);
      }
    }
    return reply;
  }
}