package org.webslinger.template;

 import java.io.IOException;

 import java.io.Writer;

 import java.util.ArrayList;

 import java.util.Iterator;

 import java.util.Map;

 import java.util.Set;

 import java.util.concurrent.ConcurrentHashMap;

 import java.util.logging.Logger;

 import javax.imageio.spi.ServiceRegistry;

 import org.apache.bsf.BSFEngine;

 import org.apache.bsf.BSFException;

 import org.webslinger.bsf.AbstractManager;

 import org.webslinger.bsf.LanguageEngine;

 import org.webslinger.vfs.VFSDelegate;

 import org.webslinger.vfs.TypeVFSDelegate;

 public class TemplateManager extends AbstractManager {

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

     public TemplateManager(Logger logger) throws BSFException {

         this(TypeVFSDelegate.DEFAULT, logger);

     }

     public TemplateManager(VFSDelegate<?, Object, ?> vfsDelegate, Logger logger) throws BSFException {

         super(vfsDelegate, logger);

         postConstruct();

     }

     public void findLanguageEngines(ClassLoader loader) throws BSFException {

         if (loader == null) return;

         Iterator<TemplateEngineInfo> it = ServiceRegistry.lookupProviders(TemplateEngineInfo.class, loader);

         while (it.hasNext()) {

             try {

                 TemplateEngineInfo info = it.next();

                 for (String name: info.getNames()) {

                     registerLanguageEngine(name, info.getImplClassName(name), info.getExtensions(name));

                 }

             } catch (RuntimeException e) {

             } catch (UnsupportedClassVersionError e) {

             }

         }

         Iterator<TemplateMacro> it1 = ServiceRegistry.lookupProviders(TemplateMacro.class, loader);

         while (it1.hasNext()) {

             try {

                 TemplateMacro macro = it1.next();

                 declareBean(macro.getName(), macro, TemplateMacro.class);

             } catch (RuntimeException e) {

             } catch (UnsupportedClassVersionError e) {

             }

         }

         Iterator<TemplateMacroInfo> it2 = ServiceRegistry.lookupProviders(TemplateMacroInfo.class, loader);

         while (it2.hasNext()) {

             TemplateMacroInfo info = it2.next();

             TemplateMacro[] macros = info.getMacros();

             if (macros == null) continue;

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

                 declareBean(macros[i].getName(), macros[i], TemplateMacro.class);

             }

         }

     }

     public void declareBean(String name, Object bean, Class type) throws BSFException {

         if (!(bean instanceof TemplateMacro)) throw new IllegalArgumentException("not a bean(" + name + ")");

         super.declareBean(name, bean, type);

         macros.put(name, (TemplateMacro) bean);

     }

     public void undeclareBean(String name) throws BSFException {

         macros.remove(name);

         super.undeclareBean(name);

     }

     public Set<String> getMacroNames() {

         return macros.keySet();

     }

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

         throw new UnsupportedOperationException("Template engines can't be implemented as standard BSFEngines.");

     }

     public static abstract class MacroBody implements TemplateMacro {

         public String getName() {

             return "MacroBody";

         }

         public boolean isBlock() {

             return false;

         }

         public boolean render(TemplateManager manager, Object parent, Writer writer, Args args, Map<String, Object> context, Body body) throws IOException, BSFException {

             Body outerBody = popBody();

             try {

                 outerBody.render(writer, context);

                 return false;

             } finally {

                 pushBody(outerBody);

             }

         }

         public TemplateMacro newInstance(TemplateManager manager, Object parent, Args args) throws IOException, BSFException {

             return this;

         }

     }

     protected static final ThreadLocal<ArrayList<TemplateMacro.Body>> tl = new ThreadLocal<ArrayList<TemplateMacro.Body>>();

     public static void pushBody(TemplateMacro.Body body) {

         ArrayList<TemplateMacro.Body> bodies = tl.get();

         if (bodies == null) {

             bodies = new ArrayList<TemplateMacro.Body>();

             tl.set(bodies);

         }

         bodies.add(body);

     }

     public static TemplateMacro.Body popBody() {

         ArrayList<TemplateMacro.Body> bodies = tl.get();

         try {

             return bodies.remove(bodies.size() - 1);

         } finally {

             if (bodies.isEmpty()) tl.set(null);

         }

     }

 }