#!/usr/bin/env node

const parseArgs = require('minimist')

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

if (argv.help) {
  console.log(`
  Description
    Builds distributables of your app.
  Usage
    $ quasar build -p <port number>
  Options
    --theme, -t    App theme (default: mat)
    --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
    --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
  appPaths = require('../lib/app-paths'),
  QuasarConfig = require('../lib/quasar-config'),
  Generator = require('../lib/generator'),
  artifacts = require('../lib/artifacts'),
  ensureDeps = require('../lib/helpers/ensure-deps')

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 (mode === 'cordova') {
    return require('../lib/cordova').build(quasarConfig)
  }
  if (mode === 'electron') {
    return require('../lib/electron').build(quasarConfig)
  }

  return Promise.resolve()
}

async function build () {
  const quasarConfig = new QuasarConfig({
    theme: argv.theme,
    mode: argv.mode,
    target: argv.target,
    arch: argv.arch,
    bundler: argv.bundler,
    debug: argv.debug,
    prod: true
  })

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

  quasarConfig.compile()

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

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

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

  webpack(parseWebpackConfig(webpackConfig, argv.mode), (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(() => {
      banner(argv, 'build', {
        outputFolder: argv.mode === 'cordova'
          ? path.join(outputFolder, '..')
          : outputFolder
      })
    })
  })
}

ensureDeps()
build()