/*
    * Copyright 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.properties.config.transfer.templatestream;
  
  import java.io.PrintWriter;
  
  import org.apache.commons.lang.StringUtils;
  
  import de.smartics.properties.api.config.domain.Property;
  import de.smartics.properties.api.config.domain.PropertyProvider;
  import de.smartics.properties.api.config.domain.key.ConfigurationKey;
  import de.smartics.properties.api.config.transfer.PropertySink;
  import de.smartics.properties.api.config.transfer.TransferException;
  import de.smartics.util.lang.Arg;
  
  /**
   * Writes properties to a folder.
   */
  public final class StreamPropertySink implements PropertySink
  { // NOPMD
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The wrapper for the whole document to be written to the stream.
     */
    private final Wrapper documentWrapper;
  
    /**
     * The wrapper for a single line.
     */
    private final Wrapper lineWrapper;
  
    /**
     * The template to apply on each property.
     */
    private final String template;
  
    /**
     * The stream to write to. The stream is closed by calling {@link #close()} by
     * the client.
     */
    private final PrintWriter stream;
  
    /**
     * The escaper for config key, property name and value.
     */
    private final ValueEscaper escaper;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Convenience constructor using a default table descriptor with no wrappers.
     * <p>
     * The stream is closed by calling {@link #close()} by the client.
     * </p>
     *
     * @param template the template to apply on each property.
     * @param stream the stream to write to.
     * @param escaper the escaper for config key, property name and value.
     * @throws NullPointerException if {@code template} or {@code stream} is
     *           <code>null</code>.
     * @throws IllegalArgumentException if {@code template} is blank.
     */
    public StreamPropertySink(final String template, final PrintWriter stream,
        final ValueEscaper escaper) throws NullPointerException,
      IllegalArgumentException
    {
      this(null, template, stream, escaper);
    }
  
    /**
     * Convenience constructor with no wrappers.
     * <p>
     * The stream is closed by calling {@link #close()} by the client.
     * </p>
     *
     * @param descriptor the descriptor for table and column names to store
     *          property values.
     * @param template the template to apply on each property.
     * @param stream the stream to write to.
    * @param escaper the escaper for config key, property name and value.
    * @throws NullPointerException if {@code template} or {@code stream} is
    *           <code>null</code>.
    * @throws IllegalArgumentException if {@code template} is blank.
    */
   public StreamPropertySink(final TableDescriptor descriptor,
       final String template, final PrintWriter stream,
       final ValueEscaper escaper) throws NullPointerException,
     IllegalArgumentException
   {
     this(descriptor, null, null, template, stream, escaper);
   }
 
   /**
    * Default constructor.
    * <p>
    * The stream is closed by calling {@link #close()} by the client.
    * </p>
    *
    * @param descriptor the descriptor for table and column names to store
    *          property values.
    * @param documentWrapper the introduction to write to the stream at the
    *          start.
    * @param lineWrapper the text to write to the stream at the end before
    *          closing the stream.
    * @param template the template to apply on each property.
    * @param stream the stream to write to.
    * @param escaper the escaper for config key, property name and value.
    * @throws NullPointerException if {@code template} , {@code stream} , or
    *           {@escaper} is <code>null</code>.
    * @throws IllegalArgumentException if {@code template} is blank.
    */
   public StreamPropertySink(final TableDescriptor descriptor,
       final Wrapper documentWrapper, final Wrapper lineWrapper,
       final String template, final PrintWriter stream,
       final ValueEscaper escaper) throws NullPointerException,
     IllegalArgumentException
   {
     final TableDescriptor desc = createDescriptor(descriptor);
     this.documentWrapper = createWrapper(documentWrapper);
     this.lineWrapper = createWrapper(lineWrapper);
     this.template =
         applyStandardAndDescriptor(desc,
             Arg.checkNotBlank("template", template));
     this.stream = Arg.checkNotNull("stream", stream);
     this.escaper = Arg.checkNotNull("escaper", escaper);
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   private static Wrapper createWrapper(final Wrapper wrapper)
   {
     final Wrapper norm = wrapper == null ? new Wrapper() : wrapper;
 
     norm.setIntro(applyStandard(norm.getIntro()));
     norm.setExtro(applyStandard(norm.getExtro()));
 
     return norm;
   }
 
   private static TableDescriptor createDescriptor(
       final TableDescriptor descriptor)
   {
     if (descriptor != null)
     {
       return descriptor;
     }
     return new TableDescriptor.Builder().build();
   }
 
   private static String applyStandard(final String template)
   {
     final String applied =
         StringUtils.replaceEach(template, new String[] { "${newline}" },
             new String[] { "\n" });
     return applied;
   }
 
   private static String applyStandardAndDescriptor(
       final TableDescriptor descriptor, final String template)
   {
     final String applied =
         StringUtils.replaceEach(
             template,
             new String[] { "${newline}", "${table}", "${configColumn}",
                           "${nameColumn}", "${valueColumn}" },
             new String[] { "\n", descriptor.getTable(),
                           descriptor.getConfigColumn(),
                           descriptor.getNameColumn(),
                           descriptor.getValueColumn() });
     return applied;
   }
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * {@inheritDoc}
    * <p>
    * This implementation is a no-op since a stream cannot be cleared.
    * </p>
    */
   @Override
   public void clear() throws TransferException
   {
   }
 
   @Override
   public void write(final PropertyProvider provider) throws TransferException
   {
     writeDocumentIntro();
     writeOne(provider);
     writeDocumentExtro();
   }
 
   private void writeDocumentIntro()
   {
     final String intro = documentWrapper.getIntro();
     if (intro != null)
     {
       stream.write(intro);
     }
   }
 
   private void writeDocumentExtro()
   {
     final String extro = documentWrapper.getExtro();
     if (extro != null)
     {
       stream.write(extro);
     }
   }
 
   private void writeOne(final PropertyProvider provider)
   {
     final String intro = lineWrapper.getIntro();
     if (intro != null)
     {
       final String location = String.valueOf(provider.getSourceId());
       final String line =
           StringUtils.replaceEach(intro, new String[] { "${location}" },
               new String[] { location });
       stream.write(line);
     }
 
     final ConfigurationKey<?> configKey = provider.getConfigurationKey();
     final String key = escaper.escape(configKey.toString());
 
     for (final Property property : provider.getProperties())
     {
       final String line = applyTemplate(key, property);
       stream.write(line);
     }
 
     final String extro = lineWrapper.getExtro();
     if (extro != null)
     {
       stream.write(extro);
     }
   }
 
   private String applyTemplate(final String escapedKey, final Property property)
   {
     final String name = escaper.escape(property.getName());
     final String value = escaper.escape(property.getValue());
     final String line =
         StringUtils.replaceEach(template,
             new String[] { "${configKey}", "${name}", "${value}" },
             new String[] { escapedKey, name, value });
     return line;
   }
 
   @Override
   public void write(final Iterable<PropertyProvider> providers)
     throws TransferException
   {
     writeDocumentIntro();
 
     for (final PropertyProvider provider : providers)
     {
       writeOne(provider);
     }
 
     writeDocumentExtro();
   }
 
   /**
    * {@inheritDoc}
    * <p>
    * This is a no-op.
    * </p>
    */
   @Override
   public void close() throws TransferException
   {
     stream.close();
   }
 
   // --- object basics --------------------------------------------------------
 
 }