package org.kuali.common.devops.jenkins.upgrade;
   
   import static com.amazonaws.services.s3.Headers.CONTENT_TYPE;
   import static com.google.common.base.Stopwatch.createStarted;
   import static com.google.common.collect.Lists.newArrayList;
   import static com.google.common.collect.Maps.newHashMap;
   import static java.lang.String.format;
   import static org.kuali.common.core.collect.Lists.shuffledCopy;
   import static org.kuali.common.devops.archive.sweep.Functions.hostnameToKey;
  import static org.kuali.common.devops.jenkins.upgrade.Jenkins.jenkinsContentType;
  import static org.kuali.common.util.Encodings.UTF8;
  import static org.kuali.common.util.log.Loggers.newLogger;
  
  import java.io.File;
  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.Callable;
  
  import org.kuali.common.aws.s3.S3Service;
  import org.kuali.common.aws.s3.model.ObjectMetadata;
  import org.kuali.common.aws.s3.model.PutFileRequest;
  import org.kuali.common.core.base.TimedInterval;
  import org.kuali.common.core.build.ValidatingBuilder;
  import org.kuali.common.core.io.BasicFile;
  import org.kuali.common.core.validate.annotation.IdiotProofImmutable;
  import org.kuali.common.util.inform.PercentCompleteInformer;
  import org.slf4j.Logger;
  
  import com.google.common.base.Function;
  import com.google.common.base.Optional;
  import com.google.common.base.Stopwatch;
  import com.google.common.collect.ImmutableList;
  
  @IdiotProofImmutable
  public final class BasicFileUploadCallable implements Callable<List<TimedInterval>> {
  
  	private static final Logger logger = newLogger();
  
  	private final S3Service s3;
  	private final ImmutableList<BasicFile> files;
  	private final String hostname;
  	private final String bucket;
  	private final PercentCompleteInformer informer;
  	private final Function<BasicFile, Double> weigher;
  	// TODO Pass this in instead of hard coding it here
  	private final Function<BasicFile, Optional<String>> contentType = jenkinsContentType();
  
  	@Override
  	public List<TimedInterval> call() {
  		String prefix = hostnameToKey().apply(hostname);
  		List<TimedInterval> timings = newArrayList();
  		List<BasicFile> shuffled = shuffledCopy(files);
  		for (BasicFile file : shuffled) {
  			Stopwatch sw = createStarted();
  			String s3Key = prefix + file.getPath();
  			try {
  				PutFileRequest request = getPutFileRequest(file, s3Key);
  				s3.putFile(request);
  			} catch (Exception e) {
  				logger.info(format("error -> %s", e));
  			}
  			TimedInterval timing = TimedInterval.build(sw);
  			timings.add(timing);
  			long progress = weigher.apply(file).longValue();
  			informer.incrementProgress(progress);
  		}
  		return timings;
  	}
  
  	private PutFileRequest getPutFileRequest(BasicFile file, String s3Key) {
  		PutFileRequest.Builder builder = PutFileRequest.builder().withBucket(bucket).withEncoding(UTF8).withFile(new File(file.getPath())).withKey(s3Key);
  		Optional<String> contentType = this.contentType.apply(file);
  		if (contentType.isPresent()) {
  			Map<String, Object> raw = newHashMap();
  			raw.put(CONTENT_TYPE, contentType.get());
  			ObjectMetadata meta = ObjectMetadata.builder().withRawMetadata(raw).build();
  			builder.withMetadata(meta);
  		}
  		return builder.build();
  	}
  
  	private BasicFileUploadCallable(Builder builder) {
  		this.s3 = builder.s3;
  		this.files = ImmutableList.copyOf(builder.files);
  		this.hostname = builder.hostname;
  		this.bucket = builder.bucket;
  		this.informer = builder.informer;
  		this.weigher = builder.weigher;
  	}
  
  	public static Builder builder() {
  		return new Builder();
  	}
  
  	public static class Builder extends ValidatingBuilder<BasicFileUploadCallable> {
  
  		private S3Service s3;
  		private List<BasicFile> files;
  		private String hostname;
 		private String bucket;
 		private PercentCompleteInformer informer;
 		private Function<BasicFile, Double> weigher;
 
 		public Builder withWeigher(Function<BasicFile, Double> weigher) {
 			this.weigher = weigher;
 			return this;
 		}
 
 		public Builder withS3(S3Service s3) {
 			this.s3 = s3;
 			return this;
 		}
 
 		public Builder withFiles(List<BasicFile> files) {
 			this.files = files;
 			return this;
 		}
 
 		public Builder withHostname(String hostname) {
 			this.hostname = hostname;
 			return this;
 		}
 
 		public Builder withBucket(String bucket) {
 			this.bucket = bucket;
 			return this;
 		}
 
 		public Builder withInformer(PercentCompleteInformer informer) {
 			this.informer = informer;
 			return this;
 		}
 
 		@Override
 		public BasicFileUploadCallable build() {
 			return validate(new BasicFileUploadCallable(this));
 		}
 	}
 
 	public S3Service getS3() {
 		return s3;
 	}
 
 	public List<BasicFile> getFiles() {
 		return files;
 	}
 
 	public String getHostname() {
 		return hostname;
 	}
 
 	public String getBucket() {
 		return bucket;
 	}
 
 	public PercentCompleteInformer getInformer() {
 		return informer;
 	}
 
 	public Function<BasicFile, Double> getWeigher() {
 		return weigher;
 	}
 
 }