package org.kuali.common.devops.jenkins.upgrade;
   
   import static com.google.common.base.Preconditions.checkState;
   import static java.lang.Integer.parseInt;
   import static java.lang.String.format;
   import static java.lang.System.currentTimeMillis;
   import static org.apache.commons.lang3.StringUtils.isNotBlank;
   import static org.kuali.common.aws.model.AWS.decryptedCopy;
   import static org.kuali.common.devops.aws.EncryptedAWSCredentials.ENCRYPTED_AWS_CREDENTIALS_FOUNDATION;
  import static org.kuali.common.devops.jenkins.upgrade.Jenkins.archiveBuildsToS3;
  import static org.kuali.common.devops.jenkins.upgrade.Jenkins.buildJenkinsSummary;
  import static org.kuali.common.devops.jenkins.upgrade.Jenkins.persistAndThenRead;
  import static org.kuali.common.devops.jenkins.upgrade.Jenkins.restore;
  import static org.kuali.common.devops.jenkins.upgrade.JenkinsCommand.REPORTING;
  import static org.kuali.common.devops.jenkins.upgrade.JenkinsCommand.RESTORE;
  import static org.kuali.common.devops.jenkins.upgrade.JenkinsCommand.UPLOAD;
  import static org.kuali.common.devops.jenkins.upgrade.JenkinsReporting.doReporting;
  import static org.kuali.common.util.FormatUtils.dateAsString;
  import static org.kuali.common.util.FormatUtils.getMillis;
  import static org.kuali.common.util.FormatUtils.getTime;
  import static org.kuali.common.util.base.Exceptions.illegalArgument;
  import static org.kuali.common.util.encrypt.Encryption.getDefaultEncryptor;
  import static org.kuali.common.util.log.Loggers.newLogger;
  
  import java.nio.file.Path;
  import java.nio.file.Paths;
  
  import org.junit.Test;
  import org.kuali.common.aws.s3.DefaultS3Service;
  import org.kuali.common.aws.s3.S3Service;
  import org.kuali.common.core.cli.api.CommandLineService;
  import org.kuali.common.core.cli.plexus.PlexusCLIService;
  import org.kuali.common.core.json.api.JsonService;
  import org.kuali.common.core.json.jackson.JacksonJsonService;
  import org.kuali.common.core.system.VirtualSystem;
  import org.kuali.common.devops.jenkins.upgrade.model.JenkinsSummary;
  import org.slf4j.Logger;
  
  import com.amazonaws.auth.AWSCredentials;
  import com.google.common.base.Splitter;
  import com.google.common.base.Stopwatch;
  
  public class JenkinsScanner {
  
      private static final Logger logger = newLogger();
  
      @Test
      public void test() {
          try {
              VirtualSystem vs = VirtualSystem.build();
              JsonService service = new JacksonJsonService();
              AWSCredentials creds = decryptedCopy(getDefaultEncryptor(), ENCRYPTED_AWS_CREDENTIALS_FOUNDATION);
              S3Service s3 = DefaultS3Service.build(creds);
              JenkinsArchiveContext ctx = getContext(vs);
              CommandLineService cli = new PlexusCLIService();
              info(service, ctx);
              if (ctx.getCommand().equals(RESTORE)) {
                  restore(ctx, s3, service, cli);
              } else {
                  long now = currentTimeMillis();
                  long startedBefore = now - getMillis(ctx.getAge());
                  info("now        -> %s", dateAsString(now, ctx.getTimezone()));
                  info("cutoff     -> %s", dateAsString(startedBefore, ctx.getTimezone()));
                  Path home = Paths.get(ctx.getHome());
                  JenkinsSummary jenkins = buildJenkinsSummary(home, ctx.getTimezone(), startedBefore);
                  if (ctx.getCommand().equals(REPORTING)) {
                      doReporting(jenkins);
                  } else if (ctx.getCommand().equals(UPLOAD)) {
                      persistAndThenRead(ctx, jenkins, service, s3, now);
                      archiveBuildsToS3(ctx, jenkins, home, startedBefore, s3);
                  } else {
                      throw illegalArgument("[%s] is an unknown command", ctx.getCommand());
                  }
              }
          } catch (Throwable e) {
              e.printStackTrace();
          }
      }
  
      private static JenkinsArchiveContext getContext(VirtualSystem vs) {
          String bucket = vs.getProperty("bucket", "archive.kuali.org");
          String hostname = vs.getEnv("JENKINS_MASTER", "unit.test.kuali.org");
          String home = vs.getProperty("home", vs.getUser().getHome().getPath() + "/.jenkins");
          String stack = getStack(vs);
          String timezone = vs.getProperty("timezone", "US/Eastern");
          int threads = parseInt(vs.getProperty("threads", "5"));
          String age = vs.getProperty("age", "12h");
          AWSCredentials creds = decryptedCopy(getDefaultEncryptor(), ENCRYPTED_AWS_CREDENTIALS_FOUNDATION);
          JenkinsCommand command = JenkinsCommand.valueOf(vs.getProperty("command", "reporting").toUpperCase());
          return JenkinsArchiveContext.builder().withStack(stack).withCommand(command).withThreads(threads).withAge(age).withTimezone(timezone).withBucket(bucket)
                          .withCredentials(creds).withHome(home).withHostname(hostname).build();
      }
  
      private static String getStack(VirtualSystem vs) {
          String stack = vs.getEnv("EC2_STACK");
          if (isNotBlank(stack)) {
              return stack;
          } else {
              return vs.getProperty("stack", "dev");
         }
     }
 
     /**
      * Convert the object reference to json.
      *
      * Create a new object instance from the json and then create a new json string from the new object instance.
      *
      * Verify that the original json string and the new json string are exactly the same.
      */
     protected static <T> T checkPerfectReadWrite(JsonService json, T reference, Class<T> type) {
         String expected = json.writeString(reference);
         String actual = json.writeString(json.readString(expected, type));
         checkState(expected.equals(actual));
         return reference;
     }
 
     protected static void elapsed(Stopwatch sw) {
         info("elapsed -> %s", getTime(sw));
     }
 
     protected static <T> void info(JsonService json, T reference) {
         String text = json.writeString(reference);
         Iterable<String> lines = Splitter.on('\n').split(text);
         for (String line : lines) {
             info("%s", line);
         }
     }
 
     protected static void debug(String msg, Object... args) {
         logger.debug((args == null || args.length == 0) ? msg : format(msg, args));
     }
 
     protected static void info(String msg, Object... args) {
         logger.info((args == null || args.length == 0) ? msg : format(msg, args));
     }
 
 }