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.ModuleRegistry;
  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_audio_common",
      service = { Module.class }
  )
  public class Module_audio_common extends Module {
  
      private static final Logger logger = LoggerFactory.getLogger(Module_audio_common.class);
  
      private boolean initialized = false;
      private XmlCatalogParser catalogParser;
      private ModuleRegistry moduleRegistry;
      private final LinkedList<Component> componentsToAdd;
      private final LinkedList<Component> componentsBeingAdded;
  
      public Module_audio_common() {
          super("audio-common",
                "5.1.5",
                "DAISY Pipeline 2 module :: Audio API");
          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;
      }
  
      @Reference(
          name = "ModuleRegistry",
          unbind = "-",
          service = ModuleRegistry.class,
          cardinality = ReferenceCardinality.MANDATORY,
          policy = ReferencePolicy.STATIC
      )
      public void setModuleRegistry(ModuleRegistry registry) {
          moduleRegistry = registry;
      }
  
      private void tryResolveComponent(String uri, String versionRange) throws ResolutionException {
          if (moduleRegistry.getModuleByComponent(URI.create(uri), versionRange) == null)
              throw new ResolutionException("Unresolved dependency " + uri + " with version=" + versionRange);
      }
  
      @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/audio-common/library.xpl".equals(name)) {
                 tryResolveXPathExtensionFunction("org.daisy.pipeline.audio.saxon.impl.TranscodeAudioFileDefinition$TranscodeAudioFile");
                 tryResolveComponent("http://www.daisy.org/pipeline/modules/file-utils/library.xpl",
                                     "[4.3.1,5.0.0)");
                 tryResolveComponent("http://www.daisy.org/pipeline/modules/common-utils/library.xsl",
                                     "[3.1.2,4.0.0)");
                 tryResolveComponent("http://www.daisy.org/pipeline/modules/fileset-utils/library.xpl",
                                     "[6.1.4,7.0.0)");
             }
         } 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");
     }
 }