/*
    * 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.jboss.extension.resources.components;
  
  import static javax.xml.stream.XMLStreamConstants.END_ELEMENT;
  
  import javax.xml.stream.XMLStreamException;
  
  import org.jboss.as.controller.AttributeDefinition;
  import org.jboss.as.controller.OperationFailedException;
  import org.jboss.as.controller.OperationStepHandler;
  import org.jboss.as.controller.SimpleAttributeDefinition;
  import org.jboss.as.controller.SimpleAttributeDefinitionBuilder;
  import org.jboss.as.controller.parsing.ParseUtils;
  import org.jboss.as.controller.registry.AttributeAccess;
  import org.jboss.as.controller.registry.ManagementResourceRegistration;
  import org.jboss.dmr.ModelNode;
  import org.jboss.dmr.ModelType;
  import org.jboss.staxmapper.XMLExtendedStreamReader;
  import org.jboss.staxmapper.XMLExtendedStreamWriter;
  
  import de.smartics.properties.api.core.security.SecurityConfiguration;
  import de.smartics.properties.spi.config.config.PropertiesConfiguration;
  
  /**
   * Defines the security information of a configuration. This information allows
   * to encrypt and decrypt property values.
   * <p>
   * Example XML fragment of a security element within a configuration:
   * </p>
   *
   * <pre>
   * {@markupExample "Security Element"
   * &lt;security&gt;
   *   &lt;algorithm&gt;AES&lt;/algorithm&gt;
   *   &lt;transformation&gt;AES/ECB/PKCS5Padding&lt;/transformation&gt;
   *   &lt;!-- provider / --&gt;
   *   &lt;key&gt;+pvrmeQCmtWmYVOZ57uuIQ==&lt;/key&gt;
   * &lt;/security&gt;}
   * </pre>
   */
  public final class SecurityComponent extends AbstractComponent
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * The name of the configuration XML element that holds the security
     * information.
     * <p>
     * The value of this constant is {@value}.
     * </p>
     */
    public static final String ROOT_ELEMENT_NAME = "security";
  
    /**
     * The attribute that holds the security algorithm.
     */
    public static final SimpleAttributeDefinition ALGORITHM =
        new SimpleAttributeDefinitionBuilder("security.algorithm",
            ModelType.STRING, true).setXmlName("algorithm")
            .setAllowExpression(true)
            .setFlags(AttributeAccess.Flag.RESTART_ALL_SERVICES).build();
  
    /**
     * The attribute that holds the security transformation.
     */
    public static final SimpleAttributeDefinition TRANSFORMATION =
        new SimpleAttributeDefinitionBuilder("security.transformation",
            ModelType.STRING, true).setXmlName("transformation")
            .setAllowExpression(true)
            .setFlags(AttributeAccess.Flag.RESTART_ALL_SERVICES).build();
  
    /**
     * The attribute that holds the security provider.
     */
    public static final SimpleAttributeDefinition PROVIDER =
        new SimpleAttributeDefinitionBuilder("security.provider",
            ModelType.STRING, true).setXmlName("provider")
            .setAllowExpression(true)
            .setFlags(AttributeAccess.Flag.RESTART_ALL_SERVICES).build();
  
    /**
     * The attribute that holds the security key.
     */
   public static final SimpleAttributeDefinition KEY =
       new SimpleAttributeDefinitionBuilder("security.key", ModelType.STRING,
           true).setXmlName("key").setAllowExpression(true)
           .setFlags(AttributeAccess.Flag.RESTART_ALL_SERVICES).build();
 
   private static final AttributeDefinition[] DEFINITIONS = { ALGORITHM,
                                                             TRANSFORMATION,
                                                             PROVIDER, KEY };
 
   // --- members --------------------------------------------------------------
 
   // ****************************** Initializer *******************************
 
   // ****************************** Constructors ******************************
 
   /**
    * Default constructor.
    */
   public SecurityComponent(final OperationStepHandler writeHandler)
   {
     super(writeHandler);
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   public void registerAttributes(
       final ManagementResourceRegistration resourceRegistration)
   {
     resourceRegistration.registerReadWriteAttribute(ALGORITHM, null,
         writeHandler);
     resourceRegistration.registerReadWriteAttribute(TRANSFORMATION, null,
         writeHandler);
     resourceRegistration.registerReadWriteAttribute(PROVIDER, null,
         writeHandler);
     resourceRegistration.registerReadWriteAttribute(KEY, null, writeHandler);
   }
 
   public void populateModel(final ModelNode operation, final ModelNode model)
     throws OperationFailedException
   {
     ALGORITHM.validateAndSet(operation, model);
     TRANSFORMATION.validateAndSet(operation, model);
     PROVIDER.validateAndSet(operation, model);
     KEY.validateAndSet(operation, model);
   }
 
   public void read(final XMLExtendedStreamReader reader,
       final ModelNode addOperation) throws XMLStreamException
   {
     ParseUtils.requireNoAttributes(reader);
 
     while (reader.hasNext() && reader.nextTag() != END_ELEMENT)
     {
       if (reader.isStartElement())
       {
         final String localName = reader.getLocalName();
 
         if (SecurityComponent.ALGORITHM.getXmlName().equals(localName))
         {
           readAttribute(reader, addOperation, SecurityComponent.ALGORITHM);
         }
         else if (SecurityComponent.TRANSFORMATION.getXmlName()
             .equals(localName))
         {
           readAttribute(reader, addOperation, SecurityComponent.TRANSFORMATION);
         }
         else if (SecurityComponent.PROVIDER.getXmlName().equals(localName))
         {
           readAttribute(reader, addOperation, SecurityComponent.PROVIDER);
         }
         else if (SecurityComponent.KEY.getXmlName().equals(localName))
         {
           readAttribute(reader, addOperation, SecurityComponent.KEY);
         }
         else
         {
           throw ParseUtils.unexpectedElement(reader);
         }
       }
     }
   }
 
   public void write(final XMLExtendedStreamWriter writer, final ModelNode config)
     throws XMLStreamException
   {
     if (isAtLeastOneDefined(config, DEFINITIONS))
     {
       writer.writeStartElement(SecurityComponent.ROOT_ELEMENT_NAME);
 
       for (final AttributeDefinition definition : DEFINITIONS)
       {
         writeAttribute(writer, config, definition);
       }
 
       writer.writeEndElement();
     }
   }
 
   public void apply(final PropertiesConfiguration propertiesConfig,
       final ModelNode model)
   {
     final SecurityConfiguration securityConfig =
         propertiesConfig.getSecurityConfiguration();
 
     final String algorithm = getAttribute(model, ALGORITHM);
     securityConfig.setAlgorithm(algorithm);
 
     final String transformation = getAttribute(model, TRANSFORMATION);
     securityConfig.setTransformation(transformation);
 
     final String provider = getAttribute(model, PROVIDER);
     securityConfig.setProvider(provider);
 
     final String key = getAttribute(model, KEY);
     securityConfig.setKey(key);
   }
 
   // --- object basics --------------------------------------------------------
 
 }