'use strict'

// const install = require('./install')
const runCmd = require('./runCmd')
const getBabelCommonConfig = require('./getBabelCommonConfig')
const merge2 = require('merge2')
const { execSync } = require('child_process')
const through2 = require('through2')
const transformLess = require('./transformLess')
const webpack = require('webpack')
const babel = require('gulp-babel')
const argv = require('minimist')(process.argv.slice(2))
const GitHub = require('@octokit/rest')

const packageJson = require(`${process.cwd()}/package.json`)
// const getNpm = require('./getNpm')
// const selfPackage = require('../package.json')
const chalk = require('chalk')
const getNpmArgs = require('./utils/get-npm-args')
const getChangelog = require('./utils/getChangelog')
const path = require('path')
// const watch = require('gulp-watch')
const gulp = require('gulp')
const fs = require('fs')
const rimraf = require('rimraf')
const replaceLib = require('./replaceLib')
const stripCode = require('gulp-strip-code')
const compareVersions = require('compare-versions')

const cwd = process.cwd()
const libDir = path.join(cwd, 'lib')
const esDir = path.join(cwd, 'es')

function dist (done) {
  rimraf.sync(path.join(cwd, 'dist'))
  process.env.RUN_ENV = 'PRODUCTION'
  const webpackConfig = require(path.join(cwd, 'webpack.build.config.js'))
  webpack(webpackConfig, (err, stats) => {
    if (err) {
      console.error(err.stack || err)
      if (err.details) {
        console.error(err.details)
      }
      return
    }

    const info = stats.toJson()

    if (stats.hasErrors()) {
      console.error(info.errors)
    }

    if (stats.hasWarnings()) {
      console.warn(info.warnings)
    }

    const buildInfo = stats.toString({
      colors: true,
      children: true,
      chunks: false,
      modules: false,
      chunkModules: false,
      hash: false,
      version: false,
    })
    console.log(buildInfo)
    done(0)
  })
}

function babelify (js, modules) {
  const babelConfig = getBabelCommonConfig(modules)
  babelConfig.babelrc = false
  delete babelConfig.cacheDirectory
  if (modules === false) {
    babelConfig.plugins.push(replaceLib)
  } else {
    babelConfig.plugins.push(require.resolve('babel-plugin-add-module-exports'))
  }
  let stream = js.pipe(babel(babelConfig))
    .pipe(through2.obj(function z (file, encoding, next) {
      this.push(file.clone())
      if (file.path.match(/\/style\/index\.(js|jsx)$/)) {
        const content = file.contents.toString(encoding)
        file.contents = Buffer.from(content
          .replace(/\/style\/?'/g, '/style/css\'')
          .replace(/\.less/g, '.css'))
        file.path = file.path.replace(/index\.(js|jsx)$/, 'css.js')
        this.push(file)
        next()
      } else {
        next()
      }
    }))
  if (modules === false) {
    stream = stream.pipe(stripCode({
      start_comment: '@remove-on-es-build-begin',
      end_comment: '@remove-on-es-build-end',
    }))
  }
  return stream.pipe(gulp.dest(modules === false ? esDir : libDir))
}

function compile (modules) {
  rimraf.sync(modules !== false ? libDir : esDir)
  const less = gulp.src(['components/**/*.less'])
    .pipe(through2.obj(function (file, encoding, next) {
      this.push(file.clone())
      if (file.path.match(/\/style\/index\.less$/) || file.path.match(/\/style\/v2-compatible-reset\.less$/)) {
        transformLess(file.path).then((css) => {
          file.contents = Buffer.from(css)
          file.path = file.path.replace(/\.less$/, '.css')
          this.push(file)
          next()
        }).catch((e) => {
          console.error(e)
        })
      } else {
        next()
      }
    }))
    .pipe(gulp.dest(modules === false ? esDir : libDir))
  const assets = gulp.src(['components/**/*.@(png|svg)']).pipe(gulp.dest(modules === false ? esDir : libDir))

  const source = [
    'components/**/*.js',
    'components/**/*.jsx',
    '!components/*/__tests__/*',
  ]
  const jsFilesStream = babelify(gulp.src(source), modules)
  return merge2([less, jsFilesStream, assets])
}

function tag () {
  console.log('tagging')
  const { version } = packageJson
  execSync(`git config --global user.email ${process.env.GITHUB_USER_EMAIL}`)
  execSync(`git config --global user.name ${process.env.GITHUB_USER_NAME}`)
  execSync(`git tag ${version}`)
  execSync(`git push https://${process.env.GITHUB_TOKEN}@github.com/vueComponent/ant-design-vue.git ${version}:${version}`)
  execSync(`git push https://${process.env.GITHUB_TOKEN}@github.com/vueComponent/ant-design-vue.git master:master`)
  console.log('tagged')
}

function githubRelease (done) {
  const changlogFiles = [
    path.join(cwd, 'CHANGELOG.en-US.md'),
    path.join(cwd, 'CHANGELOG.zh-CN.md'),
  ]
  console.log('creating release on GitHub')
  if (!process.env.GITHUB_TOKEN) {
    console.log('no GitHub token found, skip')
    return
  }
  if (!changlogFiles.every(file => fs.existsSync(file))) {
    console.log('no changelog found, skip')
    return
  }
  const github = new GitHub()
  github.authenticate({
    type: 'oauth',
    token: process.env.GITHUB_TOKEN,
  })
  const date = new Date()
  const { version } = packageJson
  const enChangelog = getChangelog(changlogFiles[0], version)
  const cnChangelog = getChangelog(changlogFiles[1], version)
  const changelog = [
    `\`${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}\``,
    enChangelog,
    '\n',
    '---',
    '\n',
    cnChangelog,
  ].join('\n')
  const [_, owner, repo] = execSync('git remote get-url origin') // eslint-disable-line
    .toString()
    .match(/github.com[:/](.+)\/(.+)\.git/)
  github.repos.createRelease({
    owner,
    repo,
    tag_name: version,
    name: version,
    body: changelog,
  }).then(() => {
    done()
  })
}

gulp.task('tag', (done) => {
  tag()
  githubRelease(done)
})

gulp.task('check-git', (done) => {
  runCmd('git', ['status', '--porcelain'], (code, result) => {
    if (/^\?\?/m.test(result)) {
      return done(`There are untracked files in the working tree.\n${result}
      `)
    }
    if (/^([ADRM]| [ADRM])/m.test(result)) {
      return done(`There are uncommitted changes in the working tree.\n${result}
      `)
    }
    return done()
  })
})

function publish (tagString, done) {
  let args = ['publish', '--with-antd-tools']
  if (tagString) {
    args = args.concat(['--tag', tagString])
  }
  const publishNpm = process.env.PUBLISH_NPM_CLI || 'npm'
  runCmd(publishNpm, args, (code) => {
    tag()
    githubRelease(() => {
      done(code)
    })
  })
}

function pub (done) {
  dist((code) => {
    if (code) {
      done(code)
      return
    }
    const notOk = !packageJson.version.match(/^\d+\.\d+\.\d+$/)
    let tagString
    if (argv['npm-tag']) {
      tagString = argv['npm-tag']
    }
    if (!tagString && notOk) {
      tagString = 'next'
    }
    if (packageJson.scripts['pre-publish']) {
      runCmd('npm', ['run', 'pre-publish'], (code2) => {
        if (code2) {
          done(code2)
          return
        }
        publish(tagString, done)
      })
    } else {
      publish(tagString, done)
    }
  })
}

gulp.task('dist', ['compile'], (done) => {
  dist(done)
})
gulp.task('compile', ['compile-with-es'], (done) => {
  compile()
    .on('finish', function () {
      done()
    })
})
gulp.task('compile-with-es', (done) => {
  compile(false)
    .on('finish', function () {
      done()
    })
})

gulp.task('pub', ['check-git', 'compile'], (done) => {
  if (!process.env.GITHUB_TOKEN) {
    console.log('no GitHub token found, skip')
  } else {
    pub(done)
  }
})

gulp.task('pub-with-ci', (done) => {
  if (!process.env.NPM_TOKEN) {
    console.log('no NPM token found, skip')
  } else {
    const github = new GitHub()
    github.authenticate({
      type: 'oauth',
      token: process.env.GITHUB_TOKEN,
    })
    const [_, owner, repo] = execSync('git remote get-url origin') // eslint-disable-line
      .toString()
      .match(/github.com[:/](.+)\/(.+)\.git/)
    const getLatestRelease = github.repos.getLatestRelease({
      owner,
      repo,
    })
    const getCommits = github.repos.getCommits({
      owner,
      repo,
      per_page: 1,
    })
    Promise.all([getLatestRelease, getCommits]).then(([latestRelease, commits]) => {
      const preVersion = latestRelease.data.tag_name
      const { version } = packageJson
      const [_, newVersion] = commits.data[0].commit.message.trim().match(/bump (.+)/) || []
      if (compareVersions(version, preVersion) === 1 && newVersion && newVersion.trim() === version) {
        gulp.run('pub', (err) => {
          err && console.log('err', err)
          done()
        })
      } else {
        console.log('donot need publish' + version)
      }
    })
  }
})

function reportError () {
  console.log(chalk.bgRed('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'))
  console.log(chalk.bgRed('!! `npm publish` is forbidden for this package. !!'))
  console.log(chalk.bgRed('!! Use `npm run pub` instead.        !!'))
  console.log(chalk.bgRed('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'))
}

gulp.task('guard', (done) => {
  const npmArgs = getNpmArgs()
  if (npmArgs) {
    for (let arg = npmArgs.shift(); arg; arg = npmArgs.shift()) {
      if (/^pu(b(l(i(sh?)?)?)?)?$/.test(arg) && npmArgs.indexOf('--with-antd-tools') < 0) {
        reportError()
        done(1)
        return
      }
    }
  }
  done()
})