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

package org.greenstone.gsdl3.gs3build.metadata;

import java.io.PrintWriter;

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

import java.net.URL;
import java.net.URLConnection;

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

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;

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

/**
 *  An individual METS component file for a document.  Many features of METS are not
 *  currently fully supported/used here, but member variables exist for all of the
 *  standard members.
 */

public class METSFile
{
  METSFileID    id;
  METSFilePos   location;
  String        MIMEType;
  int           sequenceNo;
  long          size;
  METSDate      created;
  long          checkSum;
  List          adminRefs;
  List          describeRefs;
  METSFileGroup group;

  /**
   *  Create a new METSFile object, with the given properties.  The remaining
   *  fields are filled in with default values.
   *
   *  @param <code>String</code> the id of the file
   *  @param <code>METSFilePos</code> the location of the file
   *  @param <code>String</code> the MIME type of the file
   */
  public METSFile(METSFileID id, METSFilePos location, String mimeType)
  { this.id           = id;        // required
    this.location     = location;  // the location
    this.MIMEType     = mimeType;  // the MIME type;
    this.sequenceNo   = -1;       // -1 indicates unset
    this.size         = -1;        // -1 indicates unset
    this.checkSum     = -1;        // -1 indicates unset
    this.created      = null;
    this.adminRefs    = new ArrayList();
    this.describeRefs = new ArrayList();
    this.group        = null;
  }

  public boolean equals(URL url)
  { return this.location.equals(url);
  }

  /**
   *  Set the parent group
   *
   *  @param <code>METSFileGroup</code> the new holding file group
   */
  public void setGroup(METSFileGroup group)
  { this.group = group;
  }

  /**
   *  Get the parent group of this file
   *
   *  @return <code>METSFileGroup</code> the holding file group
   */
  public METSFileGroup getGroup()
  { return this.group;
  }

  /**
   *  Get the identifier of this file
   *
   *  @return <code>METSFileID</code> the file identifier
   */
  public METSFileID getID()
  { return this.id;
  }
  
  /**
   *  Set the identifier of this file
   *
   *  @param <code>METSFileID</code> the file identifier
   */
  public void setID(METSFileID id)
  { this.id = id;
  }

  /**
   *  @return <code>String</code> the MIME (content) type of the file
   */
  public String getMIMEType()
  { return this.MIMEType;
  }

  /**
   *  @return <code>URL</code> the location of the file.  This will often be in
   *          "file://" form.
   */
  public URL getLocation()
  { return this.location.getLocation();
  }

  /**
   *  Take a url and make a METSFile object out of it - works out
   *  details such as the Mime type, identifiers and other necessary
   *  information to call the constructor for METSFile
   *
   *  @param <code>URL</code> the url of the object - this may be a 
   *                          reference to a file on the local filestore
   *
   *  @return <code>METSFile</code> the METS file object for the corresponding
   *                                document component.
   */
  public static METSFile makeMETSFile(URL url, String mimeType)
  { 
    METSFile reply = new METSFile(new METSFileID(), new METSFilePos(url), mimeType);
    return reply;
  }
        
  public static METSFile makeMETSFile(URL url)
  { String mimeType;
  
    if (url.getProtocol().equals("file"))
    { // TODO: Work out the MIME type
      mimeType = URLConnection.getFileNameMap().getContentTypeFor(url.toString().substring(7));
      if (mimeType == null) 
      { mimeType = "text/plain";
      }
    }
    else
    { // TODO: look up the MIME type through the pertinent connection
      mimeType = HTTPTools.getMIMEType(url);
    }
    // TODO: make the identifier...
    
    return makeMETSFile(url, mimeType);
  }

  /**
   *  Write the METS file in an XML to a text-output sink
   *
   *  @param <code>PrintWriter</code> the destination of the output
   */
  public void write(PrintWriter writer)
  { String tag = XMLTools.getOpenTag("mets", "file");
    tag = XMLTools.addAttribute(tag, "MIMETYPE", this.MIMEType);
    tag = XMLTools.addAttribute(tag, "ID", this.id.toString());
    writer.println(tag);
    
    tag = XMLTools.getOpenTag("mets", "FLocat");
    tag = XMLTools.addAttribute(tag, "LOCTYPE", this.location.getType());
    tag = XMLTools.addAttribute(tag, "xlink:href", this.location.getLocation().toString());
    tag = XMLTools.addAttribute(tag, "ID", this.id.toString());
    tag = XMLTools.makeSingleton(tag);
    writer.println(tag);
    
    writer.println(XMLTools.getCloseTag("mets", "file"));
  }

    
  public boolean writeSQL(int groupReference, GS3SQLConnection connection)
  { // check if this file is in the table already...
    GS3SQLAction action;

    GS3SQLSelect select = new GS3SQLSelect("files");
    select.addField("*");
    GS3SQLWhereItem whereItem = new GS3SQLWhereItem("FileGroupRef", "=", Integer.toString(groupReference),
                            GS3SQLField.INTEGER_TYPE);
    GS3SQLWhere  where  = new GS3SQLWhere(whereItem);
    whereItem = new GS3SQLWhereItem("FileID","=", this.id.toString());
    where.add(whereItem);
    select.setWhere(where);
    connection.execute(select.toString());

    // if not, then make an insert action
    try {
      ResultSet results = connection.getResultSet();
      if (results == null ||
      !results.first())
      { GS3SQLInsert insert = new GS3SQLInsert("files");

        insert.addValue("FileGroupRef", Integer.toString(groupReference), GS3SQLField.INTEGER_TYPE);
    insert.addValue("FileID", this.id.toString());
    
    action = insert;
    
      }
      else {
    GS3SQLUpdate update = new GS3SQLUpdate("files");

    update.setWhere(where);
    action = update;
      }
    }
    catch (SQLException ex)
    { System.err.println(ex);
      return false;
    }
    action.addValue("FileLocType", this.location.getType());
    action.addValue("FileLocation", this.location.getLocation().toString());
    action.addValue("MIMEType", this.MIMEType);

    return connection.execute(action.toString());
  }

  public static METSFile readSQL(GS3SQLConnection connection, ResultSet parentSet)
  { 
    try {
      String locType = parentSet.getString("FileLocType");
      String location = parentSet.getString("FileLocation");
      String mimeType = parentSet.getString("MIMEType");
      String id = parentSet.getString("FileID");

      METSFileID metsID = new METSFileID(id);
      METSFilePos metsFilePos = new METSFilePos(locType, location);
      
      METSFile reply = new METSFile(metsID, metsFilePos, mimeType);
      return reply;
    }
    catch (SQLException ex)
    { System.out.println(ex);
    }
    catch (java.net.MalformedURLException urlEx)
    { System.out.println(urlEx);
    }
    return null;
  }
    
  /**
   *  Parse an XML Element as a METS File
   */
    /*
  public static METSFile parseXML(Element element, METSFileGroup parentGroup)
  { METSFile file = null;
    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 childElement = (Element) children.item(c);
      if (childElement.getNodeName().equals("mets:FLocat"))
      { METSFilePos filePos;
    
        // get most of the information from the child FLocat node
        String locationType = childElement.getAttribute("LOCTYPE");
    String href = childElement.getAttribute("xlink:href");
    String id   = childElement.getAttribute("ID");
      
    // some more data from the parent node
    String mimeType = element.getAttribute("MIMETYPE");

    try 
    { filePos = new METSFilePos(href, locationType);
    }
    catch (java.net.MalformedURLException ex)
    { // TODO: raise error
      continue;
    }
    file = new METSFile(new METSFileID(id), filePos, mimeType);
      }
      else if (childElement.getNodeName().equals("mets:FContent"))
      {
      }
      else
      { // TODO: raise an error!
      }
    }
    return file;
  }
    */


    public static METSFile parse_file(Element element, METSFileGroup group, String parseFilePath)
    {
    NodeList children = element.getChildNodes();

    METSFile thisFile = null;

    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:file")){
        METSFile.parse_file(child, group, parseFilePath);
        } else if (childName.equals("mets:FLocat")) {
        String mimeType = element.getAttribute("MIMETYPE");
        String fileId = element.getAttribute("ID");   
        
        METSFilePos thisFilePos = METSFile.parse_flocateXML(child, parseFilePath);
        thisFile = new METSFile(new METSFileID(fileId), thisFilePos, mimeType);
        group.addFile(thisFile);
        } else {
        System.err.println("Warning: unrecognised tag " +childName);
        }
    }
    return thisFile;
    }
    
    public static METSFilePos parse_flocateXML(Element element, String parseFilePath)
    {
    METSFilePos thisFilePos = null;
    
    // get most of the information from the child FLocat node
    String locationType = element.getAttribute("LOCTYPE");
    String href = element.getAttribute("xlink:href");
    String fileId = element.getAttribute("ID");
    
    try {
        thisFilePos = new METSFilePos(locationType, href);
       
        if (fileId.startsWith("default.")) {
        //retrieve the string after ..import/
        int importPosition = href.indexOf("import/")+7;
        href.substring(importPosition);
        if (fileId.equals("default.1")) {
            href = "file:" + parseFilePath+ "doctxt.xml";
        } else {
            href = "file:" + parseFilePath + href.substring(importPosition);
        }
        }
            thisFilePos = new METSFilePos(locationType, href);
    } catch (java.net.MalformedURLException ex) {
        // TODO: raise error
        System.err.println(ex);
    }
    return thisFilePos;
//  file = new METSFile(new METSFileID(id), filePos, mimeType);
//       }
//       else if (childElement.getNodeName().equals("mets:FContent"))
//       {
//       }
//       else
//       { // TODO: raise an error!
//       }
//     }
//     return file;
// }
    
    }


  /**
   *  Get the location of this file as a URL
   */
  public URL getURL()
  { return this.location.getLocation();
  }

  /**
   *  Get modified file date
   */
  public long getModifiedDatestamp()
  { return this.location.getModifiedDatestamp();
  }

  /**
   *  Overridden <code>toString</code> for convenience - returns the location of the file.
   *
   *  @return <code>String</code> the location of the file as a string
   */
  public String toString()
  { return this.location.toString();
  }
}