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

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 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;
    }

    /**
     *  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.toString().startsWith("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 void writeSQL(GS3SQLConnection connection)
    { // check if this node is in the
    GS3SQLInsert insert = new GS3SQLInsert("files");

    insert.addValue("FileLocType", this.location.getType());
    insert.addValue("FileLocation", this.location.getLocation().toString());
    insert.addValue("MIMEType", this.MIMEType);
    insert.addValue("ID", this.id.toString());

    connection.execute(insert.toString());  
    }
    
    /**
     *  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;
    }


    /**
     *  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();
    }
}