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;
        }

}