#!/usr/bin/env node

const parseArgs = require('minimist')

const argv = parseArgs(process.argv.slice(2), {
  alias: {
    m: 'mode',
    T: 'target',
    A: 'arch',
    b: 'bundler',
    s: 'skip-pkg',
    d: 'debug',
    h: 'help'
  },
  boolean: ['h', 'd', 'u'],
  string: ['m', 'T'],
  default: {
    m: 'spa'
  }
})

if (argv.help) {
  console.log(`
  Description
    Builds distributables of your app.
  Usage
    $ quasar build -p <port number>
  Options
    --mode, -m      App mode [spa|ssr|pwa|cordova|electron] (default: spa)
    --target, -T    App target
                      - Cordova (default: all installed)
                        [android|ios|blackberry10|browser|osx|ubuntu|webos|windows]
                      - Electron with default "electron-packager" bundler (default: yours)
                        [darwin|win32|linux|mas|all]
                      - Electron with "electron-builder" bundler (default: yours)
                        [darwin|mac|win32|win|linux|all]
    --debug, -d     Build for debugging purposes
    --skip-pkg, -s  Build only UI (skips creating Cordova/Electron executables)
                      - Cordova (it only fills in /src/cordova/www folder with the UI code)
                      - Electron (it only creates the /dist/electron/UnPackaged folder)
    --help, -h      Displays this message

    ONLY for Electron mode:
    --bundler, -b   Bundler (electron-packager or electron-builder)
                      [packager|builder]
    --arch, -A      App architecture (default: yours)
                      - with default "electron-packager" bundler:
                          [ia32|x64|armv7l|arm64|mips64el|all]
                      - with "electron-builder" bundler:
                          [ia32|x64|armv7l|arm64|all]
  `)
  process.exit(0)
}

const chalk = require('chalk')

const
  logger = require('../lib/helpers/logger'),
  log = logger('app:build'),
  warn = logger('app:build', 'red'),
  banner = require('../lib/helpers/banner')

require('../lib/helpers/ensure-argv')(argv, 'build')
banner(argv, 'build')

if (argv.mode !== 'spa') {
  require('../lib/mode/install-missing')(argv.mode, argv.target)
}

const
  path = require('path'),
  webpack = require('webpack')

const
  QuasarConfig = require('../lib/quasar-config'),
  Generator = require('../lib/generator'),
  artifacts = require('../lib/artifacts'),
  ensureDeps = require('../lib/helpers/ensure-deps'),
  getQuasarCtx = require('../lib/helpers/get-quasar-ctx'),
  extensionRunner = require('../lib/app-extension/extensions-runner')

function parseWebpackConfig (webpackConfig, mode) {
  if (mode === 'ssr') {
    return [ webpackConfig.server, webpackConfig.client ]
  }
  if (mode === 'electron') {
    return [ webpackConfig.renderer, webpackConfig.main ]
  }
  return webpackConfig
}

function finalize (mode, quasarConfig) {
  if (argv['skip-pkg'] !== true) {
    if (mode === 'cordova') {
      return require('../lib/cordova').build(quasarConfig)
    }
    if (mode === 'electron') {
      return require('../lib/electron').build(quasarConfig)
    }
  }

  return Promise.resolve()
}

async function build () {
  const ctx = getQuasarCtx({
    mode: argv.mode,
    target: argv.target,
    arch: argv.arch,
    bundler: argv.bundler,
    debug: argv.debug,
    prod: true
  })

  // register app extensions
  await extensionRunner.registerExtensions(ctx)

  const quasarConfig = new QuasarConfig(ctx)

  try {
    await quasarConfig.prepare()
  }
  catch (e) {
    console.log(e)
    warn(`⚠️ [FAIL] quasar.conf.js has JS errors`)
    process.exit(1)
  }

  await quasarConfig.compile()

  const
    generator = new Generator(quasarConfig),
    webpackConfig = quasarConfig.getWebpackConfig(),
    buildConfig = quasarConfig.getBuildConfig(),
    outputFolder = buildConfig.build.packagedElectronDist || buildConfig.build.distDir

  artifacts.clean(outputFolder)
  generator.prepare()
  generator.build()

  if (typeof buildConfig.build.beforeBuild === 'function') {
    await buildConfig.build.beforeBuild()
  }

  // run possible beforeBuild hooks
  await extensionRunner.runHook('beforeBuild', async hook => {
    log(`Extension(${hook.extId}): Running beforeBuild hook...`)
    await hook.fn()
  })

  log(chalk.bold(`Building...`))

  webpack(parseWebpackConfig(webpackConfig, argv.mode), async (err, stats) => {
    if (err) { throw err }

    artifacts.add(outputFolder)

    statsArray = stats.stats || [ stats ]
    statsArray.forEach(stat => {
      process.stdout.write('\n\n' + stat.toString({
        colors: true,
        performance: false,
        hash: false,
        assets: true,
        chunks: false,
        chunkModules: false,
        chunkOrigins: false,
        modules: false,
        nestedModules: false,
        moduleAssets: false,
        children: false
      }) + '\n\n')
    })

    statsArray.forEach(stat => {
      if (stat.hasErrors()) {
        warn()
        warn(chalk.red('[FAIL] Build failed with errors. Check log above.'))
        warn()

        process.exit(1)
      }
    })

    finalize(argv.mode, quasarConfig).then(async () => {
      banner(argv, 'build', {
        outputFolder: argv.mode === 'cordova'
          ? path.join(outputFolder, '..')
          : outputFolder
      })

      if (typeof buildConfig.build.afterBuild === 'function') {
        await buildConfig.build.afterBuild()
      }

      // run possible beforeBuild hooks
      await extensionRunner.runHook('afterBuild', async hook => {
        log(`Extension(${hook.extId}): Running afterBuild hook...`)
        await hook.fn()
      })
    })
  })
}

ensureDeps()
build()