/*

  * $Id$

  *

  * The contents of this file are subject to the Mozilla Public License 

  * Version 1.1 (the "License"); you may not use this file except in 

  * compliance with the License. You may obtain a copy of the License at 

  * http://www.mozilla.org/MPL/ 

  *

  * Software distributed under the License is distributed on an "AS IS" basis, 

  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License 

  * for the specific language governing rights and limitations under the License.

  *

  * The Original Code is XML Hammer code. (org.xmlhammer.*)

  *

  * The Initial Developer of the Original Code is Edwin Dankert. Portions created 

  * by the Initial Developer are Copyright (C) 2005 - 2006 the Initial Developer. 

  * All Rights Reserved.

  *

  * Contributor(s): Edwin Dankert <edankert@gmail.com>

  */

 package org.xmlhammer.gui.xpath;

 import java.io.IOException;

 import java.net.URI;

 import java.util.ArrayList;

 import javax.xml.namespace.QName;

 import javax.xml.parsers.DocumentBuilder;

 import javax.xml.parsers.DocumentBuilderFactory;

 import javax.xml.parsers.ParserConfigurationException;

 import javax.xml.xpath.XPathConstants;

 import javax.xml.xpath.XPathExpression;

 import javax.xml.xpath.XPathExpressionException;

 import javax.xml.xpath.XPathFactoryConfigurationException;

 import org.apache.log4j.Logger;

 import org.bounce.util.URIUtils;

 import org.w3c.dom.Attr;

 import org.w3c.dom.Comment;

 import org.w3c.dom.Document;

 import org.w3c.dom.Element;

 import org.w3c.dom.Node;

 import org.w3c.dom.NodeList;

 import org.w3c.dom.ProcessingInstruction;

 import org.w3c.dom.Text;

 import org.xml.sax.InputSource;

 import org.xml.sax.SAXException;

 import org.xml.sax.SAXParseException;

 import org.xmlhammer.DefaultErrorHandler;

 import org.xmlhammer.Module;

 import org.xmlhammer.ResultModel;

 import org.xmlhammer.DefaultErrorHandler.Error;

 import org.xmlhammer.DefaultErrorHandler.Fatal;

 import org.xmlhammer.DefaultErrorHandler.Problem;

 import org.xmlhammer.DefaultErrorHandler.Warning;

 import org.xmlhammer.gui.status.StatusModel;

 import org.xmlhammer.model.preferences.Preferences;

 import org.xmlhammer.model.project.Project;

 /**

  * Put comment...

  * 

  * @version $Revision$, $Date$

  * @author Edwin Dankert <edankert@gmail.com>

  */

 public class XPathSearchModule extends Module {

         private XPathExpression expression = null;

     private DocumentBuilder builder = null;

         public XPathSearchModule(Preferences preferences, Project project, Logger logger, boolean logSettings) throws XPathExpressionException, ParserConfigurationException, SAXException {

         super(preferences, project, logger, logSettings);

         // Compile the expression

         try {

             logSettings("\t[xpath-expression] "+project.getXPath().getExpression());

             this.expression = getXPath().compile(project.getXPath().getExpression());

         } catch (XPathExpressionException e) {

             Throwable cause = e;

             while (cause.getCause() != null) {

                 cause = cause.getCause();

             }

             logError(cause);

             throw e;

         }

         DocumentBuilderFactory factory = getDocumentBuilderFactory();

         builder = factory.newDocumentBuilder();

     }

     /**

      * Sets-up an XPath Factory, creates an XPath and compiles the XPath Expression.

      * 

      * @param preferences the global preferences.

      * @param project the project specific properties;

      * @throws XPathFactoryConfigurationException

      * @throws XPathExpressionException

      * @throws SAXException 

      * @throws ParserConfigurationException 

      */

     public XPathSearchModule(Preferences preferences, Project project, Logger logger) throws XPathExpressionException, ParserConfigurationException, SAXException {

         this(preferences, project, logger, true);

         }

     /**

      * Execute the XPath expression.

      * @throws XPathExpressionException 

      * @throws IOException 

      * @throws SAXException 

      */

     @Override

         public void execute(StatusModel status, ResultModel result, URI uri) throws XPathExpressionException {

                 if ( uri != null) {

                         // Tell that we're loading classes and parsing, so the time it

                         // takes to do this doesn't get confused with the time to do

                         // the actual query and serialization.

                         getLogger().info( "xpath-search: "+URIUtils.toString(uri));

             InputSource in = new InputSource( uri.toString());

             DefaultErrorHandler errorHandler = new DefaultErrorHandler(null);

             builder.setErrorHandler(errorHandler);

             builder.setEntityResolver(getCatalogResolver());

             Document document = null;

             try {

                 document = builder.parse( in);

             } catch ( SAXException e) {

                 if ( e instanceof SAXParseException) {

                     try {

                         errorHandler.fatalError( (SAXParseException)e);

                     } catch ( Exception x) {}

                 }

             } catch ( IOException e) {

                 errorHandler.fatalError(e);

             }

             if ( errorHandler.getProblems().size() > 0) {

                 ArrayList<Problem> list = errorHandler.getProblems();

                 for ( Problem problem : list) {

                     if ( problem instanceof Warning) {

                         logWarning(uri, (SAXParseException)problem.getException());

                         if (result != null) {

                             result.addWarning( uri, (SAXParseException)problem.getException());

                         }

                     } else if ( problem instanceof Error) {

                         logError(uri, (SAXParseException)problem.getException());

                         if (result != null) {

                             result.addError( uri, (SAXParseException)problem.getException());

                         }

                     } else if ( problem instanceof Fatal) {

                         logFatal(uri, problem.getException());

                         if (result != null) {

                             Exception exception = problem.getException();

                             if ( exception instanceof IOException) {

                                 result.addFatal( uri, (IOException)problem.getException());

                             } else {

                                 result.addFatal( uri, (SAXParseException)problem.getException());

                             }

                         }

                     }

                 }

             } else {

                 QName returnType = null;

                 String type = getProject().getXPath().getReturnType();

                 if ( "BOOLEAN".equals( type)) {

                     returnType = XPathConstants.BOOLEAN;

                 } else if ( "NODE".equals( type)) {

                     returnType = XPathConstants.NODE;

                 } else if ( "NUMBER".equals( type)) {

                     returnType = XPathConstants.NUMBER;

                 } else if ( "STRING".equals( type)) {

                     returnType = XPathConstants.STRING;

                 } else {

                     returnType = XPathConstants.NODESET;

                 }

                                 // Now evaluate the expression on the document to get String result

                                 Object node = expression.evaluate( document, returnType);

                                 ArrayList<Object> list = null;

                                 if (node instanceof NodeList && returnType == XPathConstants.NODESET) {

                                         list = new ArrayList<Object>( ((NodeList)node).getLength());

                     for (int i = 0; i < ((NodeList)node).getLength(); i++) {

                                                 list.add( ((NodeList)node).item( i));

                                         }

                                 } else if (node instanceof ArrayList) {

                                         list = new ArrayList<Object>();

                     for ( Object n : (ArrayList)node) {

                         list.add( n);

                     }

                 } else if (node instanceof String || node instanceof Number || node instanceof Boolean || node instanceof Node) {

                     list = new ArrayList<Object>();

                     list.add( node);

                                 } else if (node != null) {

                     getLogger().error("Unknown result type:\n"+node.getClass());

                 }

                 if (list != null) {

                                     for ( int i = 0; i < list.size(); i++) {

                                             Object object = list.get( i);

                         if (result != null && object != null) {

                             result.addValue( uri, object);

                         }

                                             // TODO: Make sure the Namespace and Document nodes are handled!!!

                                             if ( object instanceof Element) {

                             getLogger().info( "\t[element] "+((Element)object).getTagName());

                                             } else if ( object instanceof Attr) {

                             getLogger().info( "\t[attribute] "+((Attr)object).getName()+"=\""+((Attr)object).getNodeValue()+"\"");

                                             } else if ( object instanceof Text) {

                             getLogger().info( "\t[text] "+((Text)object).getNodeValue());

                                             } else if ( object instanceof Comment) {

                             getLogger().info( "\t[comment] "+((Node)object).getNodeValue());

                                             } else if ( object instanceof ProcessingInstruction) {

                             getLogger().info( "\t[processing-instruction] "+((Node)object).getNodeValue());

                                             } else if ( object instanceof Boolean) {

                             getLogger().info( "\t[boolean] "+object.toString());

                                             } else if ( object instanceof String) {

                             getLogger().info( "\t[string] "+(String)object);

                                             } else if ( object instanceof Number) {

                             getLogger().info( "\t[number] "+((Number)object).toString());

                                             } else if (object != null) {

                             getLogger().error( "Unknown node:\n"+object.getClass());

                                             }

                                     }

                 }

             }

                 }

         }

 }