// --------------------------------------------------------------
// Parameters
// --------------------------------------------------------------
const CONSTRAINTS_FILENAME = 'bower-constraints.json';
const DATE = new Date('2016-10-08T00:00:00Z');
const GITHUB_PASSWORD = '';
const GITHUB_USERNAME = '';
// --------------------------------------------------------------

const bluebird = require('bluebird');
const bower = require('bower');
const fs = require('fs');
const github = new require('github')({
  Promise: bluebird
});
const semver = require('semver');

const constraints = readConstraints(CONSTRAINTS_FILENAME);

getDependencies(constraints)
  .then(dependencies => {
    authenticate(GITHUB_USERNAME, GITHUB_PASSWORD);
    return getReleases(dependencies, DATE);
  })
  .then(getResults)
  .then(printResults)
  .catch(error => {
    console.log();
    console.log(error);
  });

function readConstraints(filename) {
  console.log();
  console.log(`Reading constraints from ${filename}...`);

  const json = fs.readFileSync(filename, 'utf8');
  return JSON.parse(json);
}

function getDependencies(constraints) {
  const names = Object.keys(constraints);

  return bluebird.mapSeries(names, name => {
    console.log();
    console.log(`Getting dependency ${name}...`);

    return new Promise(resolve => {
      bower.commands.info(name).on('end', firstResult => {
        bower.commands.lookup(name).on('end', secondResult => {
          const constraint = constraints[name];

          console.log(`Applying constraint ${constraint}...`);

          const filter = version => semver.satisfies(version, constraint);
          const versions = firstResult.versions.filter(filter);

          console.log(`Matching versions: ${versions.length}`);

          resolve({
            name: name,
            versions: versions,
            url: secondResult.url
          });
        });
      });
    });
  });
}

function authenticate(username, password) {
  console.log();
  console.log(`Authenticating as ${username}...`);

  github.authenticate({
    type: 'basic',
    username: username,
    password: password
  });
}

function getReleases(dependencies, date) {
  return bluebird.mapSeries(dependencies, dependency => {
    console.log();
    console.log(`Getting releases of ${dependency.name}...`);

    return bluebird.mapSeries(dependency.versions, version => {
      const parts = dependency.url.substring(19, dependency.url.length - 4).split('/');
      const owner = parts[0];
      const repo = parts[1];

      const getTag = reference => {
        return new Promise(resolve => {
          switch (reference.object.type) {
            case 'commit': {
              resolve(reference);
              break;
            }
            case 'tag': {
              return github.gitdata.getTag({
                owner: owner,
                repo: repo,
                sha: reference.object.sha
              })
                .then(getTag)
                .then(resolve);
            }
          }
        });
      };

      return new Promise(resolve => {
        github.gitdata.getReference({
          owner: owner,
          repo: repo,
          ref: `tags/${version}`
        })
          .then(resolve)
          .catch(() => {
            console.log(`Path repos/${owner}/${repo}/git/refs/tags/${version} not found`);
            console.log(`Trying with repos/${owner}/${repo}/git/refs/tags/v${version}...`);

            github.gitdata.getReference({
              owner: owner,
              repo: repo,
              ref: `tags/v${version}`
            })
              .then(resolve);
          });
      })
        .then(getTag)
        .then(tag => {
          return github.repos.getCommit({
            owner: owner,
            repo: repo,
            sha: tag.object.sha
          });
        })
        .then(commit => {
          return {
            name: dependency.name,
            version: version,
            date: new Date(commit.commit.committer.date)
          };
        });
    })
      .then(releases => {
        console.log(`Discarding versions released after ${date}...`);

        const filter = release => release.date < date;
        releases = releases.filter(filter);

        console.log(`Matching versions: ${releases.length}`);

        return releases;
      });
  })
    .then(releaseSets => {
      return [].concat.apply([], releaseSets);
    });
}

function getResults(releases) {
  const results = {};
  const dates = {};

  console.log();
  console.log('Getting results...');

  for (let release of releases) {
    const date = dates[release.name];

    if (!date || release.date > date) {
      results[release.name] = release.version;
      dates[release.name] = release.date;
    }
  }

  return results;
}

function printResults(results) {
  const names = Object.keys(results);

  console.log();
  console.log('Results:');

  for (let name of names) {
    const version = results[name];
    console.log(`${name}#${version}`);
  }
}