/*
    * #%L
    * wcm.io
    * %%
    * Copyright (C) 2019 wcm.io
    * %%
    * 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.
   * #L%
   */
  package io.wcm.qa.glnm.persistence;
  
  import java.io.File;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.Reader;
  import java.io.Writer;
  
  import org.apache.commons.configuration2.PropertiesConfiguration;
  import org.apache.commons.configuration2.builder.fluent.Configurations;
  import org.apache.commons.configuration2.ex.ConfigurationException;
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.lang3.ClassPathUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import io.wcm.qa.glnm.configuration.GaleniumConfiguration;
  
  final class PersistenceUtil {
  
    private static final Logger LOG = LoggerFactory.getLogger(PersistenceUtil.class);
  
    private static final String POSTFIX_PROPERTIES = "properties";
  
    private PersistenceUtil() {
      // do not instantiate
    }
  
    private static File getOutputFile(Class clazz) {
      String resourceName = getPropertiesResourceName(clazz);
      File outputFile = getOutputFile(clazz, resourceName);
      return outputFile;
    }
  
    private static File getOutputFile(Class clazz, String resourceName) {
      String relativePath = ClassPathUtils.toFullyQualifiedPath(clazz, resourceName);
      String textOutputDirectory = GaleniumConfiguration.getTextComparisonOutputDirectory();
      File outputFile = FileUtils.getFile(textOutputDirectory, relativePath);
      return outputFile;
    }
  
    private static String getPropertiesResourceName(Class clazz) {
      String resourceName = clazz.getSimpleName() + "." + POSTFIX_PROPERTIES;
      if (LOG.isDebugEnabled()) {
        LOG.debug("properties resource name: " + resourceName);
      }
      return resourceName;
    }
  
    private static Reader getReaderForProperties(Class clazz) {
      InputStream in = clazz.getResourceAsStream(getPropertiesResourceName(clazz));
      if (in == null) {
        return null;
      }
      return new InputStreamReader(in);
    }
  
    @SuppressWarnings("PMD.AvoidCatchingNPE")
    static PropertiesConfiguration getPropertiesFor(Class clazz) {
  
      try {
        PropertiesConfiguration configuration = new Configurations().propertiesBuilder().getConfiguration();
        Reader readerForProperties = getReaderForProperties(clazz);
        if (readerForProperties != null) {
          configuration.read(readerForProperties);
        }
        return configuration;
      }
      catch (ConfigurationException | IOException ex) {
        // notify, but still return empty properties
        if (LOG.isInfoEnabled()) {
          LOG.info("Could not load properties for: " + clazz, ex);
        }
        return new PropertiesConfiguration();
      }
    }
  
    static void writeSamplesForClass(PropertiesConfiguration samples, Class clazz) {
     Writer writer = null;
     try {
       File outputFile = getOutputFile(clazz);
       if (LOG.isInfoEnabled()) {
         LOG.info("writing {} properties to '{}'", samples.size(), outputFile.getPath());
       }
       FileUtils.forceMkdirParent(outputFile);
       writer = new FileWriter(outputFile, false);
       // TODO: refactor to use FileHandler
       samples.write(writer);
     }
     catch (IOException | ConfigurationException ex) {
       LOG.error("could not persist samples.", ex);
     }
     finally {
       if (writer != null) {
         try {
           writer.close();
         }
         catch (IOException ex) {
           LOG.error("when closing writer while persisting samples.", ex);
         }
       }
     }
   }
 
 }