package org.daisy.pipeline.modules.impl;
   
   import java.net.URI;
   import java.nio.file.NoSuchFileException;
   import java.util.LinkedList;
   
   import org.daisy.pipeline.modules.Component;
   import org.daisy.pipeline.modules.Module;
   import org.daisy.pipeline.modules.ResolutionException;
  import org.daisy.pipeline.xmlcatalog.XmlCatalogParser;
  import org.osgi.service.component.annotations.Activate;
  import org.osgi.service.component.annotations.Reference;
  import org.osgi.service.component.annotations.ReferenceCardinality;
  import org.osgi.service.component.annotations.ReferencePolicy;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.slf4j.helpers.NOPLogger;
  
  @org.osgi.service.component.annotations.Component(
      name = "org.daisy.pipeline.modules.impl.Module_common_utils",
      service = { Module.class }
  )
  public class Module_common_utils extends Module {
  
      private static final Logger logger = LoggerFactory.getLogger(Module_common_utils.class);
  
      private boolean initialized = false;
      private XmlCatalogParser catalogParser;
      private final LinkedList<Component> componentsToAdd;
      private final LinkedList<Component> componentsBeingAdded;
  
      public Module_common_utils() {
          super("common-utils",
                "3.1.3",
                "DAISY Pipeline 2 module :: Common Utilities");
          componentsToAdd = new LinkedList<>();
          componentsBeingAdded = new LinkedList<>();
      }
  
      @Reference(
          name = "XmlCatalogParser",
          unbind = "-",
          service = XmlCatalogParser.class,
          cardinality = ReferenceCardinality.MANDATORY,
          policy = ReferencePolicy.STATIC
      )
      public void setParser(XmlCatalogParser parser) {
          catalogParser = parser;
      }
  
      @Activate
      protected void init() {
          logger.debug("Initializing module " + getName());
          Module tmpModule = new Module(getName(), getVersion(), getTitle()) {
              @Override public void resolveDependencies() {}
              @Override public Logger getLogger() { return NOPLogger.NOP_LOGGER; }
          };
          Module.parseCatalog(tmpModule, catalogParser);
          for (String e : tmpModule.getEntities()) {
              addEntity(tmpModule.getEntity(e));
              logger.debug("Loaded entity: " + e);
          }
          for (URI c : tmpModule.getComponents()) {
              components.put(c, () -> null); // will be replaced during resolveDependencies()
              componentsToAdd.add(tmpModule.getComponent(c));
          }
          logger.debug("Module " + getName() + " initialized, but dependencies have not been resolved yet");
      }
  
      // Not calling resolveDependencies() during object construction yet because it depends
      // on other modules, and other modules may depend on this module. resolveDependencies()
      // will be called when the object gets bound in ModuleRegistry. The method may recursively
      // call itself. It copes with that by activating components in a different order
      // when called recursively. ModuleRegistry has protection against endless recursion.
      @Override
      public void resolveDependencies() {
          if (!initialized) {
              boolean recursive = !componentsBeingAdded.isEmpty();
              if (recursive)
                  logger.debug("Resolving dependencies of module " + getName() + " (continuing in recursive call)");
              else
                  logger.debug("Resolving dependencies of module " + getName());
              while (true) {
                  if (componentsToAdd.isEmpty()) {
                      if (componentsBeingAdded.isEmpty())
                          break;
                      componentsToAdd.addAll(componentsBeingAdded);
                      componentsBeingAdded.clear();
                  }
                  Component c = componentsToAdd.poll();
                  componentsBeingAdded.add(c);
                  if (addComponent(c)) // may call resolveDependencies() recursively
                      logger.debug("Loaded component: " + c.getURI());
                  componentsBeingAdded.remove(c);
                  componentsToAdd.remove(c);
              }
              if (!initialized)
                  logger.debug("Done resolving dependencies of module " + getName());
              initialized = true;
         }
     }
 
     @Override
     protected boolean addComponent(Component component) {
         String name = component.getURI().toString();
         try {
             if ("http://www.daisy.org/pipeline/modules/common-utils/i18n.xsl".equals(name)) {
                 tryResolveXPathExtensionFunction("org.daisy.pipeline.common.NormalizeLang");
             }
         } catch (ResolutionException re) {
             logger.warn("Component " + component.getURI() + " can not be loaded: " + re.getMessage());
             return false;
         }
         return super.addComponent(component);
     }
 
     private void tryResolveXPathExtensionFunction(String className) throws ResolutionException {
         try {
             getResource("../" + className.replace('.', '/') + ".class");
             return;
         } catch (NoSuchFileException e) {
         }
         // if the function is not implemented in the same module, the class must be on the class path
         try {
             Class.forName(className);
             return;
         } catch (Throwable e) {
         }
         throw new ResolutionException(
             "Unresolved Java dependency: no class " + className + " found on the class path");
     }
 }