package org.xvsm.lookup;
   
   import java.io.File;
   import java.io.IOException;
   import java.lang.reflect.Constructor;
   import java.lang.reflect.InvocationTargetException;
   import java.net.MalformedURLException;
   import java.net.URI;
   import java.net.URISyntaxException;
  import java.net.URL;
  import java.net.URLClassLoader;
  import java.util.ArrayList;
  import java.util.Hashtable;
  import java.util.Iterator;
  import java.util.List;
  
  import org.jdom.Document;
  import org.jdom.Element;
  import org.jdom.JDOMException;
  import org.jdom.input.SAXBuilder;
  import org.xvsm.coordinators.LindaCoordinator;
  import org.xvsm.core.AtomicEntry;
  import org.xvsm.core.Capi;
  import org.xvsm.core.ContainerRef;
  import org.xvsm.core.Entry;
  import org.xvsm.core.Tuple;
  import org.xvsm.interfaces.container.IContainer;
  import org.xvsm.interfaces.lookup.ILookup;
  import org.xvsm.interfaces.lookup.ILookupManager;
  import org.xvsm.internal.exceptions.CountNotMetException;
  import org.xvsm.internal.exceptions.XCoreException;
  import org.xvsm.lookup.exceptions.ContainerAlreadyPublishedException;
  import org.xvsm.lookup.exceptions.ContainerNotPublishedException;
  import org.xvsm.lookup.exceptions.LookupException;
  import org.xvsm.selectors.KeySelector;
  
  /***
   * manages the various implementations of the lookup-services. The configuration
   * is done via xml config files or environment variables. (see constructors)
   * 
   * @author Hannu-Daniel Goiss
   */
  public class LookupManager implements ILookupManager {
  	private LookupTuple[] lookups = null;
  	private URI site = null;
  	private Capi capi;
  	private boolean abbrechen = true;
  
  	/***
  	 * xml-config file constructor, that uses the default file "config.xml"
  	 * 
  	 * @param site
  	 * @throws LookupException
  	 */
  	public LookupManager(URI site) throws LookupException {
  		this(site, new File("config.xml"));
  	}
  
  	/***
  	 * constructor using a variable to configure the LookupManager. the
  	 * functionality is the same as when using the xml config file constructor
  	 * 
  	 * @param site
  	 * @param table
  	 * @throws LookupException
  	 */
  	public LookupManager(URI site, Hashtable<String, String> table)
  			throws LookupException {
  		ArrayList<LookupTuple> templookups = new ArrayList<LookupTuple>();
  		Class cls = null;
  		ILookup lookup;
  
  		try {
  			capi = new Capi();
  			this.site = site;
  
  			try {
  				for (int i = 1;; i++) {
  					String lookupimplementation = table.get("Lookup" + i);
  					if (lookupimplementation == null) {
  						throw new IndexOutOfBoundsException();
  					}
  
  					String jarFile = table.get(lookupimplementation
  							+ ".JarFile");
  
  					String abbrechenString = table.get("AskAllUnits");
  					if (abbrechenString == null
  							|| abbrechenString.compareTo("true") != 0) {
  						abbrechen = false;
  					} else {
  						abbrechen = true;
  					}
  
  					if (jarFile != null) {
  						URL[] urls = { new URL(jarFile) };
  						ClassLoader urlc = new URLClassLoader(urls, getClass()
  								.getClassLoader());
  						cls = Class.forName(lookupimplementation, true, urlc);
 					} else {
 						cls = Class.forName(lookupimplementation);
 					}
 
 					Constructor c = cls.getConstructor(new Class[] { URI.class,
 							Hashtable.class });
 					lookup = (ILookup) c
 							.newInstance(new Object[] { site, table });
 
 					templookups.add(new LookupTuple(i, lookup));
 				}
 			} catch (IndexOutOfBoundsException ioobe) {
 			}
 			lookups = new LookupTuple[templookups.size()];
 			templookups.toArray(lookups);
 			java.util.Arrays.sort(lookups);
 			startLookupManager();
 		} catch (ClassNotFoundException cnfe) {
 			throw new LookupException(cnfe);
 		} catch (InstantiationException ie) {
 			throw new LookupException(ie);
 		} catch (IllegalAccessException iae) {
 			throw new LookupException(iae);
 		} catch (NoSuchMethodException nsme) {
 			throw new LookupException(nsme);
 		} catch (InvocationTargetException ite) {
 			throw new LookupException(ite);
 		} catch (MalformedURLException mue) {
 			throw new LookupException(mue);
 		} catch (XCoreException xce) {
 			throw new LookupException(xce);
 		}
 	}
 
 	/***
 	 * constructor using a xml config file to configure the LookupManager. the
 	 * functionality is the same as when using the the environment variable
 	 * constructor
 	 * 
 	 * @param site
 	 * @param file
 	 * @throws LookupException
 	 */
 	public LookupManager(URI site, File file) throws LookupException {
 		ArrayList<LookupTuple> templookups = new ArrayList<LookupTuple>();
 		Class cls = null;
 		ILookup lookup;
 
 		this.validateXML(file);
 
 		try {
 			capi = new Capi();
 			this.site = site;
 			SAXBuilder builder = new SAXBuilder();
 			Document doc = builder.build(file);
 
 			Element root = doc.getRootElement();
 
 			Element propertiesElement = root.getChild("Properties");
 
 			abbrechen = false;
 			try {
 				List properties = propertiesElement.getChildren("Property");
 				Iterator propertiesIterator = properties.iterator();
 
 				while (propertiesIterator.hasNext()) {
 					Element propertyElement = (Element) propertiesIterator
 							.next();
 
 					try {
 						if (propertyElement.getAttribute("Key").getValue()
 								.compareTo("AskAllUnits") == 0) {
 							String abbrechenString = propertyElement
 									.getTextTrim();
 							if (abbrechenString.compareTo("true") == 0) {
 								abbrechen = true;
 							}
 						}
 					} catch (NullPointerException npe) {
 					}
 				}
 			} catch (NullPointerException npe2) {
 			}
 
 			List lookupmanager = root.getChildren("Lookup");
 
 			Iterator i = lookupmanager.iterator();
 			while (i.hasNext()) {
 				int prioritaet;
 				String lookupimplementation = "";
 				boolean jarFileSpecified = true;
 				String jarFile = "";
 				Element lookupelement = (Element) i.next();
 				lookupimplementation = lookupelement.getChild("LookupName")
 						.getTextTrim();
 				prioritaet = lookupelement.getAttribute("Priority")
 						.getIntValue();
 
 				try {
 					jarFile = lookupelement.getChild("JarFile").getTextTrim();
 				} catch (NullPointerException e) {
 					jarFileSpecified = false;
 				}
 
 				if (jarFileSpecified == true) {
 					URL[] urls = { new URL(jarFile) };
 					ClassLoader urlc = new URLClassLoader(urls, getClass()
 							.getClassLoader());
 					cls = Class.forName(lookupimplementation, true, urlc);
 				} else {
 					cls = Class.forName(lookupimplementation);
 				}
 
 				Constructor c = cls.getConstructor(new Class[] { URI.class,
 						Element.class });
 
 				lookup = (ILookup) c.newInstance(new Object[] { site,
 						lookupelement.getChild("LookupUnitSpecific") });
 
 				templookups.add(new LookupTuple(prioritaet, lookup));
 			}
 			lookups = new LookupTuple[templookups.size()];
 			templookups.toArray(lookups);
 			java.util.Arrays.sort(lookups);
 			startLookupManager();
 		} catch (XCoreException xce) {
 			throw new LookupException(xce);
 		} catch (IOException ioe) {
 			throw new LookupException(ioe);
 		} catch (ClassNotFoundException cnfe) {
 			throw new LookupException(cnfe);
 		} catch (InstantiationException ie) {
 			throw new LookupException(ie);
 		} catch (IllegalAccessException iae) {
 			throw new LookupException(iae);
 		} catch (JDOMException je) {
 			throw new LookupException(je);
 		} catch (NoSuchMethodException nsme) {
 			throw new LookupException(nsme);
 		} catch (InvocationTargetException ite) {
 			throw new LookupException(ite);
 		}
 	}
 
 	private void startLookupManager() throws XCoreException {
 		/*
 		 * TODO: Kommentar entfernen, sobald Parameter in PreContainerDestroy
 		 * Aspect nicht mehr null ist. #
 		 * 
 		 * 
 		 * GlobalAspect aspect = new LookupAspect(this); 
 		 * List<IPoint> p = new ArrayList<IPoint>();
 		 * p.add(GlobalIPoint.PreContainerDestroy);
 		 * capi.addAspect(null, p, aspect);
 		 */
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.xvsm.interfaces.lookup.ILookupManager#lookup(java.lang.String)
 	 */
 	public ContainerRef[] lookup(String name)
 			throws ContainerNotPublishedException, LookupException {
 		ArrayList<ContainerRef> containerlist = new ArrayList<ContainerRef>();
 		ContainerRef[] containers = null;
 
 		/*
 		 * try { Capi capi = new Capi(); try { ContainerRef cref =
 		 * capi.lookupContainer(null, this.site, name); if
 		 * (this.getGepublished(cref) == true) { containerlist.add(cref); } }
 		 * catch (InvalidContainerException ice) { } } catch (XCoreException
 		 * xce) { throw new LookupException(xce); }
 		 */
 		for (int i = 0; (containerlist.size() == 0 || abbrechen == false)
 				&& i < lookups.length; i++) {
 			try {
 				containers = lookups[i].getLookup().lookup(name);
 
 				for (ContainerRef c : containers) {
 					if (containerlist.contains(c) == false)
 						containerlist.add(c);
 				}
 			} catch (Exception e) {
 				// e.printStackTrace();
 			}
 		}
 
 		if (containerlist.size() == 0) {
 			throw new ContainerNotPublishedException(name);
 		}
 		containers = new ContainerRef[containerlist.size()];
 		containerlist.toArray(containers);
 		return containers;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.xvsm.interfaces.lookup.ILookupManager#lookup(java.util.Hashtable)
 	 */
 	public ContainerRef[] lookup(Hashtable list)
 			throws ContainerNotPublishedException, LookupException {
 		ArrayList<ContainerRef> containerlist = new ArrayList<ContainerRef>();
 		ContainerRef[] containers = new ContainerRef[0];
 
 		for (int i = 0; (containerlist.size() == 0 || abbrechen == false)
 				&& i < lookups.length; i++) {
 			try {
 				containers = lookups[i].getLookup().lookup(list);
 
 				for (ContainerRef c : containers) {
 					if (containerlist.contains(c) == false)
 						containerlist.add(c);
 				}
 			} catch (Exception e) {
 				e.printStackTrace();
 			}
 		}
 
 		if (containerlist.size() == 0) {
 			throw new ContainerNotPublishedException("searched for description");
 		}
 		containers = new ContainerRef[containerlist.size()];
 		containerlist.toArray(containers);
 		return containers;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.xvsm.interfaces.lookup.ILookupManager#lookup(java.lang.String,
 	 *      java.util.Hashtable)
 	 */
 	public ContainerRef[] lookup(String name, Hashtable list)
 			throws ContainerNotPublishedException, LookupException {
 		ArrayList<ContainerRef> containerlist = new ArrayList<ContainerRef>();
 		ContainerRef[] containers = new ContainerRef[0];
 
 		for (int i = 0; (containerlist.size() == 0 || abbrechen == false)
 				&& i < lookups.length; i++) {
 			try {
 				containers = lookups[i].getLookup().lookup(name, list);
 
 				for (ContainerRef c : containers) {
 					if (containerlist.contains(c) == false)
 						containerlist.add(c);
 				}
 			} catch (Exception e) {
 			}
 		}
 
 		if (containerlist.size() == 0) {
 			throw new ContainerNotPublishedException(name
 					+ " AND searched for description");
 		}
 		containers = new ContainerRef[containerlist.size()];
 		containerlist.toArray(containers);
 		return containers;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.xvsm.interfaces.lookup.ILookupManager#publish(org.xvsm.core.ContainerRef)
 	 */
 	public void publish(ContainerRef cref)
 			throws ContainerAlreadyPublishedException, LookupException {
 		ContainerAlreadyPublishedException cape1 = null;
 		LookupException le1 = null;
 		ContainerRef crefPublish = cref;
 
 		for (int i = 0; i < lookups.length; i++) {
 			try {
 				lookups[i].getLookup().publish(crefPublish);
 			} catch (LookupException le) {
 				le1 = le;
 			} catch (ContainerAlreadyPublishedException cape) {
 				cape1 = cape;
 			}
 		}
 		if (cape1 != null) {
 			throw cape1;
 		}
 		if (le1 != null) {
 			throw le1;
 		}
 	}
 
 	public void publish(String name) throws ContainerAlreadyPublishedException,
 			LookupException {
 		ContainerAlreadyPublishedException cape1 = null;
 		LookupException le1 = null;
 
 		for (int i = 0; i < lookups.length; i++) {
 			try {
 				lookups[i].getLookup().publish(new ContainerRef());
 			} catch (LookupException le) {
 				le1 = le;
 			} catch (ContainerAlreadyPublishedException cape) {
 				cape1 = cape;
 			}
 		}
 		if (cape1 != null) {
 			throw cape1;
 		}
 		if (le1 != null) {
 			throw le1;
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.xvsm.interfaces.lookup.ILookupManager#unpublish(org.xvsm.core.ContainerRef)
 	 */
 	public void unpublish(ContainerRef cref)
 			throws ContainerNotPublishedException, LookupException {
 		ContainerNotPublishedException cnpe1 = null;
 		LookupException le1 = null;
 
 		try {
 			this.setGepublished(cref, false);
 		} catch (XCoreException xce) {
 			throw new LookupException(xce);
 		}
 
 		for (int i = 0; i < lookups.length; i++) {
 			try {
 				lookups[i].getLookup().unpublish(cref);
 			} catch (ContainerNotPublishedException cnpe) {
 				cnpe1 = cnpe;
 			} catch (LookupException le) {
 				le1 = le;
 			}
 		}
 		if (cnpe1 != null) {
 			throw cnpe1;
 		}
 		if (le1 != null) {
 			throw le1;
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.xvsm.interfaces.lookup.ILookupManager#updateDescription(org.xvsm.core.ContainerRef)
 	 */
 	public void updateDescription(ContainerRef cref)
 			throws ContainerNotPublishedException, LookupException {
 		ContainerNotPublishedException cnpe1 = null;
 		LookupException le1 = null;
 
 		for (int i = 0; i < lookups.length; i++) {
 			try {
 				lookups[i].getLookup().updateDescription(cref);
 			} catch (ContainerNotPublishedException cnpe) {
 				cnpe1 = cnpe;
 			} catch (LookupException le) {
 				le1 = le;
 			}
 		}
 		if (cnpe1 != null) {
 			throw cnpe1;
 		}
 		if (le1 != null) {
 			throw le1;
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.xvsm.interfaces.lookup.ILookupManager#publishedContainers()
 	 */
 	public ContainerRef[] publishedContainers() throws LookupException {
 		ArrayList<ContainerRef> containerlist = new ArrayList<ContainerRef>();
 		ContainerRef[] containers = null;
 		LookupException le1 = null;
 
 //		for (int i = 0; i < lookups.length; i++) {
 //			try {
 //				containers = lookups[i].getLookup().publishedContainers();
 //
 //				for (ContainerRef c : containers) {
 //					if (containerlist.contains(c) == false)
 //						containerlist.add(c);
 //				}
 //			} catch (LookupException le) {
 //				le1 = le;
 //			}
 //		}
 
 		if (containerlist.size() == 0 && le1 == null) {
 			return null;
 		} else if (le1 != null && containerlist.size() == 0) {
 			throw le1;
 		}
 
 		containers = new ContainerRef[containerlist.size()];
 		containerlist.toArray(containers);
 		return containers;
 	}
 
 	private void setGepublished(ContainerRef cref, boolean gepublished)
 			throws XCoreException {
 		ContainerRef metaCref = LookupManager.lookupMetaContainer(cref);
 
 		capi.shift(metaCref, null,
 				new AtomicEntry<Boolean>(gepublished, Boolean.class,
 						new KeySelector<String>("system", "gepublished")));
 	}
 
 	public boolean getGepublished(ContainerRef cref) throws XCoreException {
 		ContainerRef metaCref = LookupManager.lookupMetaContainer(cref);
 
 		try {
 			return (Boolean) ((AtomicEntry) capi.read(metaCref, 0, null,
 					new KeySelector<String>("system", "gepublished"))[0])
 					.getValue();
 		} catch (CountNotMetException cnme) {
 			return false;
 		}
 	}
 
 	private void validateXML(File file) throws LookupException {
 		/*
 		 * String schema = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + "<xs:schema
 		 * xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" + " <xs:import
 		 * namespace=\"http://www.w3.org/XML/1998/namespace\"
 		 * schemaLocation=\"http://www.w3.org/2001/xml.xsd\"/>" + " <xs:element
 		 * name=\"LookupManager\">" + " <xs:complexType>" + " <xs:sequence>" + "
 		 * <xs:element name=\"Lookup\" type=\"LookupUnit\" minOccurs=\"1\"
 		 * maxOccurs=\"unbounded\">" + " <xs:unique name=\"dummy1\">" + "
 		 * <xs:selector xpath=\"LookupManager/LookupUnit\"/>" + " <xs:field
 		 * xpath=\"@LookupName\"/>" + " </xs:unique>" + " </xs:element>" + "
 		 * </xs:sequence>" + " </xs:complexType>" + " </xs:element>" + "
 		 * <xs:complexType name=\"LookupUnit\">" + " <xs:sequence>" + "
 		 * <xs:element name=\"LookupName\" type=\"xs:string\"/>" + " <xs:element
 		 * name=\"JarFile\" type=\"xs:string\" minOccurs=\"0\"/>" + "
 		 * <xs:element name=\"LookupUnitSpecific\"/>" + " </xs:sequence>" + "
 		 * <xs:attribute name=\"Priority\" type=\"xs:int\" use=\"required\"/>" + "
 		 * </xs:complexType>" + "</xs:schema>";
 		 * 
 		 * try { Validator validator = SchemaFactory.newInstance(
 		 * XMLConstants.W3C_XML_SCHEMA_NS_URI).newSchema( new StreamSource(new
 		 * StringReader(schema))).newValidator();
 		 * 
 		 * validator.validate(new StreamSource(new FileReader(file))); } catch
 		 * (FileNotFoundException fnfe) { throw new LookupException("File " +
 		 * file.getName() + " could not be found"); } catch (IOException ioe) {
 		 * throw new LookupException(ioe); } catch (SAXException saxe) { throw
 		 * new LookupException(saxe); }
 		 */
 	}
 
 	public static ContainerRef lookupMetaContainer(ContainerRef cref)
 			throws LookupException {
 		ContainerRef metaCref = null;
 
 		try {
 			metaCref = new ContainerRef(new URI(cref.asURI().toASCIIString()
 					+ "/meta"));
 		} catch (URISyntaxException use) {
 			throw new LookupException(use);
 		}
 
 		metaCref.setSite(cref.getSite());
 
 		return metaCref;
 	}
 
 	/***
 	 * @param cref
 	 * @param key
 	 * @param value
 	 * @throws XCoreException
 	 */
 	public void addMetaInfo(ContainerRef cref, String key, String value)
 			throws XCoreException {
 		ContainerRef metaCref = LookupManager.lookupMetaContainer(cref);
 		ContainerRef info = null;
 
 		try {
 			info = (ContainerRef) ((AtomicEntry) capi.read(metaCref, 0, null,
 					new KeySelector<String>("system", "meta_information"))[0])
 					.getValue();
 		} catch (CountNotMetException cnme) {
 			info = capi.createContainer(null, null, null,
 					IContainer.INFINITE_SIZE, new LindaCoordinator());
 			capi.write(metaCref, 0, null, new AtomicEntry<ContainerRef>(info,
 					ContainerRef.class, new KeySelector<String>("system",
 							"meta_information")));
 		}
 
 		Entry a1 = new AtomicEntry<String>(key);
 		Entry a2 = new AtomicEntry<String>(value);
 		Tuple t1 = new Tuple(a1, a2);
 
 		capi.shift(info, null, t1);
 	}
 }