package org.daisy.pipeline.modules.impl;
   
   import java.net.URI;
   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_smil_utils",
      service = { Module.class }
  )
  public class Module_smil_utils extends Module {
  
      private static final Logger logger = LoggerFactory.getLogger(Module_smil_utils.class);
  
      private boolean initialized = false;
      private XmlCatalogParser catalogParser;
      private ModuleRegistry moduleRegistry;
      private final LinkedList<Component> componentsToAdd;
      private final LinkedList<Component> componentsBeingAdded;
  
      public Module_smil_utils() {
          super("smil-utils",
                "4.0.2",
                "DAISY Pipeline 2 module :: SMIL 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;
      }
  
      @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/smil-utils/library.xpl".equals(name)) {
                 tryResolveComponent("http://www.daisy.org/pipeline/modules/mediatype-utils/library.xpl",
                                     "[2.0.2,3.0.0)");
                 tryResolveComponent("http://www.daisy.org/pipeline/modules/file-utils/library.xsl",
                                     "[4.3.1,5.0.0)");
                 tryResolveComponent("http://www.daisy.org/pipeline/modules/common-utils/generate-id.xsl",
                                     "[3.1.2,4.0.0)");
                 tryResolveComponent("http://www.daisy.org/pipeline/modules/fileset-utils/library.xpl",
                                     "[6.1.4,7.0.0)");
                 tryResolveComponent("http://www.daisy.org/pipeline/modules/common-utils/library.xpl",
                                     "[3.1.2,4.0.0)");
             }
         } catch (ResolutionException re) {
             logger.warn("Component " + component.getURI() + " can not be loaded: " + re.getMessage());
             return false;
         }
         return super.addComponent(component);
     }
 }