/*
    * Copyright 2012-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.resource.maven.repository;
  
  import java.io.BufferedInputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.List;
  import java.util.logging.Logger;
  
  import org.apache.commons.io.IOUtils;
  import org.apache.maven.settings.Mirror;
  import org.apache.maven.settings.Server;
  import org.apache.maven.settings.Settings;
  import org.apache.maven.settings.io.xpp3.SettingsXpp3Reader;
  import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
  import org.sonatype.aether.graph.DependencyFilter;
  import org.sonatype.aether.repository.Authentication;
  import org.sonatype.plexus.components.cipher.DefaultPlexusCipher;
  import org.sonatype.plexus.components.cipher.PlexusCipherException;
  import org.sonatype.plexus.components.sec.dispatcher.DefaultSecDispatcher;
  import org.sonatype.plexus.components.sec.dispatcher.SecUtil;
  import org.sonatype.plexus.components.sec.dispatcher.model.SettingsSecurity;
  
  import de.smartics.properties.resource.repository.RepositoryException;
  
  /**
   * Builds {@link MavenRepository} based on information found in a
   * <code>settings.xml</code>.
   */
  final class SettingsMavenRepoBuilder
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * Reference to the logger for this instance.
     */
    private final Logger log = Logger.getLogger(SettingsMavenRepoBuilder.class
        .getName());
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    /**
     * Creates an instance of the maven repository based on the given settings
     * file.
     *
     * @param settingsName the file name of the <code>settings.xml</code> file to
     *          read.
     * @return the instance.
     * @throws RepositoryException if the settings cannot be read to create an
     *           instance of a resource repository successfully.
     */
    public MavenRepository build(final String settingsName,
        final List<DependencyFilter> filters) throws RepositoryException
    {
      final File settingsFile = new File(settingsName);
      if (settingsFile.canRead())
      {
        InputStream input = null;
  
        try
        {
          input = new BufferedInputStream(new FileInputStream(settingsFile));
          final SettingsXpp3Reader reader = new SettingsXpp3Reader();
          final Settings settings = reader.read(input);
          return createRepository(settingsFile, settings, filters);
        }
       catch (final FileNotFoundException e)
       {
         throw new RepositoryException(new FileMessageBean(
             MavenResourceCode.CANNOT_FIND_SETTINGS, e, settingsFile));
       }
       catch (final IOException e)
       {
         throw new RepositoryException(new FileMessageBean(
             MavenResourceCode.CANNOT_READ_SETTINGS, e, settingsFile));
       }
       catch (final XmlPullParserException e)
       {
         throw new RepositoryException(new FileMessageBean(
             MavenResourceCode.CANNOT_READ_SETTINGS, e, settingsFile));
       }
       finally
       {
         IOUtils.closeQuietly(input);
       }
     }
     throw new RepositoryException(new FileMessageBean(
         MavenResourceCode.CANNOT_FIND_SETTINGS, settingsFile));
   }
 
   private MavenRepository createRepository(final File settingsFile,
       final Settings settings, final List<DependencyFilter> filters)
   {
     final String localRepositoryPath = settings.getLocalRepository();
     final List<Mirror> mirrors = settings.getMirrors();
     final String remoteRepositoryUrl;
     Authentication auth = null;
     if (!mirrors.isEmpty())
     {
       final Mirror mirror = mirrors.get(0);
       remoteRepositoryUrl = mirror.getUrl();
       final Server server = settings.getServer(mirror.getId());
       if (server != null)
       {
         final String password =
             decodePassword(settingsFile, server.getPassword());
         auth =
             new Authentication(server.getUsername(), password,
                 server.getPrivateKey(), server.getPassphrase());
       }
     }
     else
     {
       remoteRepositoryUrl = null;
     }
 
     final boolean offline = settings.isOffline();
 
     return new MavenRepository(remoteRepositoryUrl, auth, localRepositoryPath,
         filters, offline);
   }
 
   private File createSettingsSecurityFile(final File settingsFile)
   {
     final File file =
         new File(settingsFile.getParentFile(), "settings-security.xml");
     return file;
   }
 
   private String decodePassword(final File settingsFile,
       final String possiblyEncodedPassword)
   {
     if (!isEncoded(possiblyEncodedPassword))
     {
       return possiblyEncodedPassword;
     }
 
     final File settingsSecurityFile = createSettingsSecurityFile(settingsFile);
 
     if (settingsSecurityFile.exists())
     {
       try
       {
         final SettingsSecurity security =
             SecUtil.read(settingsSecurityFile.getAbsolutePath(), true);
         final String encodedMasterPassword = security.getMaster();
         final String plainTextMasterPassword =
             decodePassword(encodedMasterPassword,
                 DefaultSecDispatcher.SYSTEM_PROPERTY_SEC_LOCATION);
         final String decodedPassword =
             decodePassword(possiblyEncodedPassword, plainTextMasterPassword);
         return decodedPassword;
       }
       catch (final Exception e)
       {
         log.warning("Cannot decrypt passwords in settings.xml:"
                     + e.getMessage());
       }
     }
     return possiblyEncodedPassword;
   }
 
   private boolean isEncoded(final String possiblyEncodedPassword)
   {
     if (possiblyEncodedPassword == null)
     {
       return false;
     }
 
     final int length = possiblyEncodedPassword.length();
     return length > 2 && possiblyEncodedPassword.charAt(0) == '{'
            && possiblyEncodedPassword.charAt(length - 1) == '}';
   }
 
   private static String decodePassword(final String encodedPassword,
       final String key) throws PlexusCipherException
   {
     final DefaultPlexusCipher cipher = new DefaultPlexusCipher();
     return cipher.decryptDecorated(encodedPassword, key);
   }
 
   // --- object basics --------------------------------------------------------
 
 }