/*

  * Created on 28.09.2005

  * 

  */

 package isac.util;

 import isac.browserdialog.BrowserDialog;

 import isac.browserdialog.IBrowserDialog;

 import isac.interfaces.IToGUI;

 import isac.session.IObjectManager;

 import isac.session.ObjectManager;

 import isac.users.UserSettings;

 import isac.wsdialog.IWorksheetDialog;

 import java.io.IOException;

 import java.io.StringReader;

 import java.io.StringWriter;

 import java.net.MalformedURLException;

 import java.rmi.Naming;

 import java.rmi.NotBoundException;

 import java.rmi.RemoteException;

 import java.util.Vector;

 import javax.xml.parsers.DocumentBuilder;

 import javax.xml.parsers.DocumentBuilderFactory;

 import javax.xml.parsers.ParserConfigurationException;

 import javax.xml.transform.Source;

 import javax.xml.transform.Transformer;

 import javax.xml.transform.TransformerConfigurationException;

 import javax.xml.transform.TransformerException;

 import javax.xml.transform.TransformerFactory;

 import javax.xml.transform.dom.DOMResult;

 import javax.xml.transform.dom.DOMSource;

 import javax.xml.transform.stream.StreamResult;

 import org.apache.log4j.Logger;

 import org.apache.xmlrpc.XmlRpcClient;

 import org.apache.xmlrpc.XmlRpcException;

 import org.w3c.dom.Document;

 import org.w3c.dom.Node;

 import org.w3c.dom.NodeList;

 import org.xml.sax.InputSource;

 import org.xml.sax.SAXException;

 /**

  * @author Martin Lang

  *

  * Handles the communication with the KEStore

  *

  */

 public class KEStoreCommunication {

     private static final Logger logger = Logger.getLogger(KEStoreCommunication.class.getName());

     protected static String id_;

     protected UserSettings user_settings_;

     protected IToGUI browser_frame_rmi_;

     private static XmlRpcClient client_ = null;

     public static IBrowserDialog getBDialog(String session) {

     	String name = KEStorePaths.OBJECT_MANAGER_PATH;

     	if(logger.isInfoEnabled())

     	    logger.info("WA<>SM: getBDialog(session=" + session + ")");

         try {

             System.out.println("connect to ObjectManager" + name);

             Object lookup = Naming.lookup(name);

             return ((IObjectManager) lookup).getBrowserDialog(session);

         } catch (RemoteException exc) {

             System.err.println("no rmiregistry runing on server " + name

                     + " no connection possible --- try later");

             System.err.println("serverCom exception: " + exc.getMessage());

         } catch (NotBoundException exc) {

             System.err.println("servercom: notboundexc: " + exc.getMessage());

             System.err.println("server not found - try to connect to Proxy");

         } catch (java.net.MalformedURLException exc) {

             System.err.println("servercom: MalformedURLException: "

                     + exc.getMessage());

             exc.printStackTrace();

         }

         return null;

     }

     /**

      * Loads the hierarchy_ of the type <code>type</code> from the KE-Store.

      * Accessible via RMI

      * 

      * @param type

      *                     requestet information-type to load the hierarchy_ for. e.g.

      *                     pbl, met, or exp

      * @return the hierarchy_ in its XML-representation. The result might be

      *                  filtered according to the current session the XBrowserDialog was

      *                  instantiated for

      */

     public static String loadHierarchy(String type) throws RemoteException {

          String hierarchy = loadHierarchy(id_, type);

         Vector keresult = null;

         keresult.add(hierarchy);

         if (keresult.size() == 0)

             return null;

         if(logger.isInfoEnabled())

             logger.info("    <-BD: loadHierarch");

         return (String) keresult.elementAt(0);

     }

     /**

      * Loads the hierarchy_ of the type <code>type</code> from the KE-Store.

      * XML-RPC version

      * 

      * @param session

      *                     ID of the session to load the KEObject for.

      * @param type

      *                     requestet information-type to load the hierarchy_ for. e.g.

      *                     pbl, met, or exp

      * @return the hierarchy_ in its XML-representation. The result might be

      *                  filtered according to the current session the XBrowserDialog was

      *                  instantiated for

      */

     public static String loadHierarchy(String session, String type) {

         Vector param = new Vector();

         param.add(type);

         Vector hierarchy = callKEStore("KEStore.loadHierarchy", param);

         return (String) hierarchy.elementAt(0);

     }

     /**

      * Loads the requested KE-Object of the type <code>type</code> from the

      * KE-Store <code>type</code> and <code>content_id</code> together give

      * the unique id. One and the same <code>content_id</code> might be used

      * in different types (<code>type</code> can be pbl, or met for the basic

      * items of the knowledge-base as well as an identifyer used for different

      * courses). If objects with equal <code>content_id</code> s reside in

      * different types, their only difference should reside within the

      * description.

      * 

      * @param type

      *                     requestet information-type to load the content for. e.g. pbl,

      *                     met, or exp

      * @param content_id

      *                     identifies the KE-Object within the <code>type</code>

      * @return requested KE-Object in its XML-representation. The result might

      *                  be filtered according to the current session the XBrowserDialog

      *                  was instantiated for

      */

     public static String loadContent(String type, String filename)

             throws RemoteException {

         String keresult = loadContent(id_, type, filename);

         return keresult;

     }

     public static String loadContent(String type, Vector idvect) {

         Vector keresult = loadContent(id_, type, idvect);

         return (String) keresult.elementAt(0);

     }

     protected static Vector loadContent(String session, String type, Vector idvect) {

         Vector parameter = new Vector();

         parameter.add(type);

         parameter.add(idvect);

         Vector result = callKEStore("KEStore.loadContent", parameter);

         if (result.size() == 0) {

             result.add(getErrorXML("Sorry, proper Content could not be found"));

             return result;

         }

         if (result.get(0) == "ERROR") {

             result.removeAllElements();

             result.add(getErrorXML("ERROR Sorry, Syntax Error"));

             return result;

         }

         return filterContent(session, result);

     }

     public static String loadContent(String session, String type, String filename) {

         Vector parameter = new Vector();

         parameter.add(type);

         parameter.add(filename);

         Vector result = callKEStore("KEStore.loadContent", parameter);

         //collecting the data for the error_log

         if ((result.firstElement()).toString().equals("ERROR")) {

             String file_name = result.get(1).toString();

             String problem_name = result.get(2).toString();

             result.removeAllElements();

             String error_information = "ERROR" + "FILE: " + file_name

                     + " =>  PROBLEM: " + problem_name;

             result.add(error_information);

             return result.elementAt(0).toString();

         }

          String stringresult = (String) result.elementAt(0);

          stringresult = decodeUmlauts(stringresult);

          result.set(0,stringresult);

           Vector content = filterContent(session, result);

           return content.elementAt(0).toString();

     }

     /**

      * Loads the requested KE-Object of the type <code>type</code> from the

      * KE-Store. <code>type</code> and <code>content_id</code> together give

      * the unique id. One and the same <code>content_id</code> might be used

      * in different types (<code>type</code> can be pbl, or met for the basic

      * items of the knowledge-base as well as an identifyer used for different

      * courses). If objects with equal <code>content_id</code> s reside in

      * different types, their only difference should reside within the

      * description. XML-RPC version.

      * 

      * @param session

      *                     session to fetch the KE-Object for.

      * @param type

      *                     requestet information-type to load the content for. e.g. pbl,

      *                     met, or exp

      * @param content_id

      *                     identifies the KE-Object within the <code>type</code>

      * @return requested KE-Object in its XML-representation. The result might

      *                  be filtered according to the session given py parameter

      *                  <code>session</code>

      */

     private static Vector filterContent(String session, Vector result) {

         //if session == "", no filtering is needed (author mode)

         if (session.equals("")) //no filtering necessary

             return result;

         try {

             TransformerFactory tFactory = TransformerFactory.newInstance();

             Transformer transformer = tFactory.newTransformer();

             String content = (String) result.firstElement();

             DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

             DocumentBuilder db = dbf.newDocumentBuilder();

             StringReader sr = new StringReader(content);

             Document document = db.parse(new InputSource(sr));

             DOMSource source = new DOMSource(document);

             DOMResult dom_result = new DOMResult();

             transformer.transform(source, dom_result);

             Source filtered_source = filter(dom_result.getNode());

             StringWriter output = new StringWriter();

             StreamResult filterresult = new StreamResult(output);

             transformer.transform(filtered_source, filterresult);

             String resultxml = output.toString();

             System.out.print(resultxml);

             result = new Vector();

             result.add(resultxml);

         } catch (TransformerConfigurationException e) {

             result.removeAllElements();

             result.add(getErrorXML("TransformerConfigurationEception: "

                     + e.getMessage()));

             e.printStackTrace();

         } catch (ParserConfigurationException e) {

             result.removeAllElements();

             result.add(getErrorXML("ParserConfigurationEception: "

                     + e.getMessage()));

             e.printStackTrace();

         } catch (SAXException e) {

             result.removeAllElements();

             result.add(getErrorXML("SAXException: " + e.getMessage()));

             e.printStackTrace();

         } catch (IOException e) {

             result.removeAllElements();

             result.add(getErrorXML("IOEception: " + e.getMessage()));

             e.printStackTrace();

         } catch (TransformerException e) {

             result.removeAllElements();

             result.add(getErrorXML("TransformerEception: " + e.getMessage()));

             e.printStackTrace();

         }

         return result;       

     }

     /*

      * @param string @return

      */

     private static String getErrorXML(String string) {

         return "<ERROR><DESCRIPTION> <h1> Error in file XBrowserDialog.java </h1>"

                 + string + "</DESCRIPTION></ERROR>";

     }

     /*

      * @param node

      */

     private static Source filter(Node node) {

         recFilter(node, "EVAL_PRECOND");

         recFilter(node, "CAS");

         recFilter(node, "RELATE");

         return new DOMSource(node);

     }

     private static void recFilter(Node node, String removename) {

         NodeList nlist = node.getChildNodes();

         System.out.println(nlist);

         for (int indx = 0; indx < nlist.getLength(); indx++) {

             Node childnode = nlist.item(indx);

             System.out.println("removename:" + removename);

             if (childnode == null) {

                 System.out.println("child is null !!!");

                 return;

             }

             System.out.println("localname:" + childnode.getLocalName());

             if (childnode.getLocalName() == null)

                 System.out.println("localname is null !");

             else if (childnode.getLocalName().equals(removename)) {

                 System.out.println("i should have been deleted");

                 node.removeChild(childnode);

             } else

                 recFilter(childnode, removename);

         }

     }

     /**

      * Encapsulates the communication with KEStore. On each call, a new

      * XMLRPC-connection to the KESTore is established

      * 

      * @param function:

      *                     the function from the KEStore to call

      * @param parameters:

      *                     parameters nedded by the called function

      */

     private static Vector callKEStore(String function, Vector parameters) {

         Vector errvector = new Vector();

         try {

             if (client_ == null)

                 //fixed path, port: new XmlRpcClient("http://localhost:1030");

                 client_ = new XmlRpcClient("http://localhost:1030");

             return (Vector) client_.execute(function, parameters);

         } catch (MalformedURLException exc) {

             errvector.add("XBrowserDialog:MalformedURLException");

             exc.printStackTrace();

         } catch (XmlRpcException exc) {

             errvector.add("XBrowserDialog:XmlRpcException");

             exc.printStackTrace();

         } catch (IOException exc) {

             errvector.add("XBrowserDialog:IOException");

             exc.printStackTrace();

         }

         return errvector;

     }

     /**

      * decodes the german 'Umlaute'

      * \u00D6 is the unicode character for the german Umlaut 'Oe'

      * \u00F6 is the unicode character for the german Umlaut 'oe'

      * \u00DC is the unicode character for the german Umlaut 'Ue'

      * \u00FC is the unicode character for the german Umlaut 'ue'

      * \u00C4 is the unicode character for the german Umlaut 'Ae'

      * \u00E4 is the unicode character for the german Umlaut 'ae'

      * \u00DF is the unicode character for the german 'sz'

      * 

      * @param the input string

      *                    

      * @return the output string

      */

     public static String decodeUmlauts(String input) {

     	input = input.replaceAll("Ö", "\u00D6");

     	input = input.replaceAll("ö", "\u00F6");

     	input = input.replaceAll("Ü", "\u00DC");

     	input = input.replaceAll("ü", "\u00FC");

     	input = input.replaceAll("Ä", "\u00C4");

     	input = input.replaceAll("ä", "\u00E4");

         input = input.replaceAll("ß","\u00DF");

     	return input;

     }

 }