import chalk from 'chalk';
import Github from 'github-api';
import utils from './_utils.js';
import { generate } from './_template.js';
import connectivity from 'connectivity';
import templateConfig from './templates.js';
import ObjectAssign from 'object-assign-deep';
import fs from 'fs';

const defaults = {
    tags: [],
    prefix: '',
    template: templateConfig,
    prerelease: false,
    generate: false,
    quiet: false,
    override: false,
    debug: false,
    ignoreLabels: false,
    ignoreIssuesWith: false,
    ignoreCommitsWith: false,
    groupBy: false,
    milestoneMatch: 'Release {{tag_name}}'
};

const MAX_TAGS_LIMIT = 99;
const TAGS_LIMIT = 30;

/** Class creating release notes and changelog notes */
class Gren {
    constructor(props = {}) {
        this.options = ObjectAssign({}, defaults, props);
        this.tasks = [];

        const {
            username,
            repo,
            token,
            apiUrl,
            tags,
            limit,
            ignoreLabels,
            ignoreIssuesWith,
            ignoreCommitsWith,
            ignoreTagsWith
        } = this.options;

        this.options.tags = utils.convertStringToArray(tags);
        this.options.ignoreLabels = utils.convertStringToArray(ignoreLabels);
        this.options.ignoreIssuesWith = utils.convertStringToArray(ignoreIssuesWith);
        this.options.ignoreCommitsWith = utils.convertStringToArray(ignoreCommitsWith);
        this.options.ignoreTagsWith = utils.convertStringToArray(ignoreTagsWith);

        if (limit && limit > 0 && limit <= MAX_TAGS_LIMIT) {
            this.options.limit = limit;
        } else if (this.options.tags.indexOf('all') >= 0) {
            this.options.limit = MAX_TAGS_LIMIT;
        } else {
            this.options.limit = TAGS_LIMIT;
        }

        if (!token) {
            throw chalk.red('You must provide the TOKEN');
        }

        if (this.options.debug) {
            this._outputOptions(this.options);
        }

        const githubApi = new Github({
            token
        }, apiUrl);

        this.repo = githubApi.getRepo(username, repo);
        this.issues = githubApi.getIssues(username, repo);
    }

    /**
     * Generate release notes and draft a new release
     *
     * @since  0.10.0
     * @public
     *
     * @return {Promise}
     */
    async release() {
        utils.printTask(this.options.quiet, 'Generate release notes');

        await this._hasNetwork();
        const blocks = await this._getReleaseBlocks();

        return blocks.reduce((carry, block) => carry.then(this._prepareRelease.bind(this, block)), Promise.resolve());
    }

    /**
     * Generate changelog file based on the release notes or generate new one
     *
     * @since  0.10.0
     * @public
     *
     * @return {Promise}
     */
    async changelog() {
        utils.printTask(this.options.quiet, 'Generate changelog file');

        await this._hasNetwork();
        this._checkChangelogFile();

        const releases = this.options.generate ? await this._getReleaseBlocks() : await this._getListReleases();

        if (releases.length === 0) {
            throw chalk.red('There are no releases, use --generate to create release notes, or run the release command.');
        }

        return this._createChangelog(this._templateReleases(releases));
    }

    /**
     * Check if the changelog file exists
     *
     * @since 0.8.0
     * @private
     *
     * @return {string}
     */
    _checkChangelogFile() {
        const filePath = process.cwd() + '/' + this.options.changelogFilename;

        if (fs.existsSync(filePath) && !this.options.override) {
            throw chalk.black(chalk.bgYellow('Looks like there is already a changelog, to override it use --override'));
        }

        return filePath;
    }

    /**
     * Create the changelog file
     *
     * @since 0.8.0
     * @private
     *
     * @param  {string} body The body of the file
     */
    _createChangelog(body) {
        const loaded = utils.task(this, `Creating ${this.options.changelogFilename}`);
        const filePath = process.cwd() + '/' + this.options.changelogFilename;

        fs.writeFileSync(filePath, this.options.template.changelogTitle + body);

        loaded(chalk.green(`Changelog created in ${filePath}`));
    }

    /**
     * Edit a release from a given tag (in the options)
     *
     * @since 0.5.0
     * @private
     *
     * @param  {number} releaseId The id of the release to edit
     * @param  {Object} releaseOptions The options to build the release:
     * @example
     * {
     *   "tag_name": "v1.0.0",
     *   "target_commitish": "master",
     *   "name": "v1.0.0",
     *   "body": "Description of the release",
     *   "draft": false,
     *   "prerelease": false
     * }
     *
     * @return {Promise}
     */
    async _editRelease(releaseId, releaseOptions) {
        const loaded = utils.task(this, 'Updating latest release');
        const { data: release } = await this.repo.updateRelease(releaseId, releaseOptions);

        loaded(chalk.green(`${release.name} has been successfully updated!`) + chalk.blue(`\nSee the results here: ${release.html_url}`));

        return release;
    }

    /**
     * Create a release from a given tag (in the options)
     *
     * @since 0.1.0
     * @private
     *
     * @param  {Object} releaseOptions The options to build the release:
     * @example {
     *   "tag_name": "1.0.0",
     *   "target_commitish": "master",
     *   "name": "v1.0.0",
     *   "body": "Description of the release",
     *   "draft": false,
     *   "prerelease": false
     * }
     *
     * @return {Promise}
     */
    async _createRelease(releaseOptions) {
        const loaded = utils.task(this, 'Preparing the release');
        const { data: release } = await this.repo.createRelease(releaseOptions);

        loaded(chalk.green(`${release.name} has been successfully created!`) + chalk.blue(`\nSee the results here: ${release.html_url}`));

        return release;
    }

    /**
     * Creates the options to make the release
     *
     * @since 0.2.0
     * @private
     *
     * @param  {Object[]} tags The collection of tags
     *
     * @return {Promise}
     */
    _prepareRelease(block) {
        const releaseOptions = {
            tag_name: block.release,
            name: block.name,
            body: block.body,
            draft: this.options.draft,
            prerelease: this.options.prerelease
        };

        if (block.id) {
            if (!this.options.override) {
                console.warn(chalk.black(chalk.bgYellow(`Skipping ${block.release} (use --override to replace it)`)));

                return Promise.resolve();
            }

            return this._editRelease(block.id, releaseOptions);
        }

        return this._createRelease(releaseOptions);
    }

    /**
     * Get the tags information from the given ones, and adds
     * the next one in case only one is given
     *
     * @since 0.5.0
     * @private
     *
     * @param  {Array|string} allTags
     * @param  {Object[]} tags
     *
     * @return {Boolean|Array}
     */
    _getSelectedTags(allTags) {
        const { tags } = this.options;

        if (tags.indexOf('all') >= 0) {
            return allTags;
        }

        if (!allTags || !allTags.length || !tags.length) {
            return false;
        }

        const selectedTags = [].concat(tags);

        return allTags.filter(({ name }, index) => {
            const isSelectedTag = selectedTags.includes(name);

            if (isSelectedTag && selectedTags.length === 1 && allTags[index + 1]) {
                selectedTags.push(allTags[index + 1].name);
            }
            return isSelectedTag;
        }).slice(0, 2);
    }

    /**
     * Temporary function for this.repo.listReleases to accept options
     *
     * @see  https://github.com/github-tools/github/pull/485
     * @param  {Object} options
     *
     * @return {Promise}
     */
    _listTags(options) {
        return this.repo._request('GET', `/repos/${this.repo.__fullname}/tags`, options);
    }

    /**
     * Get all the tags of the repo
     *
     * @since 0.1.0
     * @private
     *
     * @param {Array} releases
     * @param {number} page
     *
     * @return {Promise}
     */
    async _getLastTags(releases, page = 1, limit = this.options.limit) {
        const { headers: { link }, data: tags } = await this._listTags({
            per_page: limit,
            page
        });

        if (!tags.length) {
            throw chalk.red('\nLooks like you have no tags! Tag a commit first and then run gren again');
        }

        const filteredTags = (this._getSelectedTags(tags) || [tags[0], tags[1]])
            .filter(Boolean)
            .filter(({ name }) => this.options.ignoreTagsWith.every(ignoreTag => !name.match(ignoreTag)))
            .map(tag => {
                const tagRelease = releases ? releases.filter(release => release.tag_name === tag.name)[0] : false;
                const releaseId = tagRelease ? tagRelease.id : null;

                return {
                    tag: tag,
                    releaseId: releaseId
                };
            });
        const totalPages = this._getLastPage(link);

        if ((this.options.tags.indexOf('all') >= 0 || filteredTags.length < 2) && totalPages && +page < totalPages) {
            return this._getLastTags(releases, page + 1).then(moreTags => moreTags.concat(filteredTags));
        }

        return filteredTags;
    }

    /**
     * Get the dates of the last two tags
     *
     * @since 0.1.0
     * @private
     *
     * @param  {Object[]} tags List of all the tags in the repo
     *
     * @return {Promise[]}     The promises which returns the dates
     */
    _getTagDates(tags) {
        return tags.map(async tag => {
            const { data: { committer } } = await this.repo.getCommit(tag.tag.commit.sha);

            return {
                id: tag.releaseId,
                name: tag.tag.name,
                date: committer.date
            };
        });
    }

    /**
     * Temporary function for this.repo.listReleases to accept options
     *
     * @see  https://github.com/github-tools/github/pull/485
     * @param  {Object} options
     *
     * @return {Promise}
     */
    _listReleases(options) {
        return this.repo._request('GET', `/repos/${this.repo.__fullname}/releases`, options);
    }

    /**
     * Get the merged pull requests from the repo
     *
     * @private
     *
     * @param {number} page
     * @param {number} limit
     *
     * @return {Promise[]}     The promises which returns pull requests
     */
    async _getMergedPullRequests(since, page = 1, limit = 1000) {
        const results = await this.repo.listPullRequests({
            state: 'closed',
            sort: 'updated',
            direction: 'desc',
            per_page: limit,
            page
        });

        const { headers: { link }, data: prs } = results;
        const totalPages = this._getLastPage(link);
        const filterPrs = prs.filter(pr => pr.merged_at);
        if (prs.length > 0 && since < prs[prs.length - 1].updated_at &&
            totalPages && +page < totalPages) {
            return this._getMergedPullRequests(since, page + 1).then(prsResults => prsResults.concat(filterPrs));
        }

        return filterPrs;
    }

    /**
     * Get the last page from a Hypermedia link
     *
     * @since  0.11.1
     * @private
     *
     * @param  {string} link
     *
     * @return {boolean|number}
     */
    _getLastPage(link) {
        const linkMatch = Boolean(link) && link.match(/page=(\d+)>; rel="last"/);

        return linkMatch && +linkMatch[1];
    }

    /**
     * Get all releases
     *
     * @since 0.5.0
     * @private
     *
     * @return {Promise} The promise which resolves an array of releases
     */
    async _getListReleases(page = 1, limit = this.options.limit) {
        const loaded = utils.task(this, 'Getting the list of releases');
        const { headers: { link }, data: releases } = await this._listReleases({
            per_page: limit,
            page
        });

        const totalPages = this._getLastPage(link);

        if (this.options.tags.indexOf('all') >= 0 && totalPages && +page < totalPages) {
            return this._getListReleases(page + 1).then(moreReleases => moreReleases.concat(releases));
        }

        loaded(`Releases found: ${releases.length}`);

        return releases;
    }

    /**
     * Generate the releases bodies from a release Objects Array
     *
     * @since 0.8.0
     * @private
     * @ignore
     *
     * @param  {Array} releases The release Objects Array coming from GitHub
     *
     * @return {string}
     */
    _templateReleases(releases) {
        const { template } = this.options;

        return releases.map(release => generate({
            release: release.name || release.tag_name,
            date: utils.formatDate(new Date(release.published_at)),
            body: release.body
        }, template.release)).join(template.releaseSeparator);
    }

    /**
     * Return the templated commit message
     *
     * @since 0.1.0
     * @private
     *
     * @param  {Object} commit
     *
     * @return {string}
     */
    // eslint-disable-next-line camelcase
    _templateCommits({ sha, html_url, author, commit: { author: { name }, message } }) {
        return generate({
            sha,
            message: message.split('\n')[0],
            url: html_url,
            author: author && author.login,
            authorName: name
        }, this.options.template.commit);
    }

    /**
     * Generate the MD template from all the labels of a specific issue
     *
     * @since 0.5.0
     * @private
     *
     * @param  {Object} issue
     *
     * @return {string}
     */
    _templateLabels(issue) {
        const labels = Array.from(issue.labels);

        if (!labels.length && this.options.template.noLabel) {
            labels.push({name: this.options.template.noLabel});
        }

        return labels
            .filter(label => this.options.ignoreLabels.indexOf(label.name) === -1)
            .map(label => generate({
                label: label.name
            }, this.options.template.label)).join('');
    }

    /**
     * Generate the MD template for each issue
     *
     * @since 0.5.0
     * @private
     *
     * @param  {Object} issue
     *
     * @return {string}
     */
    _templateIssue(issue) {
        return generate({
            labels: this._templateLabels(issue),
            name: issue.title,
            text: '#' + issue.number,
            url: issue.html_url,
            body: issue.body,
            pr_base: issue.base && issue.base.ref,
            pr_head: issue.head && issue.head.ref
        }, this.options.template.issue);
    }

    /**
     * Generate the Changelog issues body template
     *
     * @since 0.5.0
     * @private
     *
     * @param  {Object[]} blocks
     *
     * @return {string}
     */
    _templateBody(body, rangeBody) {
        if (Array.isArray(body) && body.length) {
            return body.join('\n') + '\n';
        }

        if (rangeBody) {
            return `${rangeBody}\n`;
        }

        return '*No changelog for this release.*\n';
    }

    /**
     * Generates the template for the groups
     *
     * @since  0.8.0
     * @private
     *
     * @param  {Object} groups The groups to template e.g.
     * {
     *     'bugs': [{...}, {...}, {...}]
     * }
     *
     * @return {string}
     */
    _templateGroups(groups) {
        return Object.entries(groups).map(([key, value]) => {
            const heading = generate({
                heading: key
            }, this.options.template.group);
            const body = value.join('\n');

            return heading + '\n' + body;
        });
    }

    /**
     * Filter a commit based on the includeMessages option and commit message
     *
     * @since  0.10.0
     * @private
     *
     * @param  {Object} commit
     *
     * @return {Boolean}
     */
    _filterCommit({ commit: { message } }) {
        const messageType = this.options.includeMessages;
        const filterMap = {
            merges: message => message.match(/^merge/i),
            commits: message => !message.match(/^merge/i),
            all: () => true
        };
        const shouldIgnoreMessage = this.options.ignoreCommitsWith.every(commitMessage => {
            const regex = new RegExp(commitMessage, 'i');
            return !message.split('\n')[0].match(regex);
        });

        if (filterMap[messageType]) {
            return filterMap[messageType](message) && shouldIgnoreMessage;
        }

        return filterMap.commits(message) && shouldIgnoreMessage;
    }

    /**
     * Return a commit messages generated body
     *
     * @since 0.1.0
     * @private
     *
     * @param  {Array} commits
     *
     * @return {string}
     */
    _generateCommitsBody(commits = []) {
        const bodyMessages = Array.from(commits);

        if (bodyMessages.length === 1) {
            bodyMessages.push(null);
        }

        return bodyMessages
            .slice(0, -1)
            .filter(this._filterCommit.bind(this))
            .map(this._templateCommits.bind(this))
            .join('\n');
    }

    /**
     * Gets all the commits between two dates
     *
     * @since 0.1.0
     * @private
     *
     * @param  {string} since The since date in ISO
     * @param  {string} until The until date in ISO
     *
     * @return {Promise}      The promise which resolves the [Array] commit messages
     */
    async _getCommitsBetweenTwo(since, until) {
        const options = {
            since: since,
            until: until,
            per_page: 100
        };

        const { data } = await this.repo.listCommits(options);

        return data;
    }

    /**
     * Get the blocks of commits based on release dates
     *
     * @since 0.5.0
     * @private
     *
     * @param  {Array} releaseRanges The array of date ranges
     *
     * @return {Promise[]}
     */
    async _getCommitBlocks(releaseRanges) {
        const taskName = 'Creating the body blocks from commits';
        const loaded = utils.task(this, taskName);

        const ranges = await Promise.all(
            releaseRanges
                .map(async range => {
                    const [{ date: until }, { date: since }] = range;

                    this.tasks[taskName].text = `Get commits between ${utils.formatDate(new Date(since))} and ${utils.formatDate(new Date(until))}`;
                    const commits = await this._getCommitsBetweenTwo(since, until);

                    return {
                        id: range[0].id,
                        name: this.options.prefix + range[0].name,
                        release: range[0].name,
                        published_at: range[0].date,
                        body: this._generateCommitsBody(commits) + '\n'
                    };
                })
        );

        loaded(`Commit ranges loaded: ${ranges.length}`);

        return ranges;
    }

    /**
     * Compare the ignored labels with the passed ones
     *
     * @since 0.10.0
     * @private
     *
     * @param  {Array} labels   The labels to check
     * @example [{
     *     name: 'bug'
     * }]
     *
     * @return {boolean}    If the labels array contains any of the ignore ones
     */
    _lablesAreIgnored(labels) {
        if (!labels || !Array.isArray(labels)) {
            return false;
        }

        const { ignoreIssuesWith } = this.options;

        return ignoreIssuesWith.some(label => labels.map(({ name }) => name).includes(label));
    }

    /**
     * Get all the closed issues from the current repo
     *
     * @since 0.5.0
     * @private
     *
     * @param  {Array} releaseRanges The array of date ranges
     *
     * @return {Promise} The promise which resolves the list of the issues
     */
    async _getClosedIssues(releaseRanges) {
        const type = {
            issues: 'Issues',
            milestones: 'Issues'
        }[this.options.dataSource];
        const loaded = utils.task(this, `Getting all closed ${type}`);
        const { data: issues } = await this.issues.listIssues({
            state: 'closed',
            since: releaseRanges[releaseRanges.length - 1][1].date
        });

        loaded(`${type} found: ${issues.length}`);

        return issues;
    }

    /**
     * Group the issues based on their first label
     *
     * @since 0.8.0
     * @private
     *
     * @param  {Array} issues
     *
     * @return {string}
     */
    _groupByLabel(issues) {
        const groups = [];

        Object.values(ObjectAssign({}, issues)).forEach(issue => {
            if (!issue.labels.length) {
                if (!this.options.template.noLabel) {
                    return;
                }

                issue.labels.push({name: this.options.template.noLabel});
            }

            const labelName = issue.labels[0].name;

            if (!groups[labelName]) {
                groups[labelName] = [];
            }

            groups[labelName].push(this._templateIssue(issue));
        });

        return this._templateGroups(utils.sortObject(groups));
    }

    /**
     * Create groups of issues based on labels
     *
     * @since  0.8.0
     * @private
     *
     * @param  {Array} issues The array of all the issues.
     *
     * @return {Array}
     */
    _groupBy(passedIssues) {
        const { groupBy } = this.options;
        const issues = Object.values(ObjectAssign({}, passedIssues));

        if (!groupBy || groupBy === 'false') {
            return issues.map(this._templateIssue.bind(this));
        }

        if (groupBy === 'label') {
            return this._groupByLabel(issues);
        }

        if (typeof groupBy !== 'object' || Array.isArray(groupBy)) {
            throw chalk.red('The option for groupBy is invalid, please check the documentation');
        }

        const allLabels = Object.values(groupBy).reduce((carry, group) => carry.concat(group), []);
        const groups = Object.keys(groupBy).reduce((carry, group, i, arr) => {
            const groupIssues = issues.filter(issue => {
                if (!issue.labels.length && this.options.template.noLabel) {
                    issue.labels.push({name: this.options.template.noLabel});
                }

                return issue.labels.some(label => {
                    const isOtherLabel = groupBy[group].indexOf('...') !== -1 && allLabels.indexOf(label.name) === -1;

                    return groupBy[group].indexOf(label.name) !== -1 || isOtherLabel;
                }) && !arr.filter(title => carry[title]).some(title => carry[title].indexOf(this._templateIssue(issue)) !== -1);
            }).map(this._templateIssue.bind(this));

            if (groupIssues.length) {
                carry[group] = groupIssues;
            }

            return carry;
        }, {});

        return this._templateGroups(groups);
    }

    /**
     * Filter the issue based on gren options and labels
     *
     * @since 0.9.0
     * @private
     *
     * @param  {Object} issue
     *
     * @return {Boolean}
     */
    _filterIssue(issue) {
        const { dataSource } = this.options;

        return (issue.pull_request ? dataSource === 'prs' : dataSource === 'issues' | dataSource === 'milestones') && !this._lablesAreIgnored(issue.labels) &&
            !((this.options.onlyMilestones || dataSource === 'milestones') && !issue.milestone);
    }

    /**
     * Filter the pull request based on gren options and labels
     * @private
     *
     * @param  {Object} pullRequest
     *
     * @return {Boolean}
     */
    _filterPullRequest(pullRequest) {
        return !this._lablesAreIgnored(pullRequest.labels) && !(this.options.onlyMilestones && !pullRequest.milestone);
    }

    /**
     * Filter the issue based on the date range, or if is in the release
     * milestone.
     *
     * @since 0.9.0
     * @private
     *
     * @param  {Array} range The release ranges
     * @param  {Object} issue GitHub issue
     *
     * @return {Boolean}
     */
    _filterBlockIssue(range, issue) {
        if (this.options.dataSource === 'milestones') {
            return this.options.milestoneMatch.replace('{{tag_name}}', range[0].name) === issue.milestone.title;
        }

        return utils.isInRange(
            Date.parse(issue.closed_at),
            Date.parse(range[1].date),
            Date.parse(range[0].date)
        );
    }

    /**
     * Filter the pull requests in case the release is milestone,
     * or otherwise by dates range.
     *
     * @private
     *
     * @param  {Array} range The release ranges
     * @param  {Object} pullRequest GitHub pull request
     *
     * @return {Boolean}
     */
    _filterBlockPullRequest(range, pullRequest) {
        if (this.options.dataSource === 'milestones') {
            return this.options.milestoneMatch.replace('{{tag_name}}', range[0].name) === pullRequest.milestone.title;
        }

        return utils.isInRange(
            Date.parse(pullRequest.merged_at),
            Date.parse(range[1].date),
            Date.parse(range[0].date)
        );
    }

    /**
     * Get the blocks of issues based on release dates
     *
     * @since 0.5.0
     * @private
     *
     * @param  {Array} releaseRanges The array of date ranges
     *
     * @return {Promise[]}
     */
    async _getIssueBlocks(releaseRanges) {
        const issues = await this._getClosedIssues(releaseRanges);
        const release = releaseRanges
            .map(range => {
                const filteredIssues = Array.from(issues)
                    .filter(this._filterIssue.bind(this))
                    .filter(this._filterBlockIssue.bind(this, range));
                const body = (!range[0].body || this.options.override) && this._groupBy(filteredIssues);
                return {
                    id: range[0].id,
                    release: range[0].name,
                    name: this.options.prefix + range[0].name,
                    published_at: range[0].date,
                    body: this._templateBody(body, range[0].body)
                };
            });

        return release;
    }
    /**
     * Get the blocks of pull requests based on the release dates
     *
     * @private
     *
     * @param  {Array} releaseRanges The array of date ranges
     *
     * @return {Promise[]}
     */
    async _getPullRequestsBlocks(releaseRanges) {
        const loaded = utils.task(this, `Getting all merged pull requests`);
        const since = releaseRanges[releaseRanges.length - 1][1].date;
        const prs = await this._getMergedPullRequests(since);

        let totalPrs = 0;
        const release = releaseRanges
            .map(range => {
                const filteredPullRequests = Array.from(prs)
                    .filter(this._filterPullRequest.bind(this))
                    .filter(this._filterBlockPullRequest.bind(this, range));
                totalPrs += filteredPullRequests.length;
                const body = (!range[0].body || this.options.override) && this._groupBy(filteredPullRequests);
                return {
                    id: range[0].id,
                    release: range[0].name,
                    name: this.options.prefix + range[0].name,
                    published_at: range[0].date,
                    body: this._templateBody(body, range[0].body)
                };
            });
        loaded(`Pull Requests found: ${totalPrs}`);
        return release;
    }

    /**
     * Sort releases by dates
     *
     * @since 0.5.0
     * @private
     *
     * @param {Array} releaseDates
     *
     * @return {Array}
     */
    _sortReleasesByDate(releaseDates) {
        return Array.from(releaseDates).sort((release1, release2) => new Date(release2.date) - new Date(release1.date));
    }

    /**
     * Create the ranges of release dates
     *
     * @since 0.5.0
     * @private
     *
     * @param  {Array} releaseDates The release dates
     *
     * @return {Array}
     */
    _createReleaseRanges(releaseDates) {
        const ranges = [];
        const RANGE = 2;
        const sortedReleaseDates = this._sortReleasesByDate(releaseDates);

        if (sortedReleaseDates.length === 1 || this.options.tags.indexOf('all') >= 0) {
            sortedReleaseDates.push({
                id: 0,
                date: new Date(0)
            });
        }

        for (let i = 0; i < sortedReleaseDates.length - 1; i++) {
            // NOTE: Get one second later
            const until = (new Date(new Date(sortedReleaseDates[i + 1].date).getTime() + 1000).toISOString()).replace(/\.000Z$/, 'Z');
            ranges.push([
                sortedReleaseDates[i],
                {
                    ...sortedReleaseDates[i + RANGE - 1],
                    date: until
                }
            ]);
        }

        return ranges;
    }

    /**
     * Generate release blocks based on issues or commit messages
     * depending on the option.
     *
     * @return {Promise} Resolving the release blocks
     */
    async _getReleaseBlocks() {
        const loaded = utils.task(this, 'Getting releases');
        const dataSource = {
            issues: this._getIssueBlocks.bind(this),
            commits: this._getCommitBlocks.bind(this),
            milestones: this._getIssueBlocks.bind(this),
            prs: this._getPullRequestsBlocks.bind(this)
        };
        const releases = await this._getListReleases();
        this.tasks['Getting releases'].text = 'Getting tags';

        const tags = await this._getLastTags(releases.length ? releases : false);
        this._validateRequiredTagsExists(tags, this.options.tags);
        const releaseDates = await Promise.all(this._getTagDates(tags));

        loaded(`Tags found: ${tags.map(({ tag: { name } }) => name).join(', ')}`);

        return dataSource[this.options.dataSource](
            this._createReleaseRanges(releaseDates)
        );
    }

    /**
     * Check that the require tags are exists in tags
     *
     * @param {Array} tags
     * @param {Array} requireTags
     *
     * @throws{Exception} Will throw exception in case that
     * @requireTags were set to 2 specific tags and these tags aren't exists in @tags
     */
    _validateRequiredTagsExists(tags, requireTags) {
        if (requireTags.indexOf('all') >= 0 || !(requireTags instanceof Array)) return;

        const tagsNames = tags.map(tagData => tagData.tag.name);

        const missingTags = requireTags.filter(requireTag => tagsNames.indexOf(requireTag) < 0);
        if (missingTags.length > 0) {
            const inflection = (missingTags.length === 1) ? 'tag is' : 'tags are';
            throw chalk.red(`\nThe following ${inflection} not found in the repository: ${missingTags}. ` +
                'please provide existing tags.');
        }
    }

    /**
     * Check if there is connectivity
     *
     * @since 0.5.0
     * @private
     *
     * @return {Promise}
     */
    _hasNetwork() {
        return new Promise(resolve => {
            connectivity(isOnline => {
                if (!isOnline) {
                    console.warn(chalk.yellow('WARNING: Looks like you don\'t have network connectivity!'));
                }

                resolve(isOnline);
            });
        });
    }

    /**
     * Output the options in the terminal in a formatted way
     *
     * @param  {Object} options
     */
    _outputOptions(options) {
        const camelcaseToSpaces = value => value.replace(/([A-Z])/g, ' $1').toLowerCase().replace(/\w/, a => a.toUpperCase());
        const outputs = Object.entries(options)
            .filter(option => option !== 'debug')
            .map(([key, value]) => `${chalk.yellow(camelcaseToSpaces(key))}: ${value.toString() || 'empty'}`);

        process.stdout.write('\n' + chalk.blue('Options: \n') + outputs.join('\n') + '\n');
    }
}

export default Gren;
