/*
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
*/

var co = require('co');
var Q = require('q');
var glob = require('glob');
var path = require('path');
var fs = require('fs');
var util = require('util');
var optimist = require('optimist');
var shelljs = require('shelljs');
var apputil = require('./apputil');
var audit_license = require('./audit-license-headers');
var update_release_notes = require('./update-release-notes');
var create_archive = require('./create-verify-archive');
var executil = require('./executil');
var flagutil = require('./flagutil');
var gitutil = require('./gitutil');
var svnutil = require('./svnutil');
var repoutil = require('./repoutil');
var versionutil = require('./versionutil');
var repoupdate = require('./repo-update');
var repoclone = require('./repo-clone');
var reporeset = require('./repo-reset');
var jira_client = require('jira-client');
var inquirer = require('inquirer');
var semver = require('semver');
var linkify = require('jira-linkify');
var print = apputil.print;

/*
 * Pseudo code for plugin automation:
 * 1. Who are you? --> this is the release manager. Can we use JIRA for this?
 */
var jira; // issues.apache.org jira client object
var you; // store label for the user here
var jira_user; // store ref to jira project user
var cordova_project; // store ref to jira project for Cordova
var plugins_release_issue; // store ref to jira issue tracking release.
var jira_issue_types; // store ref to all issue types supported by our JIRA instance
var all_plugins_component; // store the specific component associated to the plugin issue.
var jira_task_issue; // store ref to the "task" issue type
var plugin_base; // parent directory holding all cordova plugins
var plugin_repos; // which plugins are we messing with? initially gets set to all plugin repos, later on gets filtered to only those we will release. an array of objects in a special coho-accepted format.
var dist_dev_svn; // cordova dist/dev repo
var dist_svn; // cordova dist repo
var svn_repos; // cordova dist and dist/dev svn repos
var plugin_data = {}; // massive object containing plugin release-relevant information
var plugins_to_release = []; // array of plugin names that need releasing
var plugins_ommitted = []; // array of plugin names that DO NOT need releasing
var plugins_to_merge_manually = []; // array of plugin names that RM will need to merge master into release branch manually.
var svn_user; // username for apache svn
var svn_password; // password for apache svn
var updated_repos; // sentinel variable for if we did repo updates
var created_distdev_dir; // sentinel var for if a new dir was created in cordova-dist-dev

function *updateDesiredRepos(repos) {
    if (!updated_repos) {
        updated_repos = true;
        yield repoclone.cloneRepos(repos, /*silent*/true, null);
        yield reporeset.resetRepos(repos, ['master']);
        yield repoupdate.updateRepos(repos, ['master'], /*noFetch*/false);
        yield repoclone.cloneRepos(svn_repos, /*silent*/true, null);
        yield findChangesInPluginRepos(repos);
    }
}
function *findChangesInPluginRepos(repos) {
    yield repoutil.forEachRepo(repos, function*(repo) {
        if (repo.repoName == 'cordova-plugins') return;
        var last_release = (yield gitutil.findMostRecentTag())[0];
        plugin_data[repo.repoName] = {
            last_release: last_release
        };
        var changes = yield gitutil.summaryOfChanges(last_release);
        changes = changes.split('\n').filter(function(line) {
            return (line.toLowerCase().indexOf('incremented plugin version') == -1);
        });
        if (changes.length > 0) {
            plugin_data[repo.repoName].needs_release = true;
            plugin_data[repo.repoName].changes = changes.join('\n');
            plugins_to_release.push(repo.repoName);
        } else {
            plugin_data[repo.repoName].needs_release = false;
            plugins_ommitted.push(repo.repoName);
        }
    });
}

function manualPluginSelection() {
    return inquirer.prompt({
        type: 'checkbox',
        name: 'plugins_list',
        message: 'Select the plugins you want to release:',
        choices: plugin_repos.map(function(p) { return p.repoName; }).filter(function(p) { return p != 'cordova-plugins'; })
    }).then(function(answer) {
        return answer.plugins_list;
    });
}

function *interactive_plugins_release() {
    console.log('Hi! So you want to do a plugins release, do you?');
    // sanity check for tooling that will be needed during releaser.
    if (!shelljs.which('gpg')) {
        console.warn("You'll need gpg installed and have your Apache GPG keys all set up to do a plugins release!");
        console.error('I did not find gpg on your PATH!');
        console.error('Refer to ' + create_archive.GPG_DOCS + ' for instructions on how to get that set up as a first step.');
        process.exit(1);
    }
    if (!shelljs.which('svn')) {
        console.warn("You'll need svn installed to do a plugins release!");
        console.error('I did not find `svn` on your PATH!');
        process.exit(1);
    }
    return Q.fcall(function() {
        if (process.env.JIRA_USER && process.env.JIRA_PASSWORD) {
            return {
                username: process.env.JIRA_USER,
                password: process.env.JIRA_PASSWORD
            }
        } else {
            console.log('Let\'s start with your JIRA credentials - this system will be interacting with Apache\'s JIRA instance (issues.apache.org) often.');
            console.log('(Note that you can export environment variables `JIRA_USER` and `JIRA_PASSWORD` so I won\'t ask you next time.)');
            return inquirer.prompt([{
                type: 'input',
                name: 'username',
                message: 'Please enter your JIRA username'
            },{
                type: 'password',
                name: 'password',
                message: 'Please enter your JIRA password'
            }])
        }
    }).then(function(answers) {
        var username = answers.username;
        you = username;
        var password = answers.password;
        jira = new jira_client({
              protocol: 'https',
              host: 'issues.apache.org',
              base: 'jira',
              apiVersion: '2',
              strictSSL: true,
              username: username,
              password: password
        });
        return jira.getCurrentUser();
    }).then(function(user) {
        jira_user = user;
        you = user.displayName || you; // either use JIRA display name, or username
        console.log('Hey', you, '!');
        console.log('Welcome. Let me pull some data from JIRA first...');
        return jira.listProjects();
    }).then(function(projects) {
        // Find the Apache Cordova (CB) project in Apache's JIRA
        for (var i = 0; i < projects.length; i++) {
            var project = projects[i];
            if (project.key == 'CB') {
                cordova_project = project;
                break;
            }
        }
        return jira.listComponents('CB');
    }).then(function(components) {
        // Find the ALlPlugins component in Cordova'a JIRA components
        for (var i = 0; i < components.length; i++) {
            var component = components[i];
            if (component.name == 'AllPlugins') {
                all_plugins_component = component;
                break;
            }
        }
        return jira.listIssueTypes();
    }).then(function(issue_types) {
        jira_issue_types = issue_types;
        for (var i = 0; i < issue_types.length; i++) {
            var it = issue_types[i];
            if (it.name == 'Task') {
                jira_task_issue = it;
            }
        }
        /*
         * 2. Are your gpg keys in place? maybe basic validation
         */
        inquirer.prompt({
            type: 'confirm',
            name: 'gpg',
            message: 'Are your GPG keys in place?'
        }).then(function(answer) {
            if (answer.gpg) {
                console.log('Great! Let\'s keep going.');
                return inquirer.prompt({
                    type: 'confirm',
                    name: 'discuss',
                    message: 'Did you start a "[DISCUSS] Plugins release" thread on the Cordova mailing list?'
                });
            } else {
                console.error('You should get your GPG keys sorted out first!');
                console.warn('Follow the instructions here, then come back and try again: ' + create_archive.GPG_DOCS);
                process.exit(2);
            }
        }).then(function(answer) {
            /* 3. Y/N did you start a "[DISCUSS] Plugins release" thread on the mailing list?
             *   - Bonus: Can we parse the mailing list for this?
             */
            if (answer.discuss) {
                console.log('Nice! Way to keep everyone in the loop!');
                return inquirer.prompt({
                    type: 'confirm',
                    name: 'jira',
                    message: 'Is there a JIRA issue filed for the plugins release? (i.e. "Plugins Release, <recent date>") - if not, I will create one for you.'
                });
            } else {
                console.error('You definitely need to have a discussion about the plugins release on the mailing list first. Go do that!');
                process.exit(3);
            }
        }).then(function(answer) {
            /* 4. Ask for JIRA issue, or, Create JIRA issue; check docs/plugins-release-process.md for details
             *   - lets refer to this JIRA issue as $JIRA from here on out.
             *   - TODO: BONUS: COMMENT to this JIRA issue for each "top-level" step below that is completed.
             */
            if (answer.jira) {
                return inquirer.prompt({
                    type: 'input',
                    name: 'jira',
                    message: 'What is the JIRA issue number for your plugins release? Please provide only the numerical part of the issue key (i.e. CB-XXXXX)'
                }).then(function(answers) {
                    var cb_issue = 'CB-' + answers.jira;
                    console.log('Looking for ' + cb_issue + '...');
                    return jira.findIssue(cb_issue).then(function(issue) {
                        return issue;
                    }, function(err) {
                        console.error('Error finding issue ' + cb_issue + '!');
                        process.exit(4);
                    });
                });
            } else {
                console.warn('OK, no problem. I will create one for you now! Hang tight...');
                var date = (new Date()).toDateString();
                var new_issue = {
                    "fields": {
                        "project": {
                            "id": cordova_project.id
                        },
                        "summary": "Plugins Release, " + date,
                        "description": "Following steps at https://github.com/apache/cordova-coho/blob/master/docs/plugins-release-process.md\nGenerated automatically using cordova-coho.",
                        "assignee": {
                            "name": jira_user.name
                        },
                        "issuetype": {
                            "id": jira_task_issue.id
                        },
                        "components": [
                            {
                                "id": all_plugins_component.id
                            }
                        ]
                    }
                }
                return jira.addNewIssue(new_issue).then(function(issue) {
                    return issue;
                }, function(err) {
                    console.error('There was a problem creating the JIRA issue!', err);
                    process.exit(5);
                });
            }
        }).then(function(jira_issue) {
            console.log('Sweet, our Plugins Release JIRA issue is ' + jira_issue.key + ' (https://issues.apache.org/jira/browse/' + jira_issue.key + ')!');
            plugins_release_issue = jira_issue;
        }).then(function() {
            /* 5: update the repos. ask the RM if they want to create a new set of repos, or use an existing directory */
            return inquirer.prompt([{
                type: 'confirm',
                name: 'use_existing_plugins',
                message: 'Do you want to use an existing set of plugin repositories? WARNING: If no, I will ask for a directory where I will clone all the needed repositories.'
            }, {
                type: 'input',
                name: 'cwd',
                default: apputil.getBaseDir(),
                message: function(answers) {
                    if (answers.use_existing_plugins) {
                        return 'We need to update the plugin and apache SVN repositories. Enter the directory containing all of your Apache Cordova source code repositories (absolute or relative paths work here)';
                    } else {
                        return 'Please enter the directory you want to house the plugin repos we will work with. This directory will be created if it does not exist.';
                    }
                }
            }, {
                type: 'confirm',
                name: 'auto_detect',
                message: 'Do you want me to try to auto-detect which plugins could use releases? If not, you will need to manually select which plugins you want to release. WARNING: if you use auto-detection along with the "clone-all-repos" option, you will be cloning a loooooong time.'
            }, {
                type: 'confirm',
                name: 'ok',
                message: function(answers) {
                    return 'WARNING! Are you sure the following directory is where you want the plugin repositories we will be working with to be located? We will be cloning/updating repos here: ' + path.resolve(path.normalize(answers.cwd));
                }
            }]);
        }).then(function(answers) {
            if (answers.ok) {
                plugin_base = path.resolve(path.normalize(answers.cwd));
                shelljs.mkdir('-p', plugin_base);
                process.chdir(plugin_base);
                plugin_repos = flagutil.computeReposFromFlag('plugins', {includeSvn:true});
                dist_svn = flagutil.computeReposFromFlag('dist', {includeSvn:true});
                dist_dev_svn = flagutil.computeReposFromFlag('dist/dev', {includeSvn:true});
                svn_repos = dist_svn.concat(dist_dev_svn);
                dist_svn = dist_svn[0];
                dist_dev_svn = dist_dev_svn[0];
                if (answers.auto_detect) {
                    return co.wrap(function *() {
                        yield updateDesiredRepos(plugin_repos);
                        return inquirer.prompt({
                            type: 'confirm',
                            name: 'plugins_ok',
                            message: 'I\'ve detected ' + plugins_to_release.length + ' plugin' + (plugins_to_release.length==1?'':'s') + ' to release: ' + plugins_to_release.join(', ') + '\nThat means we\'re skipping ' + plugins_ommitted.length + ' plugin' + (plugins_ommitted.length==1?'':'s') + ': ' + plugins_ommitted.join(', ') + '\nDo you want to proceed with the release process around the specified plugins above (and ommitting the ones specified as well)?'
                        }).then(function(answers) {
                            if (answers.plugins_ok) {
                                return plugins_to_release;
                            } else {
                                return manualPluginSelection();
                            }
                        });
                    })();
                } else {
                    // No auto-detection, manually specified list of plugins.
                    return manualPluginSelection();
                }
            } else {
                console.warn('Womp womp, try again? Probably this flow should be better eh?');
                process.exit(6);
            }
        }).then(function(plugins_list) {
            // at this point we either have a verified, or manually-specified, list of plugins to release.
            plugins_to_release = plugins_list;
            // modify the coho-formatted list of plugin repos to filter out to only the plugins we want to release.
            plugin_repos = plugin_repos.filter(function(plugin) {
                return plugins_to_release.indexOf(plugin.repoName) > -1;
            });
            return co.wrap(function *() {
                yield updateDesiredRepos(plugin_repos);
                // and remove all the data we collected for plugins we no longer care about.
                var data_keys = Object.keys(plugin_data);
                data_keys.forEach(function(key) {
                    if (plugins_to_release.indexOf(key) == -1) {
                        delete plugin_data[key];
                    }
                });
                /* 7. ensure license headers are present everywhere.*/
                console.log('Checking license headers for specified plugin repos...');
                var unknown_licenses = [];
                yield audit_license.scrubRepos(plugin_repos, /*silent*/true, /*allowError*/false, function(repo, stdout) {
                    var unknown = stdout.split('\n').filter(function(line) {
                        return line.indexOf('Unknown Licenses') > -1;
                    })[0];
                    if (unknown[0] != '0') {
                        // There are some unknown licenses!
                        unknown_licenses.push({repo:repo.repoName,unknown:unknown});
                    }
                });
                return yield Promise.resolve(unknown_licenses);
            })();
        }).then(function(unknowns) {
            if (unknowns.length) {
                console.warn('We identified some unknown licenses in plugin repos!');
                console.warn(unknowns);
                return inquirer.prompt({
                    type: 'confirm',
                    name: 'proceed',
                    message: 'Do you want to proceed even though there are license problems?'
                }).then(function(answer) {
                    if (!answer.proceed) {
                        console.error('License audit failed - good idea to abort. Fix it up and come back!');
                        process.exit(7);
                    }
                });
            } else {
                console.log('No license issues found - continuing.');
            }
        }).then(function() {
            return inquirer.prompt({
                type: 'confirm',
                name: 'proceed',
                message: 'We are now ready to start making changes to the selected plugin repo, which will make changes to the master and release branches. Shall we proceed?'
            }).then(function(answers) {
                if (!answers.proceed) {
                    console.error('Bailing!');
                    process.exit(99);
                }
            });
        }).then(function() {
            // TODO: step 8 apparently is "rarely" done based on fil's experience running through the plugin release steps manually.
            // soooo.... what do?
            /* 8. ensure all dependencies and subdependencies have apache-compatible licenses.
             * 9. update plugin versions + release notes.
             *   - for each plugin, remove the `-dev` suffix in plugin.xml, package.json, and plugin.xml of `tests/` subdirectory (if exists)*/
            console.log('Removing the "-dev" suffix from versions in the master branch...');
            return co.wrap(function *() {
                yield repoutil.forEachRepo(plugin_repos, function*(repo) {
                    yield gitutil.gitCheckout('master');
                    var current_version = yield versionutil.getRepoVersion(repo);
                    console.log(repo.repoName, '\'s current version is', current_version);
                    var devless_version = versionutil.removeDev(current_version);
                    plugin_data[repo.repoName].current_release = devless_version;
                    yield versionutil.updateRepoVersion(repo, devless_version, {commitChanges:false});
                });
            })();
        }).then(function() {
            /*   - each plugin may need a version bump.
             *     - how to determine if patch, minor or major? show changes to each plugin and then prompt Release Manager for a decision?
             *     - reuse coho 'update release notes' command */
            return co.wrap(function *() {
                var plugs = Object.keys(plugin_data);
                var release_note_prompts = [];
                yield plugs.map(function*(plugin) {
                    var data = plugin_data[plugin];
                    var changes = data.changes;
                    var final_notes = yield update_release_notes.createNotes(plugin, data.current_release, changes);
                    release_note_prompts.push({
                        type: 'editor',
                        name: plugin,
                        message: 'Please tweak and compile ' + plugin + ' release notes',
                        default: final_notes
                    });
                    /*     - what's the average case? just a patch bump? perhaps, for each plugin, show release notes and let RM override version beyond patch bump if RM believes it is necessary? */
                    release_note_prompts.push({
                        type: 'input',
                        name: plugin + '-version',
                        message: function(answers) {
                            var new_changes = answers[plugin];
                            var first_heading = new_changes.indexOf('###');
                            var second_heading = new_changes.indexOf('###', first_heading + 3);
                            var first_change = new_changes.indexOf('\n', first_heading + 3);
                            var len = second_heading - first_change;
                            var change_summary = new_changes.substr(first_change, len);
                            return 'Please enter a semver-compatible version number for this release of ' + plugin + ', based on the changes below:\n' + change_summary;
                        },
                        default: data.current_release,
                        validate: function(input) {
                            if (semver.valid(input)) {
                                return true;
                            } else {
                                return 'That\'s not a valid semver version!';
                            }
                        }
                    });
                });
                return inquirer.prompt(release_note_prompts);
            })();
        }).then(function(release_notes) {
            return co.wrap(function *() {
                console.log('Writing out new release notes and plugin versions (if applicable)...');
                yield repoutil.forEachRepo(plugin_repos, function*(repo) {
                    var plugin_name = repo.repoName;
                    if (plugin_data[plugin_name].current_release != release_notes[plugin_name + '-version']) {
                        // If, after release notes review, RM decided on a different version...
                        // Overwrite plugin version
                        var previous_assumed_version = plugin_data[plugin_name].current_release;
                        plugin_data[plugin_name].current_release = release_notes[plugin_name + '-version'];
                        yield versionutil.updateRepoVersion(repo, plugin_data[plugin_name].current_release, {commitChanges:false});
                        // also overwrite the version originally specified in the release notes file, since we changed it now!
                        var rn = release_notes[plugin_name];
                        var new_rn = rn.replace(new RegExp('### ' + previous_assumed_version, 'g'), '### ' + plugin_data[plugin_name].current_release);
                        release_notes[plugin_name] = new_rn;
                    }
                    fs.writeFileSync(update_release_notes.FILE, release_notes[plugin_name], {encoding: 'utf8'});
                    /* - commit changes to versions and release notes together with description '$JIRA Updated version and release notes for release $v'
                     * - tag each plugin repo with $v*/
                    if (yield gitutil.pendingChangesExist()) {
                        yield gitutil.commitChanges(plugins_release_issue.key + ' Updated version and RELEASENOTES.md for release ' + plugin_data[plugin_name].current_release + ' (via coho)');
                        yield gitutil.tagRepo(plugin_data[plugin_name].current_release);
                    } else {
                        console.warn('No pending changes detected for ' + plugin_name + '; that\'s probably not good eh?');
                    }
                });
            })();
        }).then(function() {
            /* 10. Create release branch. Check if release branch, which would be named in the form "major.minor.x" (i.e. 2.3.x) already exists */
            return co.wrap(function *() {
                var repos_with_existing_release_branch = [];
                yield repoutil.forEachRepo(plugin_repos, function*(repo) {
                    var plugin_name = repo.repoName;
                    var plugin_version = plugin_data[plugin_name].current_release;
                    var release_branch_name = versionutil.getReleaseBranchNameFromVersion(plugin_version);
                    if (yield gitutil.remoteBranchExists(repo, release_branch_name)) {
                        repos_with_existing_release_branch.push(repo);
                        // also store HEAD of release branch, so later on we can show a diff of the branch before pushing
                        plugin_data[plugin_name].previous_release_branch_head = gitutil.hashForRef(release_branch_name);
                        console.log('Release branch', release_branch_name, 'already exists, time to update it. We will be making changes to this existing branch.');
                        yield repoupdate.updateRepos([repo], [release_branch_name], /*noFetch*/false);
                    } else {
                        yield gitutil.createNewBranch(release_branch_name);
                        console.log('Created branch', release_branch_name, 'in repo', plugin_name);
                    }
                });
                return repos_with_existing_release_branch;
            })();
        }).then(function(repos_with_existing_release_branch) {
            // Here we are passed an array of repos that already had release branches created prior to starting the release process.
            // Our mission in this clause, should we choose to accept it, is to merge master back into the branch. But, this can be dangerous!
            // Ask the RM if they want us to handle the merge automatically.
            // If the RM says no, we will prompt them to handle it manually later.
            var prompts = [];
            repos_with_existing_release_branch.forEach(function(repo) {
                var plugin_name = repo.repoName;
                var rb = versionutil.getReleaseBranchNameFromVersion(plugin_data[plugin_name].current_release)
                prompts.push({
                    type: 'confirm',
                    name: 'rb_automerge_proceed_' + plugin_name,
                    message: plugin_name + ' already has an existing release branch "' + rb + '". Do you want me to automatically merge master into this branch for you? If no, I will prompt you to modify the release branch yourself at a later time in this session.\nWARNING: this will run `git merge master -s recursive -X theirs` from the release branch, essentially favouring master branch changes. Only proceed with the auto-merge if you understand the repercussions of doing so.'
                });
            });
            return inquirer.prompt(prompts);
        }).then(function(answers) {
            return co.wrap(function *() {
                var prompts = [];
                yield repoutil.forEachRepo(plugin_repos, function*(repo) {
                    var plugin_name = repo.repoName;
                    if (answers['rb_automerge_proceed_' + plugin_name]) {
                        // Auto-merge master into the release branch.
                        var rb = versionutil.getReleaseBranchNameFromVersion(plugin_data[plugin_name].current_release);
                        console.log('Checking out "' + rb + '" branch of', plugin_name, 'and merging master in...');
                        yield executil.execHelper(executil.ARGS('git merge -s recursive -X theirs', 'master'), false, false, function() {
                            console.log('Merge was fine, continuing.');
                        }, function(e) {
                        //yield gitutil.merge('master', function() { console.log('merge was fine, continuing.'); }, function(e) {
                            plugins_to_merge_manually.push(plugin_name);
                        });
                    } else {
                        plugins_to_merge_manually.push(plugin_name);
                    }
                });
                return inquirer.prompt(prompts);
            })();
        }).then(function() {
            // prompt the RM about the plugins with manual merging work needed here.
            var prompts = [];
            plugins_to_merge_manually.forEach(function(plugin_name) {
                var rb = versionutil.getReleaseBranchNameFromVersion(plugin_data[plugin_name].current_release)
                prompts.push({
                    type: 'confirm',
                    name: 'rb_manualmerge_proceed_' + plugin_name,
                    message: plugin_name + ' already has an existing release branch "' + rb + '", and it needs a manual merge of master into it (either because you specified that, or because there was a merge conflict during auto-merge. Now is your chance to manually merge / cherry-pick / resolve conflicts on the "' + rb + '" branch. Once you have done this (probably in a separate shell or command prompt), hit Enter to continue.'
                });
            });
            return inquirer.prompt(prompts);
        }).then(function() {
            /* 11. Increment plugin versions back on the master branch to include -dev*/
            // Also increment the patch version
            // So, check out master branch and do the thing.
            return co.wrap(function *() {
                yield repoutil.forEachRepo(plugin_repos, function*(repo) {
                    var plugin_name = repo.repoName;
                    var newest_version = semver.inc(plugin_data[plugin_name].current_release, 'patch') + '-dev';
                    console.log('Checking out master branch of', plugin_name, 'and setting version to', newest_version, ', then committing that change to master branch...');
                    yield gitutil.gitCheckout('master');
                    // store previous master HEAD, for later comparison/showing of diff
                    plugin_data[plugin_name].previous_master_head = gitutil.hashForRef('master');
                    yield versionutil.updateRepoVersion(repo, newest_version, {commitChanges:true});
                });
            })();
        }).then(function() {
            /* 12. Push tags, release branch, and master branch changes.
             * start with pushing tag, then compile diffs for master branch push and ask user if they approve before pushing master */
            return co.wrap(function *() {
                var master_prompts = [];
                yield repoutil.forEachRepo(plugin_repos, function*(repo) {
                    var plugin_name = repo.repoName;
                    var tag = plugin_data[plugin_name].current_release;
                    console.log(plugin_name, ': pushing tag ', tag);
                    yield gitutil.pushToOrigin(tag);
                    /*   - show diff of last master commit for user confirmation*/
                    var diff = yield gitutil.diff(plugin_data[plugin_name].previous_master_head, 'master');
                    master_prompts.push({
                        type: 'confirm',
                        name: 'master_' + plugin_name,
                        message: 'About to push the following changes to the master branch of ' + plugin_name + ': ' + diff + '\nDo you wish to continue?'
                    });
                });
                return inquirer.prompt(master_prompts);
            })();
        }).then(function(answers) {
            /*check confirmations and exit if RM bailed*/
            return co.wrap(function *() {
                yield repoutil.forEachRepo(plugin_repos, function*(repo) {
                    var plugin_name = repo.repoName;
                    if (!answers['master_' + plugin_name]) {
                        console.error('Aborting as master branch changes for ' + plugin_name + ' were not approved!');
                        process.exit(8);
                    }
                });
            })();
        }).then(function() {
            // at this point RM is cool pushing master branch changes up.
            return co.wrap(function *() {
                yield repoutil.forEachRepo(plugin_repos, function*(repo) {
                    // at this point still have master branch checked out
                    yield gitutil.pushToOrigin('master');
                });
            })();
        }).then(function() {
            /*   - show diff of release branch:
            *     - if release branch did not exist before, show diff (simple, just master..branch), confirm, then push
            *     - if release branch did exist before, show diff (last branch commit..HEAD), confirm, then push*/
            return co.wrap(function *() {
                var rb_prompts = [];
                yield repoutil.forEachRepo(plugin_repos, function*(repo) {
                    var plugin_name = repo.repoName;
                    var plugin_version = plugin_data[plugin_name].current_release;
                    var release_branch_name = versionutil.getReleaseBranchNameFromVersion(plugin_version);
                    var previous_release_branch_head = plugin_data[plugin_name].previous_release_branch_head;
                    yield gitutil.gitCheckout(release_branch_name);
                    if (previous_release_branch_head) {
                        // release branch previously existed.
                        var diff = yield gitutil.diff(previous_release_branch_head, 'HEAD');
                        rb_prompts.push({
                            type: 'confirm',
                            name: 'rb_' + plugin_name,
                            message: 'About to push the following changes to the EXISTING release branch (' + release_branch_name + ') of ' + plugin_name + ': ' + diff + '\nDo you wish to continue?'
                        });
                    } else {
                        // release branch did NOT exist previously, this is a new release branch.
                        var diff = yield gitutil.diff('master', release_branch_name);
                        rb_prompts.push({
                            type: 'confirm',
                            name: 'rb_' + plugin_name,
                            message: 'About to push the following changes (compared to master) to the NEW release branch (' + release_branch_name + ') of ' + plugin_name + ': ' + diff + '\nDo you wish to continue?'
                        });
                    }
                });
                return inquirer.prompt(rb_prompts);
            })();
        }).then(function(answers) {
            /*check confirmations and exit if RM bailed*/
            return co.wrap(function *() {
                yield repoutil.forEachRepo(plugin_repos, function*(repo) {
                    var plugin_name = repo.repoName;
                    if (!answers['rb_' + plugin_name]) {
                        console.error('Aborting as release branch changes for ' + plugin_name + ' were not approved!');
                        process.exit(8);
                    }
                });
            })();
        }).then(function() {
            // at this point RM is cool pushing master branch changes up.
            return co.wrap(function *() {
                yield repoutil.forEachRepo(plugin_repos, function*(repo) {
                    var plugin_name = repo.repoName;
                    var plugin_version = plugin_data[plugin_name].current_release;
                    var release_branch_name = versionutil.getReleaseBranchNameFromVersion(plugin_version);
                    // at this point have release branch checked out
                    yield gitutil.pushToOrigin(release_branch_name);
                });
            })();
        }).then(function() {
            // 13. Publish to apache svn:
            // - first update dist-dev repo
            return co.wrap(function *() {
                var orig_dir = process.cwd();
                var dist_dev_repo = path.join(plugin_base, dist_dev_svn.repoName);
                process.chdir(dist_dev_repo);
                console.log('Updating dist-dev svn repo...');
                yield svnutil.update();
                process.chdir(orig_dir);
            })();
        }).then(function() {
            //   - create-archive -r $ACTIVE --dest cordova-dist-dev/$JIRA
            return co.wrap(function *() {
                // location to store the archives in.
                var dist_dev_dir = path.join(plugin_base, dist_dev_svn.repoName, plugins_release_issue.key);
                if (!(fs.existsSync(dist_dev_dir))) {
                    shelljs.mkdir('-p', dist_dev_dir);
                    created_distdev_dir = true;
                }
                yield repoutil.forEachRepo(plugin_repos, function*(repo) {
                    var plugin_name = repo.repoName;
                    var tag = plugin_data[plugin_name].current_release;
                    yield gitutil.gitCheckout(tag);
                    var archive = yield create_archive.createArchive(repo, tag, dist_dev_dir, true/*sign*/);
                    // - verify-archive cordova-dist-dev/$JIRA/*.tgz
                    yield create_archive.verifyArchive(archive);
                    yield gitutil.gitCheckout('master');
                });
            })();
        }).then(function() {
            if (process.env.SVN_USER && process.env.SVN_PASSWORD) {
                return {
                    username: process.env.SVN_USER,
                    password: process.env.SVN_PASSWORD
                };
            } else {
                console.log('We are about to push changes up to Apache SVN! Let me get your SVN credentials.');
                console.log('(For next time, you can export the `SVN_USER` and `SVN_PASSWORD` environment variables to skip me asking you.)');
                return inquirer.prompt([{
                    type: 'input',
                    name: 'username',
                    message: 'Please enter your svn username'
                },{
                    type: 'password',
                    name: 'password',
                    message: 'Please enter your svn password'
                }]);
            }
        }).then(function(answers) {
            svn_user = answers.username;
            svn_password = answers.password;
            //   - upload by running `svn` add and commit commands.
            return co.wrap(function *() {
                var orig_dir = process.cwd();
                var dist_dev_repo = path.join(plugin_base, dist_dev_svn.repoName);
                if (created_distdev_dir) {
                    // if we created the dir containing the archives, then we can
                    // just svn add the entire dir.
                    process.chdir(dist_dev_repo);
                    yield svnutil.add(plugins_release_issue.key);
                    yield svnutil.commit(svn_user, svn_password, plugins_release_issue.key + ': Uploading release candidates for plugins release');
                } else {
                    // if it already existed, then we need to painstakingly add
                    // each individual archive file cause svn is cool
                    var archives_for_plugins = [];
                    yield repoutil.forEachRepo(plugin_repos, function*(repo) {
                        process.chdir(dist_dev_repo);
                        var plugin_name = repo.repoName;
                        var tag = plugin_data[plugin_name].current_release;
                        var fileref = plugin_name + '-' + tag;
                        archives_for_plugins.push(fileref);
                        var files_to_add = glob.sync(path.join(plugins_release_issue.key, fileref + '*'));
                        for (var i = 0; i < files_to_add.length; i++) {
                            yield svnutil.add(files_to_add[i]);
                        }
                    });
                    process.chdir(dist_dev_repo);
                    yield svnutil.commit(svn_user, svn_password, plugins_release_issue.key + ': Uploading release candidates for plugins ' + archives_for_plugins.join(', '));
                }

                process.chdir(orig_dir);
            })();
        }).then(function() {
            console.log('Nicely done! Last few things you should do:');
            /* 14. Dump instructions only? Prepare blog post - perhaps can dump out release notes-based blog content.
             *   - TODO: this apparently ends up as a .md file in cordova-docs. perhaps can dump this as a shell of a file into the cordova-docs repo? maybe even auto-branch the docs repo in prep for a PR?*/
            console.log('1. Prepare a blog post: https://github.com/apache/cordova-coho/blob/master/docs/plugins-release-process.md#prepare-blog-post');
            console.log('2. Start a vote thread! https://github.com/apache/cordova-coho/blob/master/docs/plugins-release-process.md#start-vote-thread');
            console.log('3. You should test these plugins out! Check out cordova-mobile-spec, and in particular, the `createmobilespec` script that comes with it - it\'s a quick way to create a test project with all plugins included.');
            process.exit(0);
        });
    }, function(auth_err) {
        var keys = Object.keys(auth_err);
        console.error('ERROR! There was a problem connecting to JIRA, received a', auth_err.statusCode, 'status code.');
        process.exit(1);
    });
     /* 16. Bonus: separate script to 'approve' a plugins release, which would:
     *   - publish the artifacts to dist/ in apache
     *   - "tell apache about the release" which has a TODO to write a helper to POST the request appropriately.
     *   - publish to npm
     *   - push 'permanent release tags' (for apache) to git
     *   - issue cordova-docs blog post PR (only if we auto-branch in cordova-docs repo, as per step 14)
     *   - dump instructions only? post an ANNOUNCE thread to ML.
     *   - close $JIRA issue
     */

    /*
     * TODO: Need ability to serialize process of plugins release - save state of the process at any point.
     */
}
module.exports.interactive = interactive_plugins_release;

/*
 * A function that handles version if it is defined or undefined
 *
 * @param {String} repo                    current repo
 * @param {String|undefined} ver           current version that can be defined or undefined
 * @param {String|undefined} validate      current version that can be defined or undefined
 *
 * @return {String} version                Returns the calculated version
 *
 */

// TODO: if using this function only to retrieve repo version, use the new
// versionutil.getRepoVersion method instead.
function *handleVersion(repo, ver, validate) {
    var platform = repo.id;
    var version = ver || undefined;

    if (version === undefined) {
        yield repoutil.forEachRepo([repo], function*() {
            // Grabbing version from platformPackageJson
            var platformPackage = path.join(process.cwd(), 'package.json');
            var platformPackageJson = require(platformPackage);
            if(validate === true) {
                version = flagutil.validateVersionString(platformPackageJson.version);
            } else {
                version = platformPackageJson.version;
            }
        });
    }
    return version;
}