/opup/src/main/scala/CreateUpgradeBranches.scala

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.atlassian.labs.opup.HttpAuthentication
import com.atlassian.labs.opup.ObsoleteAdvice;
import com.atlassian.labs.opup.OpupProperties;
import com.atlassian.labs.opup.PomScanner;
import com.atlassian.labs.opup.Report;
import com.atlassian.labs.opup.UpgradeBranchCreator
import com.atlassian.labs.opup.UpgradeSchedule;
import com.atlassian.labs.opup.UpgradeStrategy;
import com.atlassian.labs.opup.VersionChanger;
import com.atlassian.labs.opup.VersionClient;
import com.atlassian.labs.opup.VersionOverrides;
import com.atlassian.labs.opup.VerySimpleCache;

import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.model.Model;
import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.lib.RepositoryBuilder;

import scala.collection.JavaConverters._

/**
 * Main entry point, with hardcoded paths.
 */
object CreateUpgradeBranches {

    def main(args : Array[String]) : Unit = {
        val props = OpupProperties.get();

        val ps = new PomScanner();
        val versionOverrides = new VersionOverrides();
        versionOverrides.load(props.getBadArtifactsFile());

        versionOverrides.requireFinal(props.getRequireFinal());

        val obsoleteAdvice = ObsoleteAdvice.load(props.getObsoleteArtifactsFile());

        val cache = new VerySimpleCache(props.getCacheDirectory(), HttpAuthentication.fromConsole);
        val vc = new VersionClient(cache, props.getNexusUrl(), versionOverrides);

        val mainPom = new MavenXpp3Reader().read(new FileInputStream(new File(props.getBaseDirectory(), "pom.xml")));

        val target = new File("target");
        if (!target.isDirectory())
        {
            target.mkdir();
        }

        val report = new Report(mainPom.getGroupId(), mainPom.getArtifactId(), mainPom.getVersion());
        report.copyStylesheet(target);

        val poms = PomScanner.pomFiles(props.getBaseDirectory()).asScala;

        ps.process(poms)

        ps.findCurrent(report);
        val currentVersions = ps.getCurrentVersions();
        val currentProperties = ps.getCurrentProperties();

//        var targetVersions: Map[String, ArtifactVersion] = _

        report.setUpgradeStrategy(props.getUpgradeStrategy());
        val targetVersions = new UpgradeStrategy(cache).getUpgradeTarget(props.getUpgradeStrategy(), ps.getCurrentVersions().asScala.toMap);

//        System.out.println("Target versions: " + targetVersions);

        var upgradeSchedule = UpgradeSchedule.from(currentVersions, ps, vc, obsoleteAdvice, report, targetVersions);
//        System.out.println("To change: " + upgradeSchedule.newVersions.size() + " + " + upgradeSchedule.newProperties.size());

        upgradeSchedule = upgradeSchedule.withUpgrades();

        report.schedule(currentVersions, ps.getCurrentProperties(), upgradeSchedule);

        val w = new FileWriter(new File(target, "report.html"));
        try
        {
            report.writeReport(w);
        }
        finally
        {
            w.close();
        }

//        System.exit(0);

        val changerForEverything = new VersionChanger();
        changerForEverything.setKey("all");

        val allChanges = new HashMap[String, List[VersionChanger]]();

        val changeKeys = new ArrayList[String]();

        for (e <- upgradeSchedule.getNewVersions().entrySet().asScala)
        {
            val sb = new StringBuilder(e.getKey());

            sb.append(',');
            sb.append(currentVersions.get(e.getKey()));

            val branchName = "artifact-" + (e.getKey().replaceAll("[^a-zA-Z0-9]", "_"));

            val cl = new ArrayList[VersionChanger]();

            for (v <- e.getValue.asScala)
            {
                val changer = new VersionChanger();

                changer.setNewVersion(e.getKey(), v);
                changer.setKey(e.getKey() + ":" + v);
                changerForEverything.setNewVersion(e.getKey(), v);

                cl.add(changer);

                sb.append(',');
                sb.append(v);
            }

            allChanges.put(branchName, cl);
            changeKeys.add(sb.toString());
        }

        for (e <- upgradeSchedule.getNewProperties().entrySet().asScala)
        {
            val sb = new StringBuilder(e.getKey());

            sb.append(',');
            sb.append(currentProperties.get(e.getKey()));

            val branchName = "property-" + e.getKey();

            val cl = new ArrayList[VersionChanger]();

            for (v <- e.getValue.asScala)
            {
                val changer = new VersionChanger();
                changer.setNewPropertyValue(e.getKey(), v);
                changer.setKey(e.getKey() + ":" + v);
                changerForEverything.setNewPropertyValue(e.getKey(), v);
                cl.add(changer);

                sb.append(',');
                sb.append(v);
            }

            allChanges.put(branchName, cl);
            changeKeys.add(sb.toString());
        }

        allChanges.put("all", Collections.singletonList(changerForEverything));

        /* Create the branches */

        val repo = new RepositoryBuilder().setWorkTree(props.getBaseDirectory()).build();

        val git = new Git(repo);

        val upgradeBranchCreator = new UpgradeBranchCreator(git)

        upgradeBranchCreator.checkout("master")

        val log = (s: String) => println(s)

        upgradeBranchCreator.deleteAllOpupBranches(log)

        val commits = upgradeBranchCreator.createBranches(
            allChanges.asScala.map(e => (e._1, e._2.asScala.toSeq)).toMap,
            poms,
            log)

        upgradeBranchCreator.checkout("master")

        val commitKeys = for ((cmtId, changer) <- commits) yield changer.getKey() + "," + cmtId.getName()

        /* Write out the state */
        writeLines("target/opup/change.keys", changeKeys.asScala);
        writeLines("target/opup/commit.keys", commitKeys);
    }

    def writeLines(filename: String, lines: Iterable[String]) = {
        val bw = new BufferedWriter(new FileWriter(filename));
        try
        {
          for (l <- lines) {
                bw.write(l)
                bw.newLine()
           }
        }
        finally
        {
            bw.close();
        }
    }
}