/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/




import com.sun.star.comp.loader.FactoryHelper;
import com.sun.star.lang.XMultiServiceFactory;
import com.sun.star.lang.XServiceInfo;
import com.sun.star.lang.XServiceName;
import com.sun.star.lang.XSingleServiceFactory;
import com.sun.star.lang.XTypeProvider;
import com.sun.star.registry.XRegistryKey;
import com.sun.star.uno.Type;
import java.util.Enumeration;
import java.util.Vector;
import com.sun.star.xml.XImportFilter;
import com.sun.star.xml.XExportFilter;

// Imported TraX classes
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

import com.sun.star.uno.AnyConverter;

//Uno to java Adaptor
import com.sun.star.lib.uno.adapter.*;

/** This outer class provides an inner class to implement the service
 * description and a method to instantiate the
 * component on demand (__getServiceFactory()).
 */
public class XSLTValidate {

    private static XMultiServiceFactory xMSF;
    private static Vector parseErrors =new Vector();

    /** This inner class provides the component as a concrete implementation
     * of the service description. It implements the needed interfaces.
     * @implements XTypeProvider
     */
    static public class _XSLTValidate implements
		XImportFilter,
        XServiceName,
        XServiceInfo,
		ErrorHandler,
        XTypeProvider {

		private com.sun.star.xml.sax.XErrorHandler xErrorHandler;
        
        /** The component will be registered under this name.
         */
        static private final String __serviceName = "com.sun.star.documentconversion.XSLTValidate";
        
		public _XSLTValidate() {
			xErrorHandler = null;
		}

        public com.sun.star.uno.Type[] getTypes() {
            Type[] typeReturn = {};

            try {
                typeReturn = new Type[] {
                new Type( XTypeProvider.class ),
                new Type( XExportFilter.class ),
				new Type( XImportFilter.class ),
                new Type( XServiceName.class ),
                new Type( XServiceInfo.class ) };
            }
            catch( Exception exception ) {
		
            }

            return( typeReturn );
        }


	public boolean importer(com.sun.star.beans.PropertyValue[] aSourceData, 
				com.sun.star.xml.sax.XDocumentHandler xDocHandler, 
				java.lang.String[] msUserData) throws com.sun.star.uno.RuntimeException,com.sun.star.lang.IllegalArgumentException { 
	
	    com.sun.star.io.XInputStream xis=null;
	    com.sun.star.beans.PropertyValue[] pValue = aSourceData;
		for  (int  i = 0 ; i < pValue.length; i++)
		{
			try{
				//System.out.println("\n"+pValue[i].Name+" "+pValue[i].Value);
				if (pValue[i].Name.compareTo("InputStream")==0){
					xis=(com.sun.star.io.XInputStream)AnyConverter.toObject(new Type(com.sun.star.io.XInputStream.class), pValue[i].Value);
				}
				else if (pValue[i].Name.compareTo("ErrorHandler")==0){
					xErrorHandler=(com.sun.star.xml.sax.XErrorHandler)AnyConverter.toObject(new Type(com.sun.star.xml.sax.XErrorHandler.class), pValue[i].Value);
				}
			}
			catch(com.sun.star.lang.IllegalArgumentException AnyExec){
				System.out.println("\nIllegalArgumentException "+AnyExec);
			}
		}
		try{
			convert (xis);
		}
		catch (Exception AnyExec){
			throw new com.sun.star.uno.RuntimeException(AnyExec.getMessage());
		}
		return true;
	}

	 public void convert (com.sun.star.io.XInputStream xml) throws com.sun.star.uno.RuntimeException {
	     XInputStreamToInputStreamAdapter xis =new XInputStreamToInputStreamAdapter(xml);	 
	     parseErrors =new Vector();
           //String defaultTimeOut = System.getProperty("sun.net.client.defaultConnectTimeout");
           System.getProperties().setProperty("sun.net.client.defaultConnectTimeout", "10000");
	     try{
			 DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
			 dFactory.setNamespaceAware(true);
			 dFactory.setValidating(true);
			 DocumentBuilder dBuilder = dFactory.newDocumentBuilder();
			 dBuilder.setErrorHandler(this);
			 dBuilder.parse(xis);
			 if (parseErrors.size()>0){
				 String errString ="";
				 for (Enumeration e = parseErrors.elements() ; e.hasMoreElements() ;) {
					errString+=e.nextElement();
					//System.out.println(e.nextElement());
				 }
				 throw new com.sun.star.uno.RuntimeException(errString);
			 }
	     }
	    catch (Exception e){
		   //System.out.println("\nException "+ e);
		   throw new com.sun.star.uno.RuntimeException(e.getLocalizedMessage());
	    } 
	 }

	public com.sun.star.uno.Any JavaSAXParseEceptionToUno( SAXParseException e )
	{
		com.sun.star.uno.XInterface xContext = null;

		String aMessage = e.getMessage();
		if( aMessage == null )
			aMessage = new String();

		String aPublicId = e.getPublicId();
		if( aPublicId == null )
			aPublicId = new String();

		String aSystemId = e.getSystemId();
		if( aSystemId == null )
			aSystemId = new String();

		return new com.sun.star.uno.Any( new Type(com.sun.star.xml.sax.SAXParseException.class),
					new com.sun.star.xml.sax.SAXParseException( aMessage,
					xContext,
					com.sun.star.uno.Any.VOID,
					aPublicId,
					aSystemId,
					e.getLineNumber(),
					e.getColumnNumber() ) );

	}

	//  Warning Event Handler
	public void warning (SAXParseException e)
			throws SAXException 
	{
//		System.out.println("\n_XSLTValidate::warning " + e.toString() );

		if( xErrorHandler != null )
		{
			try
			{
				xErrorHandler.warning( JavaSAXParseEceptionToUno( e ) );
			}
			catch( com.sun.star.xml.sax.SAXException ex )
			{
				throw e;
			}
		}
		else
		{

			//System.err.println ("Warning:  "+e);
			try{
				//parseErrors.write (("\n"+e.getMessage()).getBytes());
			}
			catch(Exception genEx){
				//System.out.print("\n Error while writing ParseErrors"+genEx);
			}
		}
	}
	
	//  Error Event Handler
	public void error (SAXParseException e)
		throws SAXException 
	{
//		System.out.println("\n_XSLTValidate::error " + e.toString() );

		if( xErrorHandler != null )
		{
			try
			{
				xErrorHandler.error( JavaSAXParseEceptionToUno( e ) );
			}
			catch( com.sun.star.xml.sax.SAXException ex )
			{
				throw e;
			}
		}
		else
		{
			//System.err.println ("Error:  "+e);
			try{
				parseErrors.add (e.getLocalizedMessage()+" "+e.getLineNumber()+" ");
			}
			catch(Exception genEx){
				//System.out.print("\n Error while writing ParseErrors"+genEx);
			}
		}
	}

	//  Fatal Error Event Handler
	public void fatalError (SAXParseException e)
	throws SAXException {
//		System.out.println("\n_XSLTValidate::fatalError " + e.toString() );

		if( xErrorHandler != null )
		{
			try
			{
				xErrorHandler.fatalError(  JavaSAXParseEceptionToUno( e ) );
			}
			catch( com.sun.star.xml.sax.SAXException ex )
			{
				throw e;
			}
		}
		else
		{
			//System.err.println ("Fatal Error:  "+e);
			try{
				parseErrors.add (e.getLocalizedMessage()+" "+e.getLineNumber()+" ");
			}
			catch(Exception genEx){
				//System.out.print("\n Error while writing ParseErrors"+genEx);
			}
		}
	}
	
        // Implement methods from interface XTypeProvider
        public byte[] getImplementationId() {
            byte[] byteReturn = {};

            byteReturn = new String( "" + this.hashCode() ).getBytes();

            return( byteReturn );
        }

        // Implement method from interface XServiceName
        public String getServiceName() {
            return( __serviceName );
        }
    
        // Implement methods from interface XServiceInfo
        public boolean supportsService(String stringServiceName) {
            return( stringServiceName.equals( __serviceName ) );
        }
    
        public String getImplementationName() {
            return( _XSLTValidate.class.getName() );
        }
    
        public String[] getSupportedServiceNames() {
            String[] stringSupportedServiceNames = { __serviceName };
            return( stringSupportedServiceNames );
        }
    }

    /**
     * Returns a factory for creating the service.
     * This method is called by the <code>JavaLoader</code>
     *
     * @return  returns a <code>XSingleServiceFactory</code> for creating the
     *          component
     *
     * @param   implName     the name of the implementation for which a
     *                       service is desired
     * @param   multiFactory the service manager to be used if needed
     * @param   regKey       the registryKey
     *
     * @see                  com.sun.star.comp.loader.JavaLoader
     */
    public static XSingleServiceFactory __getServiceFactory(String implName,
    XMultiServiceFactory multiFactory,
    XRegistryKey regKey) {
        XSingleServiceFactory xSingleServiceFactory = null;
        xMSF= multiFactory;
        if (implName.equals(_XSLTValidate.class.getName()) ) {
            xSingleServiceFactory = FactoryHelper.getServiceFactory(_XSLTValidate.class,
            _XSLTValidate.__serviceName,
            multiFactory,
            regKey);
        }
        
        return xSingleServiceFactory;
    }
}