package org.xvsm.lookup.xvsm;
   
   import java.net.URI;
   import java.net.URISyntaxException;
   import java.util.ArrayList;
   import java.util.Enumeration;
   import java.util.Hashtable;
   
   import org.jdom.Element;
  import org.xvsm.configuration.ConfigurationManager;
  import org.xvsm.coordinators.KeyCoordinator;
  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.ICapi;
  import org.xvsm.interfaces.container.IContainer;
  import org.xvsm.interfaces.lookup.ILookup;
  import org.xvsm.internal.exceptions.ContainerFullException;
  import org.xvsm.internal.exceptions.ContainerNameOccupiedException;
  import org.xvsm.internal.exceptions.CountNotMetException;
  import org.xvsm.internal.exceptions.InvalidContainerException;
  import org.xvsm.internal.exceptions.XCoreException;
  import org.xvsm.lookup.LookupManager;
  import org.xvsm.lookup.exceptions.ContainerAlreadyPublishedException;
  import org.xvsm.lookup.exceptions.ContainerNotPublishedException;
  import org.xvsm.lookup.exceptions.LookupException;
  import org.xvsm.remote.TransportHandler;
  import org.xvsm.selectors.KeySelector;
  import org.xvsm.selectors.LindaSelector;
  import org.xvsm.selectors.RandomSelector;
  import org.xvsm.transactions.Transaction;
  
  /***
   * This is the implementation of the ILookup-Interface using XVSM containers.
   * For publishing containers are 2 containers created on the lookup-server:
   * "LookupContainer" and "LookupContainerDetails".
   * 
   * @author Hannu-Daniel Goiss
   */
  public class XVSMLookup implements ILookup {
  	private URI remoteCapi;
  	private ICapi capi;
  
  	/***
  	 * Constructor for use with environment variable
  	 * 
  	 * @param site
  	 * @param table
  	 * @throws LookupException
  	 */
  	public XVSMLookup(URI site, Hashtable<String, String> table)
  			throws LookupException {
  		URI remotesiteURI = null;
  
  		String remotesite = table
  				.get("org.xvsm.lookup.xvsm.XVSMLookup.RemoteURI");
  
  		if (remotesite.compareTo("") != 0) {
  			try {
  				remotesiteURI = new URI(remotesite);
  			} catch (URISyntaxException use) {
  				throw new LookupException(use);
  			}
  		}
  		startLookup(site, remotesiteURI);
  	}
  
  	/***
  	 * Constructor for use with XML file
  	 * 
  	 * @param site
  	 * @param element
  	 * @throws LookupException
  	 */
  	public XVSMLookup(URI site, Element element) throws LookupException {
  		URI remotesiteURI = null;
  
  		String remotesite = element.getChild("RemoteURI").getTextTrim();
  
  		if (remotesite.compareTo("") != 0) {
  			try {
  				remotesiteURI = new URI(remotesite);
  			} catch (URISyntaxException use) {
  				throw new LookupException(use);
  			}
  		}
  		startLookup(site, remotesiteURI);
  	}
  
  	/***
  	 * @param site
  	 * @param remote_site
  	 * @throws LookupException
  	 */
  	public XVSMLookup(URI site, URI remote_site) throws LookupException {
  		startLookup(site, remote_site);
 	}
 
 	/***
 	 * @param site
 	 * @param remote_site
 	 * @throws LookupException
 	 */
 	private void startLookup(URI site, URI remote_site) throws LookupException {
 		try {
 			capi = new Capi();
 
 			ContainerRef cref = null;
 			try {
 				cref = capi.createContainer(null, remote_site,
 						"LookupContainer", IContainer.INFINITE_SIZE,
 						new KeyCoordinator(new KeyCoordinator.KeyType("lookup",
 								String.class)), new LindaCoordinator());
 			} catch (ContainerNameOccupiedException cnoe) {
 			}
 			try {
 				capi.createContainer(null, remote_site,
 						"LookupContainerDetails", IContainer.INFINITE_SIZE,
 						new KeyCoordinator(new KeyCoordinator.KeyType("lookup",
 								String.class)), new LindaCoordinator());
 			} catch (ContainerNameOccupiedException cnoe) {
 			}
 			remoteCapi = remote_site;
 		} catch (XCoreException xce) {
 			throw new LookupException(xce);
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.xvsm.interfaces.lookup.ILookup#publish(org.xvsm.core.ContainerRef)
 	 */
 	public void publish(ContainerRef cref)
 			throws ContainerAlreadyPublishedException, LookupException {
 		String ipname;
 		String name = null;
 		Transaction tx = null;
 		ContainerRef lookup_cref;
 		boolean throwException = false;
 
 		try {
 			name = this.getContainerName(cref);
 		} catch (LookupException le) {
 		}
 
 		catch (XCoreException xce) {
 			throw new LookupException(xce);
 		}
 
 		try {
 			ipname = name;
 
 			try {
 				try {
 					lookup_cref = capi.lookupContainer(null, remoteCapi,
 							"LookupContainer");
 				} catch (InvalidContainerException e) {
 					lookup_cref = capi.createContainer(null, remoteCapi,
 							"LookupContainer", IContainer.INFINITE_SIZE,
 							new KeyCoordinator(new KeyCoordinator.KeyType(
 									"lookup", String.class)),
 							new LindaCoordinator());
 				}
 
 				tx = capi.createTransaction(remoteCapi, Capi.INFINITE_TIMEOUT);
 
 				Entry a1 = new AtomicEntry<String>(name);
 				Entry a2 = new AtomicEntry<ContainerRef>(cref);
 				URI testuri = TransportHandler.getInstance().getListener(
 						ConfigurationManager.getInstance().getStringSetting(
 								"DefaultAnswerToProtocol")).getUri();
 				// URI testuri = TransportManagerInstance.getInstance()
 				// .getDefaultListener().getUri();
 
 				Entry a3 = new AtomicEntry<URI>(testuri);
 
 				Tuple t1 = new Tuple(a1, a2, a3);
 				t1.addSelectors(new KeySelector<String>("lookup", name));
 
 				try {
 					capi.write(lookup_cref, 0, tx, t1);
 				} catch (ContainerFullException e) {
 					throwException = true;
 				}
 
 				if (throwException == false) {
 					this.updateDescription(cref, tx);
 					capi.commitTransaction(tx);
 				} else {
 					capi.rollbackTransaction(tx);
 				}
 
 			} catch (XCoreException e) {
 				try {
 					capi.rollbackTransaction(tx);
 				} catch (Exception e1) {
 				}
 
 				try {
 					unpublish(cref);
 				} catch (Exception e1) {
 
 				}
 
 				throw new LookupException(e);
 			}
 
 		} catch (XCoreException xce) {
 			throw new LookupException(xce);
 		}
 		if (throwException == true) {
 			throw new ContainerAlreadyPublishedException(name);
 		}
 	}
 
 	public void publish(String name) throws ContainerAlreadyPublishedException,
 			LookupException {
 
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.xvsm.interfaces.lookup.ILookup#unpublish(org.xvsm.core.ContainerRef)
 	 */
 	public void unpublish(ContainerRef cref)
 			throws ContainerNotPublishedException, LookupException {
 		Transaction tx = null;
 		String name;
 
 		try {
 			name = getContainerName(cref);
 
 			try {
 				ContainerRef rem_cref = capi.lookupContainer(null, remoteCapi,
 						"LookupContainer");
 				ContainerRef rem_cref_def = capi.lookupContainer(null,
 						remoteCapi, "LookupContainerDetails");
 				tx = capi.createTransaction(remoteCapi, Capi.INFINITE_TIMEOUT);
 
 				try {
 					capi.destroy(rem_cref, 0, tx, new KeySelector<String>(
 							"lookup", name));
 				} catch (CountNotMetException cnme) {
 				}
 				try {
 					capi.destroy(rem_cref_def, 0, tx, new KeySelector<String>(
 							"lookup", name));
 				} catch (CountNotMetException cnme) {
 				}
 
 				capi.commitTransaction(tx);
 			} catch (Exception e) {
 				// e.printStackTrace();
 
 				try {
 					capi.rollbackTransaction(tx);
 				} catch (Exception e1) {
 				}
 			}
 		} catch (XCoreException xce) {
 			throw new LookupException(xce);
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.xvsm.interfaces.lookup.ILookup#lookup(java.lang.String)
 	 */
 	public ContainerRef[] lookup(String name)
 			throws ContainerNotPublishedException, LookupException {
 		Transaction tx = null;
 		boolean vorhanden;
 		ArrayList<ContainerRef> containers = new ArrayList<ContainerRef>();
 		ContainerRef tempContainer = null;
 		String containerName = null;
 		URI containerIp = null;
 
 		try {
 			try {
 				ContainerRef rem_cref = capi.lookupContainer(null, remoteCapi,
 						"LookupContainer");
 
 				tx = capi.createTransaction(remoteCapi, Capi.INFINITE_TIMEOUT);
 
 				Entry[] entries1 = capi.read(rem_cref, 0, tx,
 						new KeySelector<String>("lookup", name));
 
 				capi.commitTransaction(tx);
 
 				if (entries1.length > 0) {
 					Tuple t1 = (Tuple) entries1[0];
 
 					Entry[] e = t1.toArray();
 
 					AtomicEntry ae1 = (AtomicEntry) e[0];
 					AtomicEntry ae2 = (AtomicEntry) e[1];
 					AtomicEntry ae3 = (AtomicEntry) e[2];
 
 					containerName = (String) ae1.getValue();
 					tempContainer = (ContainerRef) ae2.getValue();
 					containerIp = (URI) ae3.getValue();
 					if (tempContainer.getSite() == null) {
 						tempContainer.setSite(containerIp);
 					}
 
 					vorhanden = false;
 					for (int j = 0; j < containers.size() && vorhanden == false; j++) {
 						if (tempContainer.toString().compareTo(
 								containers.get(j).toString()) == 0) {
 							vorhanden = true;
 						}
 					}
 					if (vorhanden == false) {
 						containers.add(tempContainer);
 					}
 				}
 			} catch (Exception e) {
 				try {
 					capi.rollbackTransaction(tx);
 				} catch (Exception e1) {
 				}
 			}
 
 			if (containers.size() == 0) {
 				throw new ContainerNotPublishedException(name);
 			}
 
 			ContainerRef[] containerArray = new ContainerRef[containers.size()];
 
 			for (int i = 0; i < containers.size(); i++) {
 				containerArray[i] = containers.get(i);
 			}
 
 			return containerArray;
 		} catch (XCoreException xce) {
 			throw new LookupException(xce);
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.xvsm.interfaces.lookup.ILookup#lookup(java.util.Hashtable)
 	 */
 	public ContainerRef[] lookup(Hashtable list)
 			throws ContainerNotPublishedException, LookupException {
 		return lookup(null, list);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.xvsm.interfaces.lookup.ILookup#lookup(java.lang.String,
 	 *      java.util.Hashtable)
 	 */
 	public ContainerRef[] lookup(String name, Hashtable list)
 			throws ContainerNotPublishedException, LookupException {
 		Transaction tx = null;
 		ArrayList<ContainerRef> containers = new ArrayList<ContainerRef>();
 		ArrayList<ContainerRef> containers2 = new ArrayList<ContainerRef>();
 		String containerName = null;
 		URI containerIp = null;
 
 		try {
 			try {
 				ContainerRef rem_cref = capi.lookupContainer(null, remoteCapi,
 						"LookupContainerDetails");
 				ContainerRef metaCref = LookupManager
 						.lookupMetaContainer(rem_cref);
 
 				tx = capi.createTransaction(remoteCapi, Capi.INFINITE_TIMEOUT);
 
 				int count = 0;
 				containers2.clear();
 				for (Enumeration enumeration = list.keys(); enumeration
 						.hasMoreElements();) {
 					String key = (String) enumeration.nextElement();
 					String value = (String) list.get(key);
 
 					LindaSelector ts = new LindaSelector(Capi.INFINITE,
 							new Tuple(new AtomicEntry<ContainerRef>(
 									ContainerRef.class),
 									new AtomicEntry<String>(key),
 									new AtomicEntry<String>(value)));
 					Entry[] entries1 = capi.read(rem_cref, 0, tx, ts);
 
 					for (Entry entry : entries1) {
 						Tuple t1 = (Tuple) entry;
 
 						Entry[] e = t1.toArray();
 
 						AtomicEntry ae1 = (AtomicEntry) e[0];
 						AtomicEntry ae2 = (AtomicEntry) e[1];
 						AtomicEntry ae3 = (AtomicEntry) e[2];
 
 						ContainerRef xcref = (ContainerRef) ae1.getValue();
 						String s1 = (String) ae2.getValue();
 						String s2 = (String) ae3.getValue();
 
 //						if (xcref.getSite() == null) {
 //							xcref.setSite(s2);
 //						}
 
 						containerName = this.getContainerName(xcref);
 
 						if ((name != null && containerName.compareTo(name) == 0)
 								|| name == null) {
 							try {
 								xcref = this.lookup(containerName)[0];
 								if (count == 0) {
 									containers.add(xcref);
 								} else {
 									containers2.add(xcref);
 								}
 							} catch (ContainerNotPublishedException cnfe) {
 
 							}
 						}
 					}
 					if (count == 0) {
 					} else {
 						containers.retainAll(containers2);
 					}
 
 					count++;
 				}
 
 				capi.commitTransaction(tx);
 			} catch (Exception e) {
 				try {
 					capi.rollbackTransaction(tx);
 				} catch (Exception e1) {
 				}
 			}
 
 			if (containers.size() == 0) {
 				throw new ContainerNotPublishedException(
 						"searched for meta information");
 			}
 
 			ContainerRef[] containerArray = new ContainerRef[containers.size()];
 
 			for (int i = 0; i < containers.size(); i++) {
 				containerArray[i] = containers.get(i);
 			}
 
 			return containerArray;
 		} catch (XCoreException xce) {
 			throw new LookupException(xce);
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.xvsm.interfaces.lookup.ILookup#updateDescription(org.xvsm.core.ContainerRef)
 	 */
 	public void updateDescription(ContainerRef cref)
 			throws ContainerNotPublishedException, LookupException {
 		Transaction tx = null;
 		try {
 			tx = capi.createTransaction(remoteCapi, Capi.INFINITE_TIMEOUT);
 
 			this.updateDescription(cref, tx);
 
 			capi.commitTransaction(tx);
 		} catch (XCoreException xce) {
 			try {
 				capi.rollbackTransaction(tx);
 			} catch (Exception e) {
 
 			}
 
 			throw new LookupException(xce);
 		}
 	}
 
 	/***
 	 * @param cref
 	 * @param tx
 	 * @throws LookupException
 	 */
 	private void updateDescription(ContainerRef cref, Transaction tx)
 			throws LookupException {
 		try {
 			String name = this.getContainerName(cref);
 			ContainerRef metaInfo = this.getMetaInfoCref(cref);
 			ContainerRef lookup_cref_def;
 			try {
 				lookup_cref_def = capi.lookupContainer(null, remoteCapi,
 						"LookupContainerDetails");
 
 				try {
 					capi.destroy(lookup_cref_def, 0, tx,
 							new KeySelector<String>("lookup", name));
 				} catch (CountNotMetException cnme) {
 
 				}
 			} catch (InvalidContainerException e) {
 				lookup_cref_def = capi.createContainer(null, remoteCapi,
 						"LookupContainerDetails", IContainer.INFINITE_SIZE,
 						new KeyCoordinator(new KeyCoordinator.KeyType("lookup",
 								String.class)), new LindaCoordinator());
 			}
 
 			if (metaInfo != null) {
 				ContainerRef metaCref = LookupManager.lookupMetaContainer(cref);
 
 				String containerName = (String) ((AtomicEntry) capi.read(
 						metaCref, 0, null, new KeySelector<String>("system",
 								"name"))[0]).getValue();
 
 				LindaSelector ts = new LindaSelector(Capi.INFINITE, new Tuple(
 						null, null));
 
 				Entry[] entries1 = capi.read(metaInfo, 0, null, ts);
 
 				for (Entry entry : entries1) {
 					Tuple tuple = (Tuple) entry;
 
 					Entry[] e = tuple.toArray();
 
 					AtomicEntry ae1 = (AtomicEntry) e[0];
 					AtomicEntry ae2 = (AtomicEntry) e[1];
 
 					String eins = (String) ae1.getValue();
 					String zwei = (String) ae2.getValue();
 
 					Entry a1 = new AtomicEntry<ContainerRef>(cref);
 					Entry a2 = new AtomicEntry<String>(eins);
 					Entry a3 = new AtomicEntry<String>(zwei);
 
 					Tuple t1 = new Tuple(a1, a2, a3);
 					// t1.addSelectors(new
 					// KeySelector<String>("lookup",name));
 
 					capi.write(lookup_cref_def, 0, tx, t1);
 				}
 			}
 		} catch (XCoreException xce) {
 			throw new LookupException(xce);
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.xvsm.interfaces.lookup.ILookup#publishedContainers()
 	 */
 	public ContainerRef[] publishedContainers() throws LookupException {
 		Transaction tx = null;
 		ArrayList<ContainerRef> containers = new ArrayList<ContainerRef>();
 		ContainerRef tempContainer = null;
 		String containerName = null;
 		URI containerIp = null;
 
 		try {
 			ContainerRef rem_cref = capi.lookupContainer(null, remoteCapi,
 					"LookupContainer");
 
 			tx = capi.createTransaction(remoteCapi, Capi.INFINITE_TIMEOUT);
 
 			Entry[] entries1 = capi.read(rem_cref, 0, tx, new RandomSelector(
 					RandomSelector.CNT_ALL));
 
 			capi.commitTransaction(tx);
 
 			if (entries1.length > 0) {
 				Tuple t1 = (Tuple) entries1[0];
 
 				Entry[] e = t1.toArray();
 
 				AtomicEntry ae1 = (AtomicEntry) e[0];
 				AtomicEntry ae2 = (AtomicEntry) e[1];
 				AtomicEntry ae3 = (AtomicEntry) e[2];
 
 				containerName = (String) ae1.getValue();
 				tempContainer = (ContainerRef) ae2.getValue();
 				containerIp = (URI) ae3.getValue();
 				if (tempContainer.getSite() == null) {
 					tempContainer.setSite(containerIp);
 				}
 
 				containers.add(tempContainer);
 			}
 		} catch (Exception e) {
 			try {
 				capi.rollbackTransaction(tx);
 			} catch (Exception e1) {
 			}
 		}
 
 		if (containers.size() == 0) {
 			return null;
 		}
 
 		ContainerRef[] containerArray = new ContainerRef[containers.size()];
 
 		for (int i = 0; i < containers.size(); i++) {
 			containerArray[i] = containers.get(i);
 		}
 
 		return containerArray;
 	}
 
 	/***
 	 * @param cref
 	 * @return
 	 * @throws XCoreException
 	 */
 	private String getContainerName(ContainerRef cref) throws XCoreException {
 		ContainerRef metaCref = LookupManager.lookupMetaContainer(cref);
 		String containerName = (String) ((AtomicEntry) capi.read(metaCref, 0,
 				null, new KeySelector<String>("system", "name"))[0]).getValue();
 
 		return containerName;
 	}
 
 	/***
 	 * @param cref
 	 * @return
 	 * @throws XCoreException
 	 */
 	private ContainerRef getMetaInfoCref(ContainerRef cref)
 			throws XCoreException {
 		ContainerRef metaCref = LookupManager.lookupMetaContainer(cref);
 		try {
 			return (ContainerRef) ((AtomicEntry) capi.read(metaCref, 0, null,
 					new KeySelector<String>("system", "meta_information"))[0])
 					.getValue();
 		} catch (CountNotMetException cnme) {
 			return null;
 		}
 	}
 }