// Native
const { basename, resolve: resolvePath } = require('path')

// Packages
const chalk = require('chalk')
const { readFile, exists } = require('fs-promise')
const { parse: parseDockerfile } = require('docker-file-parser')

// Helpers
const { error } = require('../lib/error')

const listPackage = {
  scripts: {
    start: `NODE_ENV='production' serve ./content`
  },
  dependencies: {
    serve: '5.0.4'
  }
}

module.exports = readMetaData

async function readMetaData(
  path,
  {
    deploymentType = 'npm',
    deploymentName,
    quiet = false,
    strict = true,
    isStatic = false
  }
) {
  let pkg = {}
  let nowConfig = null
  let hasNowJson = false

  let name
  let description

  try {
    nowConfig = JSON.parse(await readFile(resolvePath(path, 'now.json')))
    hasNowJson = true
  } catch (err) {
    // If the file doesn't exist then that's fine; any other error bubbles up
    if (err.code !== 'ENOENT') {
      const e = Error(`Failed to read JSON in "${path}/now.json"`)
      e.userError = true
      throw e
    }
  }

  if (hasNowJson) {
    // User can specify the type of deployment explicitly in the `now.json` file
    // when both a package.json and Dockerfile exist
    if (nowConfig.type) {
      deploymentType = nowConfig.type
    } else if (
      !await exists(resolvePath(path, 'package.json')) &&
      !await exists(resolvePath(path, 'Dockerfile'))
    ) {
      deploymentType = 'static'
    }
    if (nowConfig.name) {
      deploymentName = nowConfig.name
    }
  }

  if (deploymentType === 'static') {
    isStatic = true
    deploymentType = 'npm'
  }

  if (deploymentType === 'npm') {
    if (isStatic) {
      pkg = listPackage
    } else {
      try {
        pkg = JSON.parse(await readFile(resolvePath(path, 'package.json')))
      } catch (err) {
        error(`Failed to read JSON in "${path}/package.json"`)

        // eslint-disable-next-line unicorn/no-process-exit
        process.exit(1)
      }
    }

    if (!deploymentName) {
      if (typeof pkg.name === 'string' && pkg.name !== '') {
        name = pkg.name
      } else {
        name = basename(path)

        if (!quiet && !isStatic) {
          console.log(
            `> No \`name\` in \`package.json\`, using ${chalk.bold(name)}`
          )
        }
      }
    }

    description = pkg.description
  } else if (deploymentType === 'docker') {
    let docker
    try {
      const dockerfile = await readFile(resolvePath(path, 'Dockerfile'), 'utf8')
      docker = parseDockerfile(dockerfile, { includeComments: true })
    } catch (err) {
      const e = Error(`Failed to parse "${path}/Dockerfile"`)
      e.userError = true
      throw e
    }

    if (strict && docker.length <= 0) {
      const e = Error('No commands found in `Dockerfile`')
      e.userError = true
      throw e
    }

    const labels = {}
    docker.filter(cmd => cmd.name === 'LABEL').forEach(({ args }) => {
      for (const key in args) {
        if (!{}.hasOwnProperty.call(args, key)) {
          continue
        }

        // Unescape and convert into string
        try {
          labels[key] = JSON.parse(args[key])
        } catch (err) {
          const e = Error(
            `Error parsing value for LABEL ${key} in \`Dockerfile\``
          )
          e.userError = true
          throw e
        }
      }
    })

    if (!deploymentName) {
      if (labels.name) {
        name = labels.name
      } else {
        name = basename(path)

        if (!quiet) {
          if (hasNowJson) {
            console.log(
              `> No \`name\` LABEL in \`Dockerfile\` or \`name\` field in \`now.json\`, using ${chalk.bold(name)}`
            )
          } else {
            console.log(
              `> No \`name\` LABEL in \`Dockerfile\`, using ${chalk.bold(name)}`
            )
          }
        }
      }
    }

    description = labels.description
  } else {
    throw new TypeError(`Unsupported "deploymentType": ${deploymentType}`)
  }

  if (deploymentName) {
    name = deploymentName
  }

  if (pkg.now) {
    // If the project has both a `now.json` and `now` Object in the `package.json`
    // file, then fail hard and let the user know that they need to pick one or the
    // other
    if (hasNowJson) {
      const e = new Error(
        'You have a `now` configuration field' +
          'inside `package.json`, but configuration is also present' +
          "in `now.json`! Please ensure there's a single source of configuration by removing one"
      )
      e.userError = true
      throw e
    } else {
      nowConfig = pkg.now
    }
  }

  return {
    name,
    description,
    deploymentType,
    pkg,
    nowConfig,
    hasNowJson
  }
}