/**
 *  '$RCSfile$'
 *    Purpose: A class to asyncronously do delta-T replication checking
 *  Copyright: 2000 Regents of the University of California and the
 *             National Center for Ecological Analysis and Synthesis
 *    Authors: Chad Berkley
 *
 *   '$Author: leinfelder $'
 *     '$Date: 2011-11-03 03:40:12 +0000 (Thu, 03 Nov 2011) $'
 * '$Revision: 6595 $'
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package edu.ucsb.nceas.metacat;

import java.io.StringReader;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Hashtable;
import java.util.Vector;

import org.apache.log4j.Logger;
import org.apache.xpath.objects.XObject;
import org.apache.xpath.XPathAPI;
import org.apache.xerces.parsers.DOMParser;
import org.apache.xerces.dom.DocumentTypeImpl;
import org.w3c.dom.Attr;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.NodeList;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.DocumentType;
import org.xml.sax.InputSource;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.*;
import javax.xml.transform.stream.*;
import javax.xml.transform.dom.*;

import org.ecoinformatics.eml.EMLParser;

import edu.ucsb.nceas.metacat.database.DBConnection;
import edu.ucsb.nceas.metacat.database.DBConnectionPool;
import edu.ucsb.nceas.metacat.properties.PropertyService;
import edu.ucsb.nceas.metacat.util.DocumentUtil;
import edu.ucsb.nceas.metacat.util.MetacatUtil;
import edu.ucsb.nceas.utilities.PropertyNotFoundException;
/**
 * This class will figure out which content type it is for a given data file.
 * First, from xml_relation to get all relative files to this data file.
 * Then from xml_documents to get physical files. From physical file pull out
 * the content type
 */
public class ContentTypeProvider
{
  private String dataFileId = null;
  private String contentType = null;
  private String packageType = null;
  private Hashtable contentTypeHash = new Hashtable();

  //Constant
  private String BETA = "beta";
  private String EML2 = "eml2";
  private static String DEFAULTCONTENTTYPE;
  static {
		try {
			DEFAULTCONTENTTYPE = PropertyService.getProperty("replication.defaultcontenttype");
		} catch (PropertyNotFoundException pnfe) {
			System.err.println("Could not get property DEFAULTCONTENTTYPE:" 
					+ pnfe.getMessage());
		}
	}
  private String FORMATPATH = "//format";
  private String TEXT       = "text";
  private String TEXTYPE    ="text/plain";
  private String XML        = "xml";
  private String XMLTYPE    = "text/xml";
  private String HTML       = "HTML";
  private String HTMLTYPE   = "text/html";
  private String GIF        = "gif";
  private String JPEG       = "jpeg";
  private String JPEGTYPE   = "image/jpeg";
  private String GIFTYPE    = "image/gif";
  private String BMP        = "bmp";
  private String BMPTYPE    = "image/bmp";
  private String TAR        = "tar";
  private String TARTYPE    ="application/x-tar";
  private String ZIP        = "zip";
  private String ZIPTYPE    = "application/x-zip-compressed";
  private String BINARY     = "binary";
  private String BINARYTYPE = "application/octet-stream";

  private String ENTITYDOCTYPE = "xml.entitydoctype";
  private String PHYSICALDOCTYPE = "xml.physicaldoctype";
  private String EML2DOCTYPE = "eml2namespace";
  private String DATAFORMAT = "dataFormat";
  private String TEXTFORMAT = "textFormat";
  private String EXTENALFORMAT = "externallyDefinedFormat";
  private String FORMATNAME = "formatName";
  private String BINARYRASTERFORMAT = "binaryRasterFormat";

  private String DATAFILEPATH ="//physical/distribution/online/url";
  private static Logger logMetacat = Logger.getLogger(ContentTypeProvider.class);

  /**
   * Constructor of ContentTypeProvider
   */
  public ContentTypeProvider(String docIdWithRevision)
  {
    dataFileId = DocumentUtil.getDocIdFromString(docIdWithRevision);
    //get relative doclist for data file and package type
    Vector docLists = null;
    docLists = getRelativeDocIdList(dataFileId);

    if ( packageType == null)
    {
      // other situation, contenetype is default value
      contentType = DEFAULTCONTENTTYPE;
    }
    else if (packageType.equals(BETA))
    {
      // for beta package and get entity docid for the data file
      String entityDocid = getTargetDocIdForBeta(docLists, ENTITYDOCTYPE);
      // get physical docid for data file
      docLists = getRelativeDocIdList(entityDocid);
      String physicalDocId = getTargetDocIdForBeta(docLists, PHYSICALDOCTYPE);
      // if no physical docid assign to this data file, content type is default
      if (physicalDocId == null)
      {

        contentType = DEFAULTCONTENTTYPE;
      }
      else
      {

        parsePhysicalDocumentForBeta(physicalDocId);
      }
    }
    else if (packageType.equals(EML2))
    {
      // for eml2 package
      // get eml document for data file
      //String eml2Docid = getTargetDocIdForBeta(docLists, EML2DOCTYPE);
      String eml2Docid = (String)docLists.elementAt(0);
      findContentTypeInEML2(eml2Docid);

    }

  }

  /** Method to get content type */
  public String getContentType()
  {
    return contentType;
  }//getContentType

  /* Method to find content type base on data format*/
  private void findContentTypeInEML2(String eml2DocId)
  {
    if (eml2DocId == null)
    {
      contentType = DEFAULTCONTENTTYPE;
      return;
    }
    DocumentImpl xmlDoc = null;
    String xmlString = null;
    StringReader read = null;
    InputSource in = null;
    DocumentBuilderFactory dfactory = null;
    Document doc = null;
    // create xml document
    try
    {
      String accNumber = eml2DocId + PropertyService.getProperty("document.accNumSeparator") +
                    DBUtil.getLatestRevisionInDocumentTable(eml2DocId);
      //System.out.println("the acc number is !!!!!!!!!!!!!!!!!"+accNumber);
      xmlDoc = new DocumentImpl(accNumber);
      xmlString = xmlDoc.toString();
      //System.out.println("the xml doc is "+xmlDoc);
      // create dom tree
      read = new StringReader(xmlString);
      in = new InputSource(read);
      dfactory = DocumentBuilderFactory.newInstance();
      dfactory.setNamespaceAware(false);
      doc = dfactory.newDocumentBuilder().parse(in);
    }
    catch (Exception e)
    {
      // if faild, set default value
      contentType = DEFAULTCONTENTTYPE;
      logMetacat.error("Error in ContentTypeProvider." +
                         "findContentTypeInEML2()" + e.getMessage());
      return;
    }
    Node dataFormatNode = findDataFormatNodeInEML2(doc, DATAFILEPATH,
                                                   dataFileId);
    if (dataFormatNode == null)
    {
      contentType = DEFAULTCONTENTTYPE;
      logMetacat.info("Couldn't find data format node");
      return;

    }
    NodeList childList  = dataFormatNode.getChildNodes();
    // go through childList
    for (int i = 0; i<childList.getLength(); i++)
    {
      Node child = childList.item(i);

      // if has text format child set to text/plain
      if (child.getNodeName() != null && child.getNodeName().equals(TEXTFORMAT))
      {
        logMetacat.info("in text format");
        contentType = TEXTYPE;
      }

      //external format
      if (child.getNodeName() != null && child.getNodeName().equals(EXTENALFORMAT))
      {
        logMetacat.info("in external format ");
        String format = getTextValueForGivenChildTag(child, FORMATNAME);
        logMetacat.info("The format is: "+format);
        // if we can find the format in the contentTypeHash table
        contentType = (String)lookUpContentType(format);
        if (contentType == null)
        {
          contentType = BINARYTYPE;
        }
      }

      // binaryRasterFormat
      if (child.getNodeName() != null && child.getNodeName().
          equals(BINARYRASTERFORMAT))
      {
        contentType = BINARYTYPE;
      }//if
    }//for
    //if contentype still be null, set default value
    if (contentType == null)
    {
      contentType = DEFAULTCONTENTTYPE;
    }
  }

  /* Method get text value of given child tagname*/
  private String getTextValueForGivenChildTag(Node parentNode,
                                              String childTagName)
  {
    String textValue = null;
    NodeList childList = parentNode.getChildNodes();
    for (int i= 0; i<childList.getLength();i++)
    {
      Node child = childList.item(i);
      if (child.getNodeName() != null && child.getNodeName().equals(childTagName))
      {
        logMetacat.info("Find child node: " + childTagName);
        Node textNode = child.getFirstChild();
        if (textNode.getNodeType() == Node.TEXT_NODE)
        {
          textValue = textNode.getNodeValue();
        }//if
      }//if
    }//for
    logMetacat.info("The text value for element- " + childTagName +
                             " is " + textValue);
    return textValue;
  }//getTExtValueForGivenChildTag

  /* Find the data format node in eml2 document */
  private Node findDataFormatNodeInEML2(Document xml, String xPath,
                                       String targetDocId)
  {
    Node targetNode = null;
    Node node = findDataFileNodeInEML2(xml, xPath, targetDocId);
    if (node != null)
    {
      // get the phycial the prent is online, grandparent is distribution
      // the grand'parent is physical
      Node phyicalNode = node.getParentNode().getParentNode().getParentNode();
      NodeList list = phyicalNode.getChildNodes();
      for (int i = 0; i < list.getLength(); i++)
      {
        Node kid = list.item(i);
        // find dataFormat node
        if (kid.getNodeType() == node.ELEMENT_NODE &&
            kid.getNodeName().equals(DATAFORMAT))
        {
          targetNode = kid;
          break;
        } //if
      } //for
      if (targetNode != null)
      {
        logMetacat.info("dataFormat node'name: " +
                                 targetNode.getNodeName());
      }
    }//if
    return targetNode;
  }
  /* Find the datafile node */
  private Node findDataFileNodeInEML2(Document xml, String xPath,
                                String targetDocId)
  {
    Node dataFileNode = null;
    NodeList list = null;
    try
    {
      list = XPathAPI.selectNodeList(xml, xPath);
    }
    catch (Exception e)
    {
      // catch an error and return null
      logMetacat.error("Error in findDataFileNode: "+e.getMessage());
      return dataFileNode;
    }
    // go through the list and find target docid in online/url
    if (list != null)
    {
      for (int i = 0; i < list.getLength(); i++)
      {
        Node node = list.item(i);
        Node textNode = node.getFirstChild();
        if (textNode.getNodeType() == node.TEXT_NODE)
        {
          String URLData = textNode.getNodeValue();
          logMetacat.info("online/url text data: " + URLData);
          //Only handle ecogrid data file
          if (URLData.indexOf(DBSAXHandler.ECOGRID) != -1 )
          {
            // Get docid from url
            String docId = 
            	DocumentUtil.getAccessionNumberFromEcogridIdentifier(URLData);
            // Get rid of revision
            docId = DocumentUtil.getDocIdFromAccessionNumber(docId);
            logMetacat.info("docid from url element in xml is: " +
                                     docId);
            //if this docid equals target one, we find it
            if (docId != null && docId.equals(targetDocId))
            {
              logMetacat.info("Find target docid in online/url: " +
                                       docId);
              dataFileNode = node;
              break;
            }
          } //if

        } //if
      } //for
    }//if

    return dataFileNode;
  }//findDataFileNode

  /* Get relative docid list and packagetype */
  private Vector getRelativeDocIdList(String id)
  {
    Vector docList = new Vector();
    String sql = "SELECT packagetype, subject from xml_relation " +
                 "where object = ?";
    ResultSet rs = null;
    PreparedStatement pStmt=null;
    DBConnection conn = null;
    int serialNumber = -1;
    try
    {
      //check out DBConnection
      conn=DBConnectionPool.getDBConnection
                                   ("ContentTypeProvider.getRelativeDocIdlist");
      serialNumber=conn.getCheckOutSerialNumber();
      pStmt = conn.prepareStatement(sql);
      // binding value
      pStmt.setString(1, id);
      //execute query
      pStmt.execute();
      rs = pStmt.getResultSet();
      // get result list
      String packType = null;
      while (rs.next())
      {
        packType = rs.getString(1);
        String subject = rs.getString(2);

        // get rid of duplicate record and add the docid into vector
        if (!docList.contains(subject))
        {

          docList.add(subject);
        }
      }//while

      // set up data package type
      if ((MetacatUtil.getOptionList(PropertyService.getProperty("xml.packagedoctype"))).
                                     contains(packType))
      {
        //this is beta4 or beta6 version
        logMetacat.info("This is beta package");
        packageType = BETA;
      }
      else if ((MetacatUtil.getOptionList
               (PropertyService.getProperty("xml.eml2_0_0namespace"))).contains(packType))
      {
        // this eml 2 document
        logMetacat.info("This is EML2.0.0 package");
        packageType = EML2;
      }
      else if ((MetacatUtil.getOptionList
               (PropertyService.getProperty("xml.eml2_0_1namespace"))).contains(packType))
      {
        // this eml 2 document
        logMetacat.info("This is EML2.0.1 package");
        packageType = EML2;
      }



    }//try
    catch(SQLException e)
    {

      logMetacat.error("ContenTypProvider.getRelativeDoclist1 " +
                             e.getMessage());
    }//catch
    catch(PropertyNotFoundException pnfe)
    {
      logMetacat.error("ContenTypProvider.getRelativeDoclist1 " +
                             pnfe.getMessage());
    }//catch
    finally
    {
      try
      {
        pStmt.close();
      }
      catch (SQLException ee)
      {
        logMetacat.error("ContenTypProvider.getRelativeDoclist2 " +
                             ee.getMessage());
      }
      finally
      {
        DBConnectionPool.returnDBConnection(conn, serialNumber);
      }
    }//finally

    return docList;
  }// getRelativeDocIdList

  /* Method to get physical document for data file in xml_documents table for
   * beta eml package
   */
  private String getTargetDocIdForBeta(Vector list, String targetType)
  {
    String docId = null;
    // make sure list is not empty
    if (list.isEmpty())
    {

      return docId;
    }
    // get sql command
    String sql = "SELECT doctype, docid from xml_documents where docid in ( ";
    // the first element
    sql = sql + "?";
    // remaining values
    for (int i = 1; i < list.size(); i++) {
      sql = sql + ", ?";
    }
    // add parentheses
    sql = sql + ")";
    logMetacat.info("SQL for select doctype: "+ sql);
    ResultSet rs = null;
    PreparedStatement pStmt=null;
    DBConnection conn = null;
    int serialNumber = -1;
    try
    {
      //check out DBConnection
      conn=DBConnectionPool.getDBConnection
                                 ("ContentTypeProvider.setPhycialDocIdForBeta");
      serialNumber=conn.getCheckOutSerialNumber();
      pStmt = conn.prepareStatement(sql);
      // set the parameter values
      for (int i = 0; i < list.size(); i++) {
        String docid = (String) list.elementAt(i);
        pStmt.setString(i+1, docid);
      }
      //execute query
      pStmt.execute();
      rs = pStmt.getResultSet();
      // get result list
      while (rs.next())
      {
        String packType = rs.getString(1);
        String targetId  = rs.getString(2);
        // find physical document
        if ((MetacatUtil.getOptionList(PropertyService.getProperty(targetType))).
                                     contains(packType))
       {
         // assign physical document and jump out the while loop
         docId = targetId;
         break;
       }
      }//while

    }//try
    catch(SQLException e)
    {

      logMetacat.error("ContenTypProvider.setPhysicalDocIdForBeta1 " +
                             e.getMessage());
    }//catch
    catch(PropertyNotFoundException pnfe)
    {

      logMetacat.error("ContenTypProvider.setPhysicalDocIdForBeta1 " +
                             pnfe.getMessage());
    }//catch
    finally
    {
      try
      {
        pStmt.close();
      }
      catch(SQLException ee)
      {
        logMetacat.error("ContenTypProvider.setPhysicalDocIdForBeta2 " +
                             ee.getMessage());
      }//catch
      finally
      {
        DBConnectionPool.returnDBConnection(conn, serialNumber);
      }
    }//finally
    logMetacat.info("target docid is: "+ docId + " "+
                             "for target doctype: "+targetType);
    return docId;
  }




  /* Parser the beta physical document and find the value in format element*/
  private void parsePhysicalDocumentForBeta(String physicalDocid)
  {
    String xmlDoc = null;
    try
    {
      String accNumber = physicalDocid + PropertyService.getProperty("document.accNumSeparator") +
        DBUtil.getLatestRevisionInDocumentTable(physicalDocid);
      //System.out.println("the accenumber is !!!!!!!!!!!!!!!!!!" + accNumber);
      DocumentImpl doc = new DocumentImpl(accNumber);
      xmlDoc = doc.toString();
      //System.out.println("The physical xml is "+xmlDoc);
    }
    catch (Exception e)
    {
      contentType = DEFAULTCONTENTTYPE;
      logMetacat.error("Error in ContentTypeProvider." +
                         "parsePhysicalDocumentForBeta()" + e.getMessage());
      return;
    }
      // get format element's text value
    String format = getTextValueFromPath(new StringReader(xmlDoc), FORMATPATH);

    if (format == null)
    {
      // if couldn't find the format, set contentype default value;
      contentType = DEFAULTCONTENTTYPE;
    }
    else
    {
      // if can find a format and look up from hash to get value
      contentType = lookUpContentType(format);
      // couldn't find the content type for this format in hash table
      if (contentType == null)
      {
        //set default vlaue
        contentType = DEFAULTCONTENTTYPE;
      }//if
    }//else
  }//parsePhysicalDocumentForBeta

  private String getTextValueFromPath(StringReader xml, String xPath)
  {
    String textValue = null;
    // get nodelist from doc by path
    try
    {
      NodeList list = EMLParser.getPathContent(xml, xPath);
      Node elementNode = list.item(0);
      Node textNode = elementNode.getFirstChild();
      if (textNode.getNodeType() == Node.TEXT_NODE)
      {
        textValue = textNode.getNodeValue();// get value
      }

    }
    catch (Exception e)
    {
      logMetacat.error("error in ContentTypeProvider."+
                               "getTextValueFromPath: "+e.getMessage());
    }
    logMetacat.info("The text value for " + xPath + " is: "+
                              textValue);
    return textValue;
  }//getTextValueFromPath

  /* A method to look up contentype */
  private String lookUpContentType(String format)
  {
    String newFormat = null;
    constructContentHashTable();
    newFormat = format.toLowerCase().trim();
    String type = null;
    type = (String)contentTypeHash.get(newFormat);
    logMetacat.info("contentType looked from hashtalbe is: " +
                              type);
    return type;
  }// lookupcontentypes

  /* Construct content type hashtable */
  private void constructContentHashTable()
  {
    contentTypeHash.put(TEXT, TEXTYPE);
    contentTypeHash.put(XML, XMLTYPE);
    contentTypeHash.put(HTML,HTMLTYPE);
    contentTypeHash.put(GIF, GIFTYPE);
    contentTypeHash.put(JPEG, JPEGTYPE);
    contentTypeHash.put(BMP, BMPTYPE);
    contentTypeHash.put(TAR, TARTYPE);
    contentTypeHash.put(ZIP, ZIPTYPE);
    contentTypeHash.put(BINARY, BINARYTYPE);

  }//constructrContentHashTable();



  public static void main(String[] argus)
  {
     try
     {
       DBConnectionPool pool = DBConnectionPool.getInstance();
       //ContentTypeProvider provider = new ContentTypeProvider("tao.9830");
       ContentTypeProvider provider = new ContentTypeProvider("tao.0001");
       String str = provider.getContentType();
       logMetacat.info("content type is : " + str);
     }
     catch(Exception e)
     {
       logMetacat.error("erorr in Schemalocation.main: " +
                                e.getMessage());
     }
  }
}//ContentTypeProvider
