/*
    * Copyright 2010-2013 smartics, Kronseder & Reiner GmbH
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package de.smartics.testdoc.report.export.doc;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.ObjectInputStream;
  import java.lang.management.ManagementFactory;
  import java.util.Collection;
  
  import javax.management.JMX;
  import javax.management.MBeanServer;
  import javax.management.MalformedObjectNameException;
  import javax.management.ObjectName;
  
  import org.apache.commons.io.FileUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import de.smartics.testdoc.core.adapter.JmxExportAdapterClient;
  import de.smartics.testdoc.core.adapter.JmxExportAdapterMBean;
  import de.smartics.testdoc.core.adapter.PersistenceUtils;
  import de.smartics.testdoc.core.doc.UnitTestDoc;
  import de.smartics.testdoc.core.doc.UnitTestDocIndex;
  
  /**
   * Checks whether or not the test documentation has been gathered successfully.
   * <p>
   * This is a simple implementation that checks, whether there is accessible
   * information stored either in the JMX bean or a singleton index of serialized
   * files.
   * </p>
   */
  public class IndexProvider
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * The logger to use.
     */
    private final Logger log = LoggerFactory.getLogger(IndexProvider.class);
  
    // --- members --------------------------------------------------------------
  
    /**
     * The name of the JMX bean that provides access to the generated index.
     */
    private final ObjectName jmxObjectName;
  
    /**
     * The location where the serialized files with test doc information is
     * expected.
     */
    private final File serializedRootDir;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Convenience constructor using JMX object name
     * {@link JmxExportAdapterClient#OBJECT_NAME}.
     *
     * @param serializedRootDir the location where the serialized files with test
     *          doc information is expected.
     * @throws NullPointerException if <code>serDir</code> is <code>null</code>.
     */
    public IndexProvider(final String serializedRootDir)
      throws NullPointerException
    {
      this(JmxExportAdapterClient.OBJECT_NAME, serializedRootDir);
    }
  
    /**
     * Default constructor.
     *
     * @param jmxObjectName the name of the JMX bean that provides acces to the
     *          generated index.
     * @param serializedRootDir the location where the serialized files with test
     *          doc information is expected.
     * @throws IllegalStateException if the <code>jmxObjectName</code> is not
     *           valid.
     * @throws NullPointerException if the <code>jmxObjectName</code> or
     *           <code>serDir</code> is <code>null</code>.
    */
   public IndexProvider(final String jmxObjectName,
       final String serializedRootDir) throws NullPointerException
   {
     try
     {
       this.jmxObjectName = new ObjectName(jmxObjectName);
       this.serializedRootDir = new File(serializedRootDir);
     }
     catch (final MalformedObjectNameException e)
     {
       throw new IllegalStateException("Illegal JMX name: " + jmxObjectName, e);
     }
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   private boolean isJmxBeanRegistered()
   {
     final MBeanServer server = ManagementFactory.getPlatformMBeanServer();
     final boolean registered = server.isRegistered(jmxObjectName);
     return registered;
   }
 
   private UnitTestDocIndex getIndexIndexFromJmxBean()
   {
     final MBeanServer server = ManagementFactory.getPlatformMBeanServer();
     final JmxExportAdapterMBean exportAdapter =
         JMX.newMBeanProxy(server, jmxObjectName, JmxExportAdapterMBean.class);
     final UnitTestDocIndex index = readIndex(exportAdapter);
     return index;
   }
 
   private UnitTestDocIndex readIndex(final JmxExportAdapterMBean exportAdapter)
   {
     try
     {
       final ObjectInputStream in = exportAdapter.getIndexOnStream();
       if (in != null)
       {
         final UnitTestDocIndex index = (UnitTestDocIndex) in.readObject();
         return index;
       }
       return null;
     }
     catch (final IOException e)
     {
       if (log.isDebugEnabled())
       {
         log.debug("Reading the index from the JMX bean failed.", e);
       }
       return null;
     }
     catch (final ClassNotFoundException e)
     {
       if (log.isDebugEnabled())
       {
         log.debug("Reading the index from the JMX bean failed.", e);
       }
       return null;
     }
   }
 
   private UnitTestDocIndex readIndex()
   {
     final UnitTestDocIndex index = new UnitTestDocIndex(); // GlobalUnitTestDocIndex.getIndex();
     if (isJmxBeanRegistered())
     {
       return getIndexIndexFromJmxBean();
     }
     else if (isSerializedIndexProvided())
     {
       final Collection<File> serFiles = fetchSerFiles(serializedRootDir);
       final PersistenceUtils persist = new PersistenceUtils();
 
       for (final File serFile : serFiles)
       {
         final UnitTestDoc testDoc = (UnitTestDoc) persist.deserialize(serFile);
         index.register(testDoc);
       }
     }
     if (index.isEmpty())
     {
       if (log.isInfoEnabled())
       {
         log.info("No index found. Nothing to render to the testdoc report.");
       }
       return null;
     }
 
     return index;
   }
 
   private Collection<File> fetchSerFiles(final File baseDir)
   {
     return FileUtils.listFiles(baseDir, new String[]
     { "ser" }, true);
   }
 
   private boolean isSerializedIndexProvided()
   {
     return serializedRootDir.exists() && serializedRootDir.list().length > 0;
   }
 
   /**
    * Creates the helper that essentially encapsulates the index of test
    * documentation.
    *
    * @param config the configuration to be used by the helper.
    * @return the created helper instance.
    */
   public TestDocHelper createHelper(final ReportConfig config)
   {
     final UnitTestDocIndex index = readIndex();
     return new TestDocHelper(index, config);
   }
 
   // --- object basics --------------------------------------------------------
 
 }