/*

 Copyright (c) 2006, University of Tromsø

 All rights reserved.

 Redistribution and use in source and binary forms, with or without 

 modification, are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 

    of conditions and the following disclaimer.

  * Redistributions in binary form must reproduce the above copyright notice, this 

    list of conditions and the following disclaimer in the documentation and/or other 

    materials provided with the distribution.

  * Neither the name of the University of Tromsø nor the names of its contributors may 

    be used to endorse or promote products derived from this software without specific 

    prior written permission.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 

 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 

 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 

 SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 

 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 

 TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 

 BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 

 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 

 ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH 

 DAMAGE.

 */

 package argos.naming;

 import java.io.File;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.logging.Logger;

 import argos.annotation.Description;

 import argos.annotation.Impact;

 import argos.annotation.RemoveInstrumentation;

 import argos.deploy.ComponentManager;

 import argos.deploy.HotDeployer;

 import argos.logging.Console;

 import argos.metadata.ComponentMetaInfo;

 import argos.metadata.ServiceMetaInfo;

 import argos.proxy.NotificationProxy;

 import argos.util.ComponentComparator;

 /**

  * Created on 04.jul.2006

  * 

  * @author Dan Peder Eriksen

  */

 @Description("This component used used to see what components are availible in the system")

 public class NamingService {

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

         private static NamingService singelton = new NamingService();

         public static NamingService getInstance() {

                 return singelton;

         }

         private Map<ComponentMetaInfo, Object> componentMetaToComponent;

         private Map<Object, ComponentMetaInfo> componentToComponentMeta;

         private Map<File, ServiceMetaInfo> fileToService;

         private Map<File, Long> timestamps;

         private List<NotificationProxy> proxies;

         private Map<String, ComponentMetaInfo> stringToComponentMeta;

         private Map<String, ComponentMetaInfo> mbeanToComponentMeta;

         private Map<String, ServiceMetaInfo> stringToService;

         private List<File> loadedFiles;

         private NamingService() {

                 super();

                 componentMetaToComponent = new HashMap<ComponentMetaInfo, Object>();

                 stringToComponentMeta = new HashMap<String, ComponentMetaInfo>();

                 mbeanToComponentMeta = new HashMap<String, ComponentMetaInfo>();

                 stringToService = new HashMap<String, ServiceMetaInfo>();

                 componentToComponentMeta = new HashMap<Object, ComponentMetaInfo>();

                 fileToService = new HashMap<File, ServiceMetaInfo>();

                 timestamps = new HashMap<File, Long>();

                 proxies = new ArrayList<NotificationProxy>();

                 loadedFiles = new ArrayList<File>();

         }

         @Impact(Impact.ACTION)

         @Description("Adds a component")

         public synchronized boolean addComponent(ComponentMetaInfo meta, Object mbean) {

                 String name = meta.getName();

                 if(componentMetaToComponent.get(meta) == null) {

                         componentMetaToComponent.put(meta, mbean);

                         componentToComponentMeta.put(mbean, meta);

                         stringToComponentMeta.put(name, meta);

                         mbeanToComponentMeta.put(meta.getMbeanName(), meta);

                         logger.finest("Component added to naming service, " + name);

                         return true;

                 }

                 else {

                         logger.severe("Didnt add component " + name + " to naming service, already exists.");

                         return false;

                 }

         }

         @Impact(Impact.ACTION)

         @Description("Adds a notifcation proxy")

         public synchronized boolean addNotificationProxy(NotificationProxy proxy) {

                 if(proxies.contains(proxy)) {

                         logger.severe("Didnt add proxy " + proxy + " to naming service, already exists.");

                         return false;

                 }

                 else {

                         proxies.add(proxy);

                         return true;

                 }

         }

         @RemoveInstrumentation

         public synchronized void addService(ServiceMetaInfo service) {

                 stringToService.put(service.getName(), service);

                 fileToService.put(service.getFile(), service);

                 timestamps.put(service.getFile(), service.getFile().lastModified());

                 loadedFiles.add(service.getFile());

         }

         @Impact(Impact.INFO)

         @Description("Gets all the components metadata")

         public List<ComponentMetaInfo> getAllComponentMetaData() {

                 List<ComponentMetaInfo> list = new ArrayList<ComponentMetaInfo>();

                 for(String key : stringToComponentMeta.keySet()) {

                         list.add(stringToComponentMeta.get(key));

                 }

                 Collections.sort(list, new ComponentComparator());

                 return list;

         }

         @RemoveInstrumentation

         public Object getBangBang(String name) {

                 if("!!HotDeployer".equals(name)) {

                         return HotDeployer.getInstance();

                 }

                 else if("!!ComponentManager".equals(name)) {

                         return ComponentManager.getInstance();

                 }

                 else if("!!Console".equals(name)) {

                         return Console.console;

                 }

                 else {

                         return getComponentByName(name);

                 }

         }

         @Impact(Impact.INFO)

         @Description("Looks up a component")

         public Object getComponentByMeta(ComponentMetaInfo meta) {

                 Object o = componentMetaToComponent.get(meta);

                 if(o == null) {

                         logger.warning("Unable to find Component by ComonentMetaInfo: " + meta.getName());

                 }

                 return o; 

         }

         @Impact(Impact.INFO)

         @Description("Looks up a component, by name")

         public Object getComponentByName(String name) {

                 Object o = componentMetaToComponent.get(stringToComponentMeta.get(name));

                 if(o == null) {

                         logger.warning("Unable to find Component by name: " + name);

                 }

                 return o; 

         }

         @Impact(Impact.INFO)

         @Description("Looks up a components metadata, by name")

         public ComponentMetaInfo getComponentMetaByName(String name) {

                 return getComponentMetaByName(name, true);

         }

         @Impact(Impact.INFO)

         @Description("Looks up a components metadata, by name")

         public ComponentMetaInfo getComponentMetaByName(String name, boolean verbose) {

                 ComponentMetaInfo meta = stringToComponentMeta.get(name);

                 if(verbose && meta == null) {

                         logger.warning("Unable to find component meta data by name: " + name);

                 }

                 return meta;

         }

         @Impact(Impact.INFO)

         @Description("Looks up a components metadata, by component")

         public ComponentMetaInfo getComponentMetaByComponent(Object component) {

                 ComponentMetaInfo meta = componentToComponentMeta.get(component);

                 if(meta == null) {

                         logger.warning("Unable to find component meta data by component: " + component.getClass().toString());

                 }

                 return meta;

         }

         @Impact(Impact.INFO)

         @Description("Looks up a components metadata, by mbean name")

         public ComponentMetaInfo getComponentMetaByMBeanName(String mbean) {

                 ComponentMetaInfo meta = mbeanToComponentMeta.get(mbean);

                 if(meta == null) {

                         logger.warning("Unable to find component meta data by mbean name: " + mbean);

                 }

                 return meta;

         }

         @Impact(Impact.INFO)

         @Description("Returns a list of all registered components")

         public List<ComponentMetaInfo> getComponentMetaDatas() {

                 List<ComponentMetaInfo> results = new ArrayList<ComponentMetaInfo>();

                 for(ComponentMetaInfo key : componentMetaToComponent.keySet()) {

                         results.add(key);

                 }

                 return results;

         }

         @Impact(Impact.INFO)

         @Description("Returns a list of all loaded files")

         public List<File> getLoadedFiles() {

                 return loadedFiles;

         }

         @Impact(Impact.INFO)

         @Description("Looks up the Notification proxy for the component")

         public NotificationProxy getNotificationProxy(Object object) {

                 if(object == HotDeployer.getInstance()) {

                         return HotDeployer.getInstance().proxy;

                 }

                 if(object == ComponentManager.getInstance()) {

                         return ComponentManager.getInstance().proxy;

                 }

                 for(NotificationProxy np : proxies) {

                         if(np.getMbean() == object) {

                                 logger.finest("Found NotificationProxy for " + object.toString());

                                 return np;

                         }

                 }

                 logger.severe("Didnt find NotificationProxy for " + object.toString());

                 return null;

         }

         @Description("Looks up a service by name.")

         @Impact(Impact.INFO)

         public ServiceMetaInfo getServiceByName(String name, boolean verbose) {

                 ServiceMetaInfo s = stringToService.get(name);

                 if(verbose && s == null) {

                         logger.warning("Unable to find service by name: " + name);

                 }

                 return s;

         }

         @Impact(Impact.INFO)

         @Description("Gets the service meta data, by name")

         public ServiceMetaInfo getServiceByName(String name) {

                 return getServiceByName(name, true);

         }

         @Description("Looks up a service by name.")

         @Impact(Impact.INFO)

         public ServiceMetaInfo getServiceByFile(File file) {

                 return fileToService.get(file);

         }

         @Impact(Impact.INFO)

         @Description("Gets the meta data of all services loaded.")

         public List<ServiceMetaInfo> getAllServices() {

                 List<ServiceMetaInfo> list = new ArrayList<ServiceMetaInfo>();

                 for(String name : stringToService.keySet()) {

                         list.add(getServiceByName(name));

                 }

                 return list;

         }

         @Impact(Impact.INFO)

         @Description("Checks if a component is loaded, by meta info")

         public boolean isComponentLoaded(ComponentMetaInfo meta) {

                 return componentMetaToComponent.containsKey(meta);

         }

         @Impact(Impact.INFO)

         @Description("Checks if a component is loaded, by name")

         public boolean isComponentLoaded(String name) {

                 return stringToComponentMeta.containsKey(name);

         }

         @Impact(Impact.INFO)

         @Description("Checks if a service is loaded, by file")

         public boolean isFileLoaded(File file) {

                 return getServiceByFile(file) != null;

         }

         @Impact(Impact.ACTION)

         @Description("Removes a component")

         public synchronized void removeComponent(ComponentMetaInfo meta) {

                 String name = meta.getName();

                 Object comp = componentMetaToComponent.remove(meta);

                 stringToComponentMeta.remove(name);

                 componentToComponentMeta.remove(comp);

                 mbeanToComponentMeta.remove(meta.getMbeanName());

                 proxies.remove(comp);

                 logger.finest("Removing component " + name + " from naming service");

         }

         @RemoveInstrumentation

         public synchronized void removeService(ServiceMetaInfo service) {

                 stringToService.remove(service.getName());

                 fileToService.remove(service.getFile());

                 timestamps.remove(service.getFile());

                 loadedFiles.remove(service.getFile());

         }

         /**

          * Checks to see if the given file is newer than the one that 

          * is loaded. Its assumed that the file is already loaded.

          * 

          * @param jarFile        The jar file checking is done against.

          * @return        True if the given jar file is never, false otherwise.

          */

         @Description("Checks if a file is newer than the one already loaded")

         @Impact(Impact.ACTION)

         public boolean isNewer(File jarFile) {

                 Long time = timestamps.get(jarFile);

                 if(time == null) {

                         return true;

                 }

                 else {

                         return jarFile.lastModified() > time;

                 }

         }

 }