package org.webslinger.bsf;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.StringTokenizer;

 import java.util.logging.Logger;

 import java.util.concurrent.ConcurrentHashMap;

 import java.security.AccessController;

 import java.security.PrivilegedActionException;

 import java.security.PrivilegedExceptionAction;

 import org.apache.bsf.BSFEngine;

 import org.apache.bsf.BSFException;

 import org.apache.bsf.BSFManager;

 import org.webslinger.vfs.VFSDelegate;

 public abstract class AbstractManager extends BSFManager {

     protected final ConcurrentHashMap<String, String> registeredLanguages = new ConcurrentHashMap<String, String>();

     protected final ConcurrentHashMap<String, String> languagesByExtension = new ConcurrentHashMap<String, String>();

     protected final VFSDelegate<?, Object, ?> vfsDelegate;

     protected final Logger logger;

     protected final ConcurrentHashMap<String, LanguageEngine> loadedLanguages = new ConcurrentHashMap<String, LanguageEngine>();

     protected AbstractManager(VFSDelegate<?, Object, ?> vfsDelegate, Logger logger) throws BSFException {

         super();

         this.vfsDelegate = vfsDelegate;

         this.logger = logger != null ? logger : Logger.getLogger(getClass().getName());

         registerBean("vfsDelegate", vfsDelegate);

     }

     protected void postConstruct() throws BSFException {

         findLanguageEngines(getClass().getClassLoader());

         findLanguageEngines(Thread.currentThread().getContextClassLoader());

     }

     public Logger getLogger() {

         return logger;

     }

     public abstract void findLanguageEngines(ClassLoader loader) throws BSFException;

     public final void registerLanguageEngine(String languageName, String className, String[] extensions) {

         registeredLanguages.put(languageName, className);

         if (extensions != null) {

             for (int i = 0; i < extensions.length; i++) {

                 String extensionLanguages = languagesByExtension.get(extensions[i]);

                 extensionLanguages = extensionLanguages == null ? languageName : extensionLanguages + ',' + extensionLanguages;

                 languagesByExtension.put(extensions[i], extensionLanguages);

             }

         }

     }

     public String getLanguageFromFilename(String fileName) throws BSFException {

         int dot = fileName.lastIndexOf(".");

         String language = dot != -1 ? getLanguageFromExtensionInternal(fileName.substring(dot + 1)) : null;

         if (language != null) return language;

         throw new BSFException(BSFException.REASON_OTHER_ERROR,

                            "file extension missing: "

                            + "unable to determine language for '"

                            + fileName

                            + "'");

     }

     public String getLanguageFromExtension(String extension) throws BSFException {

         String language = getLanguageFromExtensionInternal(extension);

         if (language != null) return language;

         throw new BSFException(BSFException.REASON_OTHER_ERROR,

                                "file extension unknown: "

                                + "unable to determine language for '"

                                + extension

                                + "'");

     }

     protected String getLanguageFromExtensionInternal(String extension) throws BSFException {

         String langval = languagesByExtension.get(extension), lang = null;

         if (langval == null) return null;

         StringTokenizer st = new StringTokenizer(langval, ",");

         while (st.hasMoreTokens()) {

             String language = st.nextToken();

             try {

                 Class.forName(registeredLanguages.get(language));

                 return lang;

             } catch (ClassNotFoundException cnfe) {

             }

         }

         return null;

     }

     protected void initializeLanguageEngine(final LanguageEngine engine, final String language) throws BSFException {

         try {

             try {

                 AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {

                     public Object run() throws Exception {

                         engine.initialize(AbstractManager.this, language, declaredBeans);

                         return null;

                     }

                 });

             } catch (PrivilegedActionException e) {

                 throw e.getException();

             }

         } catch (BSFException e) {

             throw e;

         } catch (RuntimeException e) {

             throw e;

         } catch (Error e) {

             throw e;

         } catch (Throwable t) {

             throw (BSFException) new BSFException(BSFException.REASON_OTHER_ERROR, "unable to initialize engine for language: " + language).initCause(t);

         }

     }

     protected abstract LanguageEngine getLanguageEngineConvertor(String language, BSFEngine engine) throws BSFException;

     public LanguageEngine loadLanguageEngine(String language) throws BSFException {

         try {

             do {

                 LanguageEngine engine = loadedLanguages.get(language);

                 if (engine != null) return engine;

                 String className = registeredLanguages.get(language);

                 if (className == null) {

                     BSFEngine bsfEngine = super.loadScriptingEngine(language);

                     if (bsfEngine instanceof LanguageEngine) {

                         engine = (LanguageEngine) bsfEngine;

                     } else {

                         engine = getLanguageEngineConvertor(language, bsfEngine);

                         initializeLanguageEngine(engine, language);

                         pcs.addPropertyChangeListener(engine);

                     }

                 } else {

                     ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

                     if (classLoader == null) classLoader = getClass().getClassLoader();

                     synchronized (this) {

                         engine = (LanguageEngine) Class.forName(className, true, classLoader).newInstance();

                         initializeLanguageEngine(engine, language);

                         pcs.addPropertyChangeListener(engine);

                     }

                 }

                 LanguageEngine oldEngine = loadedLanguages.putIfAbsent(language, engine);

                 if (oldEngine == null) return engine;

                 pcs.removePropertyChangeListener(engine);

                 return oldEngine;

             } while (true);

         } catch (BSFException e) {

             throw e;

         } catch (ClassNotFoundException e) {

             throw (BSFException) new BSFException(BSFException.REASON_OTHER_ERROR, "unable to load language: " + language).initCause(e);

         } catch (IllegalAccessException e) {

             throw (BSFException) new BSFException(BSFException.REASON_OTHER_ERROR, "unable to load language: " + language).initCause(e);

         } catch (InstantiationException e) {

             throw (BSFException) new BSFException(BSFException.REASON_OTHER_ERROR, "unable to load language: " + language).initCause(e);

         }

     }

     public BSFEngine loadScriptingEngine(String language) throws BSFException {

         return loadLanguageEngine(language);

     }

     public void setDebug(String language, boolean debugging) throws BSFException {

         ((LanguageEngine) loadScriptingEngine(language)).setDebug(debugging);

     }

     public VFSDelegate<?, Object, ?> getVFSDelegate() {

         return vfsDelegate;

     }

     public Object apply(String lang, final String source, final int lineNo, final int columnNo, final Object funcBody, final String[] paramNames, final Object[] arguments) throws BSFException {

         final LanguageEngine engine = (LanguageEngine) loadScriptingEngine(lang);

         try {

             return AccessController.doPrivileged(

                 new PrivilegedExceptionAction<Object>() {

                     public Object run() throws Exception {

                         return engine.apply(source, lineNo, columnNo, funcBody, paramNames, arguments);

                     }

                 }

             );

         } catch (PrivilegedActionException e) {

             throw (BSFException) e.getException();

         }

     }

     public Object apply(String lang, final String source, final int lineNo, final int columnNo, final Object funcBody, final String[] paramNames, final Object[] arguments, final Class[] types) throws BSFException {

         final LanguageEngine engine = (LanguageEngine) loadScriptingEngine(lang);

         try {

             return AccessController.doPrivileged(

                 new PrivilegedExceptionAction<Object>() {

                     public Object run() throws Exception {

                         return engine.apply(source, lineNo, columnNo, funcBody, paramNames, arguments, types);

                     }

                 }

             );

         } catch (PrivilegedActionException e) {

             throw (BSFException) e.getException();

         }

     }

 }