package com.atlassian.amps.sdk.mpac;
   
   import java.io.IOException;
   import java.net.PasswordAuthentication;
   import java.net.URI;
   import java.text.MessageFormat;
   import java.util.ArrayList;
   import java.util.List;
   
  import com.atlassian.amps.sdk.util.PropertiesReader;
  import com.atlassian.jira.rest.client.api.JiraRestClient;
  import com.atlassian.jira.rest.client.api.domain.Issue;
  import com.atlassian.jira.rest.client.api.domain.SearchResult;
  import com.atlassian.jira.rest.client.internal.async.AsynchronousJiraRestClientFactory;
  import com.atlassian.marketplace.client.HttpConfiguration;
  import com.atlassian.marketplace.client.MpacException;
  import com.atlassian.marketplace.client.api.PluginDetailQuery;
  import com.atlassian.marketplace.client.api.PluginVersionUpdate;
  import com.atlassian.marketplace.client.impl.DefaultMarketplaceClient;
  import com.atlassian.marketplace.client.model.LicenseIdentifier;
  import com.atlassian.marketplace.client.model.Plugin;
  import com.atlassian.marketplace.client.model.PluginVersion;
  import com.atlassian.upm.api.util.Option;
  
  import org.apache.commons.lang.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Created by Lucas Le on 5 Aug 2015.
   */
  public class MpacPublisher
  {
      final private static Logger LOG = LoggerFactory.getLogger(MpacPublisher.class);
  
      final public static String MPAC_STAGING_SERVER = "https://mpac-5.dev.internal.atlassian.com/";
      final public static String MPAC_PRODUCTION_SERVER = "https://marketplace.atlassian.com/";
      final public static String JIRA_SERVER_URL = "https://ecosystem.atlassian.net/";
      final private String[] sdkPluginKeys = new String[] { "mac", "tgz", "windows", "rpm", "deb" };
      final private static URI JIRA_SERVER_URI = URI.create(JIRA_SERVER_URL);
      final private static URI MPAC_STAGING_SERVER_URI = URI.create(MPAC_STAGING_SERVER);
      final private static URI MPAC_PRODUCTION_SERVER_URI = URI.create(MPAC_PRODUCTION_SERVER);
      private DefaultMarketplaceClient mpacClient;
      final private PropertiesReader releaseProperties;
  
      final private PasswordAuthentication mpacCredentials;
      final private PasswordAuthentication ecoCredentials;
      final private String version;
      private String releaseNotes;
  
      private MpacPublisher(final PasswordAuthentication mpacCredentials, final PasswordAuthentication ecoCredentials, final String version)
              throws IOException
      {
          this.mpacCredentials = mpacCredentials;
          this.ecoCredentials = ecoCredentials;
          this.version = version;
          this.releaseProperties = PropertiesReader.getInstance();
      }
  
      public void publish() throws IOException, MpacException
      {
              mpacClient = initializeMpacClient();
              final List<SDKPlugin> sdkPlugins = processSdkPlugins();
              for (SDKPlugin sdkPlugin : sdkPlugins)
              {
                  releaseNewPluginVersion(sdkPlugin);
              }
      }
  
      private List<SDKPlugin> processSdkPlugins()
      {
          final List<SDKPlugin> sdkPlugins = new ArrayList<SDKPlugin>(5);
          for (int i = 0; i < sdkPluginKeys.length; i++)
          {
              final SDKPlugin sdkPlugin = SDKPlugin.SDKPluginBuilder
                      .aSDKPlugin()
                      .name("atlassian-plugin-sdk-" + sdkPluginKeys[i])
                      .binaryURI(formatURI(releaseProperties.getBinaryURI(sdkPluginKeys[i])))
                      .build();
              sdkPlugins.add(sdkPlugin);
          }
          return sdkPlugins;
      }
  
      private String formatURI(String uri)
      {
          LOG.debug(uri);
          return MessageFormat.format(uri, version);
      }
  
      private String initializeReleaseNotes(final String latestAmpsVersion, final String newAmpsVersion,
              final String latestSdkVersion, final String newSdkVersion) throws IOException
      {
          final AsynchronousJiraRestClientFactory factory = new AsynchronousJiraRestClientFactory();
          final JiraRestClient restClient = factory.createWithBasicHttpAuthentication(JIRA_SERVER_URI,
                  ecoCredentials.getUserName(), ecoCredentials.getPassword().toString());
          final String query = MessageFormat.format("(project IN (AMPS, AMPSDEV) and status = resolved and fixVersion > {0} and fixVersion <= {1}) "
                          + "or (project IN (ATLASSDK ) and status = resolved and fixVersion > {2} and fixVersion <= {3})",
                  latestAmpsVersion, newAmpsVersion,
                 latestSdkVersion, newSdkVersion);
         LOG.debug("initializeReleaseNotes query: " + query);
         final StringBuilder releaseNotes = new StringBuilder();
         final SearchResult searchResult = restClient.getSearchClient().searchJql(query).claim();
         for (Issue issue : searchResult.getIssues())
         {
             releaseNotes.append("<p>");
             releaseNotes.append(issue.getKey());
             releaseNotes.append(": ");
             releaseNotes.append(issue.getSummary());
             releaseNotes.append("</p>");
         }
         restClient.close();
         return releaseNotes.toString();
     }
 
     private DefaultMarketplaceClient initializeMpacClient()
     {
         final HttpConfiguration myHttpConfiguration = HttpConfiguration.builder()
                 .username(mpacCredentials.getUserName())
                 .password(mpacCredentials.getPassword().toString())
                 .connectTimeoutMillis(300000)
                 .build();
         final URI serverURI = releaseProperties.isReleaseProduction() ? MPAC_PRODUCTION_SERVER_URI : MPAC_STAGING_SERVER_URI;
         final DefaultMarketplaceClient defaultMarketplaceClient = new DefaultMarketplaceClient(serverURI, myHttpConfiguration);
         return defaultMarketplaceClient;
     }
 
     private void releaseNewPluginVersion(final SDKPlugin sdkPlugin) throws MpacException, IOException
     {
         final Option<Plugin> sdkPlugins = mpacClient.plugins().get(PluginDetailQuery.builder(sdkPlugin.getName()).build());
         final Plugin sdk = sdkPlugins.get();
         final PluginVersion latestPluginVersion = sdk.getVersion();
         if (!version.equals(latestPluginVersion.getVersion()))
         {
             if(StringUtils.isEmpty(releaseNotes))
             {
                 try
                 {
                     releaseNotes = initializeReleaseNotes(releaseProperties.getAMPSLatestVersion(),
                             releaseProperties.getAMPSCurrentVersion(),
                             latestPluginVersion.getVersion(),
                             version);
                 }catch(IOException io)
                 {
                     throw new IOException("Could not generate release notes, please check your Ecosystem again", io);
                 }
             }
             LOG.debug("Create new version for plugin: " + sdkPlugin.getName() + " - binary URI: " + sdkPlugin.getBinaryURI());
             LOG.debug("Release summary:\n " + releaseSummary());
             LOG.debug("Release notes:\n " + releaseNotes);
             PluginVersionUpdate newVersionData = PluginVersionUpdate.newVersion(
                     sdkPlugin.getName(),
                     latestPluginVersion.getBuildNumber() + 10,
                     version,
                     PluginVersionUpdate.Deployment
                             .nonDeployable(URI.create(sdkPlugin.getBinaryURI())),
                     LicenseIdentifier.ASL
             ).summary(Option.some(releaseSummary()))
                     .releaseNotes(Option.some(releaseNotes))
                     .build();
             mpacClient.plugins().putVersion(newVersionData);
         }
     }
 
     private String releaseSummary()
     {
         return MessageFormat.format(releaseProperties.getReleaseSummary(),
                 version,
                 releaseProperties.getAMPSCurrentVersion());
     }
 
     public static class MpacPublisherBuilder
     {
         private PasswordAuthentication mpacCredentials;
         private PasswordAuthentication ecoCredentials;
         private String version;
 
         private MpacPublisherBuilder()
         {
         }
 
         public static MpacPublisherBuilder aMpacPublisher()
         {
             return new MpacPublisherBuilder();
         }
 
         public MpacPublisherBuilder mpacCredentials(PasswordAuthentication mpacCredentials)
         {
             this.mpacCredentials = mpacCredentials;
             return this;
         }
 
         public MpacPublisherBuilder ecoCredentials(PasswordAuthentication ecoCredentials)
         {
             this.ecoCredentials = ecoCredentials;
             return this;
         }
 
         public MpacPublisherBuilder version(String version)
         {
             this.version = version;
             return this;
         }
 
         public MpacPublisherBuilder but()
         {
             return aMpacPublisher().mpacCredentials(mpacCredentials).ecoCredentials(ecoCredentials).version(version);
         }
 
         public MpacPublisher build() throws IOException
         {
             MpacPublisher mpacPublisher = new MpacPublisher(mpacCredentials, ecoCredentials, version);
             return mpacPublisher;
         }
     }
 }