package org.kuali.common.devops.jenkins.upgrade.model;
   
   import static com.google.common.base.Optional.absent;
   import static com.google.common.base.Preconditions.checkNotNull;
   import static com.google.common.collect.Iterables.filter;
   import static com.google.common.collect.Lists.newArrayList;
   import static com.google.common.collect.Ordering.natural;
   import static java.lang.String.format;
   import static org.kuali.common.core.io.Files.buildUnixFile;
  import static org.kuali.common.core.io.Files.checkIsDir;
  import static org.kuali.common.devops.jenkins.upgrade.Jenkins.BUILDS_DIRECTORY;
  import static org.kuali.common.devops.jenkins.upgrade.Jenkins.buildNumberMap;
  import static org.kuali.common.devops.jenkins.upgrade.Jenkins.isJenkinsBuildDirectory;
  import static org.kuali.common.devops.jenkins.upgrade.Jenkins.listBuildDirContents;
  import static org.kuali.common.util.base.Precondition.checkNotBlank;
  import static org.kuali.common.util.base.Precondition.checkNotNull;
  import static org.kuali.common.util.log.Loggers.newLogger;
  
  import java.io.IOException;
  import java.nio.file.Path;
  import java.nio.file.Paths;
  import java.util.List;
  import java.util.Map;
  
  import org.kuali.common.core.io.UnixFile;
  import org.slf4j.Logger;
  
  import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
  import com.google.common.base.Optional;
  import com.google.common.base.Predicate;
  import com.google.common.collect.ImmutableList;
  
  @JsonDeserialize(builder = JobSummary.Builder.class)
  public final class JobSummary {
  
  	private static final Logger logger = newLogger();
  
  	private final String name;
  	private final UnixFile basedir;
  	private final ImmutableList<BuildSummary> builds;
  	private final Optional<BuildSummary> lastFailedBuild;
  	private final Optional<BuildSummary> lastStableBuild;
  	private final Optional<BuildSummary> lastSuccessfulBuild;
  	private final Optional<BuildSummary> lastUnstableBuild;
  	private final Optional<BuildSummary> lastUnsuccessfulBuild;
  
  	public static JobSummary build(UnixFile basedir, String timeZoneId, long startedBefore) throws IOException {
  		checkIsDir(basedir);
  		List<UnixFile> files = listBuildDirContents(basedir);
  		Map<String, Integer> buildNumbers = buildNumberMap(files);
  		List<BuildSummary> builds = getBuilds(files, buildNumbers, timeZoneId, startedBefore);
  		String name = basedir.getFileName();
  		Builder builder = builder().withBasedir(basedir).withBuilds(builds).withName(name);
  		builder.withLastFailedBuild(getNamedBuild(basedir, "lastFailedBuild", builds));
  		builder.withLastStableBuild(getNamedBuild(basedir, "lastStableBuild", builds));
  		builder.withLastSuccessfulBuild(getNamedBuild(basedir, "lastSuccessfulBuild", builds));
  		builder.withLastUnstableBuild(getNamedBuild(basedir, "lastUnstableBuild", builds));
  		builder.withLastUnsuccessfulBuild(getNamedBuild(basedir, "lastUnsuccessfulBuild", builds));
  		return builder.build();
  	}
  
  	private static Optional<BuildSummary> getNamedBuild(UnixFile jobDir, String link, List<BuildSummary> builds) {
  		try {
  			Path path = Paths.get(jobDir.getPath() + "/" + BUILDS_DIRECTORY + "/" + link);
  			UnixFile file = buildUnixFile(path);
  			if (!file.getAttributes().isSymbolicLink()) {
  				return absent();
  			}
  			Path realPath = path.toRealPath();
  			UnixFile realFile = buildUnixFile(realPath);
  			for (BuildSummary build : builds) {
  				if (realFile.equals(build.getBasedir())) {
  					return Optional.of(build);
  				}
  			}
  			return absent();
  		} catch (IOException e) {
  			return absent();
  		}
  	}
  
  	private static List<BuildSummary> getBuilds(List<UnixFile> files, Map<String, Integer> buildNumbers, String timeZoneId, long startedBefore) throws IOException {
  		// Setup a predicate that filters out everything except timestamp'd build directories
  		Predicate<UnixFile> buildsOnly = isJenkinsBuildDirectory();
  
  		// Convert Path objects into UnixFile objects and sort them
  		List<UnixFile> list = natural().sortedCopy(filter(files, buildsOnly));
  
  		// Convert each build directory into a BuildSummary object
  		List<BuildSummary> builds = newArrayList();
  		for (UnixFile element : list) {
  			try {
  				int buildNumber = checkNotNull(buildNumbers.get(element.getPath()), "no build number for [%s]", element.getPath());
  				BuildSummary build = BuildSummary.build(element, buildNumber, timeZoneId);
  				if (build.getStartTime() > startedBefore) {
  					continue;
  				}
  				if (!build.getFiles().isEmpty()) {
  					builds.add(build);
 				}
 			} catch (IOException e) {
 				// We don't have exclusive access to the file system
 				// Jenkins may delete a build while we are working
 				logger.info(format("error -> [%s]", e));
 			}
 		}
 		return builds;
 	}
 
 	public static Builder builder() {
 		return new Builder();
 	}
 
 	private JobSummary(Builder builder) {
 		this.name = builder.name;
 		this.basedir = builder.basedir;
 		this.builds = ImmutableList.copyOf(builder.builds);
 		this.lastFailedBuild = builder.lastFailedBuild;
 		this.lastStableBuild = builder.lastStableBuild;
 		this.lastSuccessfulBuild = builder.lastSuccessfulBuild;
 		this.lastUnstableBuild = builder.lastUnstableBuild;
 		this.lastUnsuccessfulBuild = builder.lastUnsuccessfulBuild;
 	}
 
 	public static class Builder implements org.apache.commons.lang3.builder.Builder<JobSummary> {
 
 		private String name;
 		private UnixFile basedir;
 		private List<BuildSummary> builds = newArrayList();
 		private Optional<BuildSummary> lastFailedBuild = absent();
 		private Optional<BuildSummary> lastStableBuild = absent();
 		private Optional<BuildSummary> lastSuccessfulBuild = absent();
 		private Optional<BuildSummary> lastUnstableBuild = absent();
 		private Optional<BuildSummary> lastUnsuccessfulBuild = absent();
 
 		public Builder withLastUnsuccessfulBuild(Optional<BuildSummary> lastUnsuccessfulBuild) {
 			this.lastUnsuccessfulBuild = lastUnsuccessfulBuild;
 			return this;
 		}
 
 		public Builder withLastUnstableBuild(Optional<BuildSummary> lastUnstableBuild) {
 			this.lastUnstableBuild = lastUnstableBuild;
 			return this;
 		}
 
 		public Builder withLastSuccessfulBuild(Optional<BuildSummary> lastSuccessfulBuild) {
 			this.lastSuccessfulBuild = lastSuccessfulBuild;
 			return this;
 		}
 
 		public Builder withLastStableBuild(Optional<BuildSummary> lastStableBuild) {
 			this.lastStableBuild = lastStableBuild;
 			return this;
 		}
 
 		public Builder withLastFailedBuild(Optional<BuildSummary> lastFailedBuild) {
 			this.lastFailedBuild = lastFailedBuild;
 			return this;
 		}
 
 		public Builder withBasedir(UnixFile basedir) {
 			this.basedir = basedir;
 			return this;
 		}
 
 		public Builder withName(String name) {
 			this.name = name;
 			return this;
 		}
 
 		public Builder withBuilds(List<BuildSummary> builds) {
 			this.builds = builds;
 			return this;
 		}
 
 		@Override
 		public JobSummary build() {
 			return validate(new JobSummary(this));
 		}
 
 		private static JobSummary validate(JobSummary instance) {
 			checkNotBlank(instance.name, "name");
 			checkNotNull(instance.basedir, "basedir");
 			checkNotNull(instance.builds, "builds");
 			return instance;
 		}
 	}
 
 	public List<BuildSummary> getBuilds() {
 		return builds;
 	}
 
 	public String getName() {
 		return name;
 	}
 
 	public UnixFile getBasedir() {
 		return basedir;
 	}
 
 	public Optional<BuildSummary> getLastFailedBuild() {
 		return lastFailedBuild;
 	}
 
 	public Optional<BuildSummary> getLastStableBuild() {
 		return lastStableBuild;
 	}
 
 	public Optional<BuildSummary> getLastSuccessfulBuild() {
 		return lastSuccessfulBuild;
 	}
 
 	public Optional<BuildSummary> getLastUnstableBuild() {
 		return lastUnstableBuild;
 	}
 
 	public Optional<BuildSummary> getLastUnsuccessfulBuild() {
 		return lastUnsuccessfulBuild;
 	}
 
 }