'use strict'

const format = require('util').format

class Context {
  static get (opts) {
    return new Context(opts)
  }

  constructor (opts) {
    opts = opts || {}
    // dependencies
    this._utils = opts.utils
    this._pathLib = opts.pathLib
    this._fsLib = opts.fsLib
    // config
    this.types = {}
    // args to parse per type
    this.args = []
    this.slurped = []
    // values by type, keyed by type.id
    this.values = new Map()
    this.sources = new Map()
    // results of parsing and validation
    this.code = 0
    this.output = ''
    this.argv = {}
    this.knownArgv = {}
    this.details = { args: [], types: [] }
    this.errors = []
    this.messages = []
    // other
    this.commandHandlerRun = false
    this.helpRequested = false
    this.versionRequested = false
  }

  get utils () {
    if (!this._utils) this._utils = require('./lib/utils').get()
    return this._utils
  }

  get pathLib () {
    if (!this._pathLib) this._pathLib = require('path')
    return this._pathLib
  }

  get fsLib () {
    if (!this._fsLib) this._fsLib = require('fs')
    return this._fsLib
  }

  slurpArgs (args) {
    if (typeof args === 'string') args = this.utils.stringToArgs(args)
    if (!args) args = process.argv.slice(2)
    if (!Array.isArray(args)) args = [].concat(args)
    // TODO read from stdin with no args? based on config?
    const parseable = []
    const extra = []
    let isExtra = false
    for (let i = 0, len = args.length, arg; i < len; i++) {
      arg = String(args[i])
      if (arg === '--') {
        isExtra = true
        // continue
      }
      (isExtra ? extra : parseable).push(arg)
    }
    this.args = parseable
    this.details.args = parseable.concat(extra)

    // let prev = [{}]
    // this.argv = this.args.reduce((argv, arg) => {
    //   let kvArray = this.parseSingleArg(arg)
    //   kvArray.forEach(kv => {
    //     if (kv.key) argv[kv.key] = kv.value
    //     else argv._.push(kv.value)
    //   })
    //   if (!kvArray[kvArray.length - 1].key && prev[prev.length - 1].key) {
    //     argv[prev[prev.length - 1].key] = kvArray[kvArray.length - 1].value
    //     argv._ = argv._.slice(0, -1)
    //   }
    //   prev = kvArray
    //   return argv
    // }, { _: [] })
    // console.log('context.js > argv:', this.argv)

    this.slurped = this.args.map((arg, index) => {
      return {
        raw: arg,
        index,
        parsed: this.parseSingleArg(arg)
      }
    })
    // console.log('context.js > slurped:', JSON.stringify(this.slurped, null, 2))

    return this
  }

  parseSingleArg (arg) {
    // short-circuit if no flag
    const numBeginningDashes = (arg.match(/^-+/) || [''])[0].length
    if (numBeginningDashes === 0) {
      return [{
        key: '',
        value: arg
      }]
    }
    // otherwise check for =value somewhere in arg
    const kvDelimIndex = arg.indexOf('=')
    const flags = kvDelimIndex > 1 ? arg.substring(numBeginningDashes, kvDelimIndex) : arg.slice(numBeginningDashes)
    const value = kvDelimIndex > 1 ? arg.substring(kvDelimIndex + 1) : undefined
    // allow an arg of just dashes e.g. '-'
    if (!flags && !value) {
      return [{
        key: '',
        value: arg
      }]
    }
    // can only be one flag with more than 1 dash
    if (numBeginningDashes > 1) {
      return [{
        key: flags,
        value: value || true
      }]
    }
    // may be multiple single-length flags, with value belonging to the last one
    const kvArray = flags.split('').map(flag => {
      return {
        key: flag,
        value: true
      }
    })
    if (value) kvArray[kvArray.length - 1].value = value
    return kvArray
  }

  pushLevel (level, types) {
    this.types[level] = types
    return this
  }

  unexpectedError (err) {
    this.errors.push(err)
    this.output = String((err && err.stack) || err)
    this.code++
  }

  cliMessage (msg) {
    // do NOT modify this.code here - the messages will be disregarded if help is requested
    const argsLen = arguments.length
    const args = new Array(argsLen - 1)
    for (let i = 0; i < argsLen; ++i) {
      args[i] = arguments[i]
      // if any args are an array, join into string
      // this is a hack to get Node 12's util.format working like Node 10's
      // e.g. require('util').format("Value \"%s\" is invalid.", ["web", "docs"])
      // Node 10: Value "web,docs" is invalid.
      // Node 12: Value "[ 'web', 'docs' ]" is invalid.
      if (Array.isArray(args[i])) {
        args[i] = args[i].join(',')
      }
    }
    this.messages.push(format.apply(null, args))
  }

  markTypeInvalid (id) {
    const mappedLevels = Object.keys(this.types)
    for (let i = mappedLevels.length - 1, currentLevel, found; i >= 0; i--) {
      currentLevel = mappedLevels[i]
      found = (this.types[currentLevel] || []).find(type => type.id === id)
      if (found) {
        found.invalid = true
        return
      }
    }
  }

  explicitCommandMatch (level) {
    if (!this.argv._ || !this.argv._.length) return false
    const candidate = this.argv._[0]
    return (this.types[level] || []).some(type => type.datatype === 'command' && type.aliases.some(alias => alias === candidate))
  }

  matchCommand (level, aliases, isDefault) {
    if (!this.argv._ || this.versionRequested) return false // TODO what to do without an unknownType?
    // first determine if argv._ starts with ANY known command alias
    const matchFound = this.explicitCommandMatch(level)
    const candidate = this.argv._[0]
    return {
      explicit: matchFound && aliases.some(alias => alias === candidate),
      implicit: !matchFound && isDefault && !this.helpRequested,
      candidate: candidate
    }
  }

  deferHelp (opts) {
    this.helpRequested = opts || {}
    return this
  }

  addDeferredHelp (helpBuffer) {
    const groups = {}
    const mappedLevels = Object.keys(this.types)
    for (let i = mappedLevels.length - 1, currentLevel; i >= 0; i--) {
      currentLevel = mappedLevels[i]
      ;(this.types[currentLevel] || []).forEach(type => {
        if (currentLevel === helpBuffer._usageName || type.datatype !== 'command') {
          if (this.helpRequested) type.invalid = false
          groups[type.helpGroup] = (groups[type.helpGroup] || []).concat(type)
        }
      })
    }
    helpBuffer.groups = groups

    if (!this.helpRequested) {
      helpBuffer.messages = this.messages
      this.code += this.messages.length
    }

    // add/set output to helpBuffer.toString()
    this.output = helpBuffer.toString(this.helpRequested)
    return this
  }

  addHelp (helpBuffer, opts) {
    return this.deferHelp(opts).addDeferredHelp(helpBuffer)
  }

  deferVersion (opts) {
    this.versionRequested = opts || {}
    return this
  }

  addDeferredVersion () {
    if (!(this.versionRequested && this.versionRequested.version)) {
      let dir = this.pathLib.dirname(require.main.filename)
      const root = this.pathLib.parse(dir).root
      let version
      let attempts = 0 // protect against infinite tight loop if libs misbehave
      while (dir !== root && attempts < 999) {
        attempts++
        try {
          version = JSON.parse(this.fsLib.readFileSync(this.pathLib.join(dir, 'package.json'), 'utf8')).version
          if (version) break
        } catch (_) {
          dir = this.pathLib.dirname(dir)
        }
      }
      if (!this.versionRequested) this.versionRequested = {}
      this.versionRequested.version = version || 'Version unknown'
    }
    if (typeof this.versionRequested.version === 'function') this.output = this.versionRequested.version()
    else this.output = this.versionRequested.version
    return this
  }

  // weird method names make for easier code searching
  assignValue (id, value) {
    this.values.set(id, value)
  }

  lookupValue (id) {
    return this.values.get(id)
  }

  resetSource (id, source) {
    this.sources.set(id, { source: source, position: [], raw: [] })
  }

  employSource (id, source, position, raw) {
    let obj = this.lookupSource(id)
    if (!obj) {
      obj = { source: undefined, position: [], raw: [] }
      this.sources.set(id, obj)
    }
    if (typeof source === 'string') obj.source = source
    if (typeof position === 'number') obj.position.push(position)
    if (typeof raw === 'string') obj.raw.push(raw)
  }

  lookupSource (id) {
    return this.sources.get(id)
  }

  lookupSourceValue (id) {
    const obj = this.lookupSource(id)
    return obj && obj.source
  }

  populateArgv (typeResults) {
    let detailIndex
    typeResults.forEach(tr => {
      // find and reset detailed object; otherwise add it
      detailIndex = this.details.types.findIndex(t => t.parent === tr.parent && t.datatype === tr.datatype && this.utils.sameArrays(tr.aliases, t.aliases))
      if (detailIndex !== -1) this.details.types[detailIndex] = tr
      else this.details.types.push(tr)

      // if not command, set value for each alias in argv
      if (tr.datatype === 'command') return undefined // do not add command aliases to argv
      tr.aliases.forEach(alias => {
        this.argv[alias] = tr.value
        this.knownArgv[alias] = tr.value
      })
    })
  }

  getUnknownArguments () {
    if (!Array.isArray(this.argv._)) return []
    const endOptions = this.argv._.indexOf('--')
    return this.argv._.slice(0, endOptions === -1 ? this.argv._.length : endOptions)
  }

  getUnknownSlurpedOptions () {
    return Object.keys(this.argv).filter(key => !(key in this.knownArgv)).map(key => {
      return this.slurped.find(arg => arg.parsed.some(p => p.key === key))
    })
  }

  toResult () {
    return {
      code: this.code,
      output: this.output,
      errors: this.errors,
      argv: this.argv,
      details: this.details
    }
  }
}

module.exports = Context