/opup/src/old/java/ShowResults.java

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.TreeMap;

import com.atlassian.labs.opup.BuildResult;
import com.atlassian.labs.opup.ItemResults;

import org.apache.commons.io.FileUtils;
import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.VelocityEngine;


public class ShowResults
{
    public static void main(String[] args) throws IOException
    {
        Map<String, String> commits = new HashMap<String, String>();
        
        for (String c : FileUtils.readLines(new File("target/commit.keys")))
        {
            String[] sa = c.split(",", 2);
            
            commits.put(sa[0], sa[1]);
        }

        Map<String, Boolean> passes = new HashMap<String, Boolean>();
        
        for (String pf : FileUtils.readLines(new File("opup-log/build-pass-fail")))
        {
            String[] sa = pf.split(",");
            
            passes.put(sa[0], Boolean.valueOf(sa[1].equals("good")));
        }
        
        List<ItemResults> allResults = new ArrayList<ItemResults>();
        
        for (String change : FileUtils.readLines(new File("target/change.keys")))
        {
            String[] sa = change.split(",");
            
            ItemResults results = new ItemResults();
            results.key = sa[0];

            Map<ArtifactVersion, BuildResult> buildResults = new TreeMap<ArtifactVersion, BuildResult>();
            
            for (int i = 1; i < sa.length; i++)
            {
                String k = sa[0] + ':' + sa[i];

                BuildResult result = new BuildResult();
                result.ran = false;
                
                String commit = commits.get(k);
                if (commit != null)
                {
                    Boolean pf = passes.get(commit);
                    if (pf != null)
                    {
                        result.ran = true;
                        result.passed = pf.booleanValue();
                        result.logfile = "../opup-log/build-log-" + commit + ".txt";
                    }
                }
                
                buildResults.put(new DefaultArtifactVersion(sa[i]), result);
            }
            
            implicitise(buildResults, Arrays.asList(sa).subList(1, sa.length));
            results.results = buildResults;
            allResults.add(results);
        }
        
        VelocityEngine ve = new VelocityEngine();
        
        Properties props = new Properties();
        props.setProperty("resource.loader", "class");
        props.setProperty("class.resource.loader.class", "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
        props.setProperty("eventhandler.referenceinsertion.class", "org.apache.velocity.app.event.implement.EscapeHtmlReference");

        ve.init(props);
        
        VelocityContext ctxt = new VelocityContext();
//        ctxt.put("groupId", groupId);
//        ctxt.put("artifactId", artifactId);
        
        ctxt.put("results", allResults);
        
        Template template = ve.getTemplate("/com/atlassian/labs/opup/results.vm");

        Writer w = new FileWriter("target/results.html");
        try
        {
            template.merge(ctxt, w);
            w.flush();
        }
        finally
        {
            w.close();
        }
    }

    private static void implicitise(Map<ArtifactVersion, BuildResult> buildResults, List<String> subList)
    {
        /* Current version passes implicitly */
        ArtifactVersion current = new DefaultArtifactVersion(subList.get(0));
        if (!buildResults.get(current).ran)
        {
            BuildResult br = new BuildResult();
            br.ran = false;
            br.passed = true;
            buildResults.put(current, br);
        }
        
        Map<ArtifactVersion, BuildResult> implied = new HashMap<ArtifactVersion, BuildResult>();

        boolean haveRealResults = false;
        boolean noFailures = true;
        for (String s : subList)
        {
            ArtifactVersion v = new DefaultArtifactVersion(s);
            
            BuildResult real = buildResults.get(v);
            if (real.ran)
            {
                haveRealResults = true;
                noFailures &= real.passed;
            }
            else
            {
                BuildResult ibr = new BuildResult();
                ibr.ran = false;
                ibr.passed = noFailures;
                implied.put(v, ibr);
            }
        }
        
        if (haveRealResults)
        {
            buildResults.putAll(implied);
        }
    }
}