import { build, fs, IParameters, http, install, logger, strings, semver, inquirer } from '../index'
import { parseParams } from '../toolbox/parameter-tools'
import { machineIdSync } from 'node-machine-id'
import * as path from 'path'

const debug = require('debug')('weex:core')

export enum ModType {
  PLUGIN,
  EXTENSION,
}

export enum ErrorType {
  PACKAGE_VERSION_NOT_FOUND = 101,
  PACKAGE_NOT_FOUND,
}
export interface ModData {
  mods: {
    [key: string]: ModItem
  }
  last_update_time: number
}

export interface Command {
  name?: string
  alias?: string
  dashed?: boolean
  description?: string
}

export interface ModItem {
  type: ModType
  version: string
  description: string
  dependencies?: {
    [key: string]: string
  }
  next_version?: string
  is_next?: boolean
  changelog?: string
  local: string
  commands?: string[]
}
export interface PluginItem {
  value?: string
  options?: any
  commands?: {
    name: string
    alias: string
    description: string
    showed: boolean
  }[]
  name?: string
}

export interface CliConfiguration {
  cliVersion: string
  corePath: string
  coreName: string
  coreRoot: string
  moduleRoot: string
  moduleConfigFileName: string
  home: string
  registry: string
  argv: string
  trash: string
  modules: ModData
  globalConfigFileName: string
  force?: boolean
  configs?: {
    [key: string]: any
  }
  ENVS?: any
}

export interface CoreOptions {
  brand?: string
  help?: any
  defaultCommand?: any
  version?: any
  plugin?: {
    value?: string
    options?: any
  }
  plugins?: {
    value?: string
    options?: any
  }
  exclude?: string[]
}
// use for analyzer function
let cliConfiguration: CliConfiguration

export default class Cli {
  private cli: any
  private updateTime: number
  private rawArgv: string[] | string
  private argv: IParameters
  private plugins: PluginItem[] = []
  private cliConfiguration: CliConfiguration
  constructor(data: CliConfiguration, options: CoreOptions = {}) {
    debug('Init Cli instance on <%s>', __filename)
    this.rawArgv = data.argv

    this.updateTime = data.configs.update_time || 7

    this.argv = parseParams(data.argv)

    this.cliConfiguration = cliConfiguration = {
      ...data,
      force: this.argv.options.f || this.argv.options.force,
    }
    // create a CLI runtime
    this.cli = build(options.brand || 'weex')
      .src(__dirname)
      .help(options.help)
      .version(options.version)
      .exclude(options.exclude)
      .defaultCommand(options.defaultCommand)

    if (options.plugins && options.plugins.value) {
      this.cli = this.cli.plugins(options.plugins.value, options.plugins.options)
    }

    if (!this.cliConfiguration.modules.mods) {
      this.cliConfiguration.modules['mods'] = {}
      this.cliConfiguration.modules['last_update_time'] = new Date().getTime()
    }

    if (options.plugin) {
      if (Array.isArray(options.plugin)) {
        options.plugin.forEach(p => {
          this.cli = this.cli.plugin(p.value, p.options)
        })
      } else {
        this.cli = this.cli.plugin(options.plugin.value, options.plugin.options)
      }
    }
  }

  async start() {
    const command = this.argv.array[0]
    const moduleConfigFilePath = path.join(this.cliConfiguration.moduleRoot, this.cliConfiguration.moduleConfigFileName)
    const pkg = require('../../package.json')
    
    const traceData = {
      cmd: command || '',
      argv: this.argv.array.join('+'),
      mid: machineIdSync(),
      node: process.version,
      core: pkg.version
    }
    usertrack('usage', traceData, this.cliConfiguration.configs.telemetry)

    if (this.cliConfiguration.modules) {
      this.plugins = pickPlugins(this.cliConfiguration.modules)
    } else {
      fs.write(moduleConfigFilePath, {
        mods: {},
        last_update_time: new Date().getTime(),
      })
    }
    if (command === 'repair') {
      debug(`Do repair`)
    } else if (command === 'config') {
      debug('Do config')
    } else if (command === 'install') {
      debug('Do install')
    } else if (command === 'uninstall') {
      debug('Do uninstall')
    } else if (command) {
      const plugin = searchPlugin(command, this.plugins)
      let commands = []
      let type = ModType.EXTENSION
      // If the module has been instll, skip
      if (!plugin || !plugin.name) {
        let packageSubName = command
        if (command === 'create' || command === 'platform') {
          packageSubName = 'generator'
        }
        const res: { error?: string; [key: string]: any } = await suggestPackage(
          packageSubName,
          this.cliConfiguration.configs.registry,
        )
        if (res && !res.error) {
          const packages: any = await installPackage(this.cliConfiguration, `@weex-cli/${packageSubName}`, 'latest', {
            root: this.cliConfiguration.moduleRoot,
            registry: this.cliConfiguration.configs.registry,
            force: this.cliConfiguration.force,
            ENVS: this.cliConfiguration.configs.ENVS,
          })
          for (let i = 0; i < packages.length; i++) {
            const commandBasePath = path.join(packages[i].root, 'commands')
            const extensionBasePath = path.join(packages[i].root, 'extensions')
            const commandFiles: string[] = fs.list(commandBasePath) || []
            commands = []
            // continue next package while the package has not commands and extensions folder
            if (!fs.existsAsync(commandBasePath) && !fs.existsAsync(extensionBasePath)) {
              continue
            }
            commandFiles.forEach(file => {
              let content: Command = {}
              try {
                content = require(path.join(commandBasePath, file))
              } catch (e) {
                debug(`Check module error with: ${e.stack}`)
                // try prev version
              }
              if (content.name) {
                commands.push({
                  name: content.name || '',
                  alias: content.alias || '',
                  showed: typeof content.dashed === 'boolean' ? !content.dashed : true,
                  description: content.description || '',
                })
                type = ModType.PLUGIN
              } else {
                type = ModType.EXTENSION
              }
            })

            this.cliConfiguration.modules.mods[packages[i].package.name] = {
              type: type,
              version: packages[i].package.version,
              description: packages[i].package.description || '',
              dependencies: packages[i].package.pluginDependencies,
              next_version: '',
              is_next: true,
              changelog: packages[i].package.changelog || '',
              local: packages[i].root,
              commands: commands,
            }
            this.plugins.push({
              value: packages[i].root,
              options: {},
              commands: commands,
              name: packages[i].package.name,
            })
          }
          // update module file
          fs.write(moduleConfigFilePath, {
            mods: this.cliConfiguration.modules.mods,
            last_update_time: new Date().getTime(),
          })
        }
      } else {
        // check if there has some module need to be upgraded
        // check last_update_time
        const info: any = await updateNpmPackageInfo(
          this.cliConfiguration.modules,
          this.cliConfiguration.configs.registry,
          this.updateTime,
        )
        if (info) {
          let upgradeList = {}
          for (let mod in info.mods) {
            if (!info.mods[mod].is_next) {
              upgradeList[mod] = info.mods[mod]
            }
          }
          const generateChangelog = (changelog: any[] | string): string => {
            if (!changelog) {
              return ''
            }
            if (typeof changelog === 'string') {
              changelog = [changelog]
            }
            changelog = changelog.map(log => `\n    • ${log}`)
            return `\n  changelog:${changelog.join('')}`
          }

          let lists = Object.keys(upgradeList).map(key => {
            return {
              name: `${key} ${logger.colors.grey(
                `${upgradeList[key].version} -> ${upgradeList[key].next_version}${generateChangelog(
                  upgradeList[key].changelog,
                )}`,
              )}`,
              value: key,
            }
          })
          let yes = 'Yes, update all'
          let no = 'No, next time'
          let choices = [yes, no, new inquirer.Separator('Or choose update package')].concat(lists)
          if (lists.length > 0) {
            let res = await inquirer.prompt({
              name: 'choose',
              type: 'list',
              choices: choices,
              default: yes,
              message: 'New update detected, update now?',
            })
            if (yes === res.choose) {
              for (let item in upgradeList) {
                await repairPackage(this.cliConfiguration, item, upgradeList[item].next_version)
                logger.success(
                  `[${logger.checkmark}] Upgrade ${item} ${upgradeList[item].version} -> ${
                    upgradeList[item].next_version
                  } success`,
                )
              }
              logger.success(`All task completed.`)
            } else if (no !== res.choose) {
              await repairPackage(this.cliConfiguration, res.choose, upgradeList[res.choose].next_version)
              logger.success(
                `[${logger.checkmark}] Upgrade ${res.choose} ${upgradeList[res.choose].version} -> ${
                  upgradeList[res.choose].next_version
                } success`,
              )
            }
          }
          fs.write(moduleConfigFilePath, info)
        }
      }
      if (this.plugins.length > 0) {
        this.plugins.forEach(p => {
          this.cli = this.cli.plugin(p.value, p.options)
        })
      }
    }
    // run the cli
    const toolbox = await this.cli.create().run(this.rawArgv, { __config: this.cliConfiguration, __analyzer: analyzer })
    // send it back (for testing, mostly)
    return toolbox
  }
}

/**
 * Repair npm package
 *
 * @param name npm package name
 * @param version npm package version
 */
export async function repairPackage(config: CliConfiguration, name: string, version: string) {
  let commands = []
  let type = ModType.EXTENSION
  const moduleConfigFilePath = path.join(config.moduleRoot, config.moduleConfigFileName)
  const packages: any = await installPackage(config, name, version, {
    root: config.moduleRoot,
    registry: config && config.configs && config.configs.registry,
    force: config.force,
    ENVS: config.ENVS,
  })
  for (let i = 0; i < packages.length; i++) {
    let commandBasePath = path.join(packages[i].root, 'commands')
    let commandFiles: string[] = fs.list(commandBasePath) || []
    commandFiles.forEach(file => {
      let content
      try {
        content = require(path.join(commandBasePath, file))
      } catch (e) {
        debug(`Check module error with: ${e.stack}`)
        // try prev version
      }
      commands.push({
        name: (content && content.name) || '',
        alias: (content && content.alias) || '',
        showed: content && typeof content.dashed === 'boolean' ? !content.dashed : true,
        description: (content && content.description) || '',
      })
      type = ModType.PLUGIN
    })
    if (commands.length > 0) {
      config.modules.mods[packages[i].package.name] = {
        type: type,
        version: packages[i].package.version,
        description: packages[i].package.description || '',
        dependencies: packages[i].package.pluginDependencies,
        next_version: '',
        is_next: true,
        changelog: packages[i].package.changelog || '',
        local: packages[i].root,
        commands: commands,
      }
      commands = []
    } else {
      config.modules.mods[packages[i].package.name] = {
        type: type,
        version: packages[i].package.version,
        description: packages[i].package.description || '',
        dependencies: packages[i].package.pluginDependencies,
        next_version: '',
        is_next: true,
        changelog: packages[i].package.changelog || '',
        local: packages[i].root,
      }
    }
  }
  debug(`save modjson: ${JSON.stringify(config.modules.mods)}`)
  // update module file
  fs.write(moduleConfigFilePath, {
    mods: config.modules.mods,
    last_update_time: new Date().getTime(),
  })
}

/**
 * Install packages
 *
 * @param name package name
 * @param version package version
 * @param options install options
 * @param result data from reduce
 */
export async function installPackage(
  config: CliConfiguration,
  name: string,
  version: string,
  options: any,
  result: any = [],
) {
  const info: any = await install(name, version || 'latest', options)
  let res = result.concat(info)
  if (info.package.pluginDependencies) {
    for (let name in info.package.pluginDependencies) {
      res = await installPackage(config, name, info.package.pluginDependencies[name], options, res)
    }
  }
  return res
}

/**
 * Suggest if there has a official module for the command.
 *
 * @param command command name
 * @param registry npm registry
 */
export async function suggestPackage(command: string, registry: string = 'https://registry.npm.taobao.org/') {
  const npmApi = http.create({
    baseURL: `${registry}${registry.slice(-1) === '/' ? '' : '/'}-/package/@weex-cli/`,
    timeout: 30000,
    headers: {
      Accept: '*/*',
    },
  })
  const res: any = await npmApi.get(`${command}/dist-tags`)
  if (res.problem) {
    debug('suggest package error:', res.problem)
    await analyzer('request', res.problem, { registry })
  }
  return res.data
}

/**
 * Checking if there has the package on the specified registry with specified version
 *
 * @param name package name
 * @param version package version
 * @param registry npm registry
 */
export async function checkNpmPackageExist(name: string, version: string, registry: string) {
  const npmApi = http.create({
    baseURL: `${registry}`,
  })
  const res: any = await npmApi.get(`${name}`)
  if (res && res.data.error) {
    if (/not_found/.test(res.data.error)) {
      res.data.error = ErrorType.PACKAGE_NOT_FOUND
    }
  } else if (version && version !== 'latest') {
    if (res && !res.data.versions[version]) {
      res.data.error = ErrorType.PACKAGE_VERSION_NOT_FOUND
      res.data.versions = Object.keys(res.data.versions)
    }
  }
  return res.data
}

/**
 * Check if there has some modules need to be upgraded.
 *
 * @param modules module item
 * @param registry npm registry
 * @param time update checking times, day
 */
export async function updateNpmPackageInfo(modules: ModData, registry: string, time: number = 1) {
  const modData = Object.assign({}, modules)
  const date = new Date()
  if (date.getTime() - modData.last_update_time <= 24 * 3600 * 1000 * time) {
    return false
  }
  logger.info(`Time: ${formateTime(date)}, verify if there is an update`)
  for (let mod in modData.mods) {
    let spinner = logger.spin(`Checking ${mod} ... ${logger.colors.grey('this may take a few seconds')}`)
    spinner.text = ``
    let res = await getLatestNpmPackageInfo(mod, registry)
    if (res && !res.error) {
      spinner.stopAndPersist({
        symbol: `${logger.colors.green(`[${logger.checkmark}]`)}`,
        text: `sync module [${mod}]`,
      })
      if (semver.gt(res.latest, modData.mods[mod].version)) {
        modData.mods[mod].is_next = false
        modData.mods[mod].next_version = res.latest
        modData.mods[mod].changelog = res.package.changelog || ''
      } else {
        modData.mods[mod].is_next = true
        modData.mods[mod].next_version = res.latest
        modData.mods[mod].changelog = res.package.changelog || ''
      }
    } else {
      if (res.error === ErrorType.PACKAGE_NOT_FOUND) {
        spinner.stopAndPersist({
          symbol: `${logger.colors.red(`[${logger.xmark}]`)}`,
          text: `Package [${mod}] not found on registry ${registry}`,
        })
      } else {
        spinner.stopAndPersist({
          symbol: `${logger.colors.red(`[${logger.xmark}]`)}`,
          text: `Unkonw error with checking [${mod}], ${res.error}`,
        })
      }
    }
  }
  modData.last_update_time = date.getTime()
  return modData
}

/**
 * Get the latest version of a package.
 *
 * @param name package name
 * @param registry npm registry
 * @returns {error?:string, latest?:string}
 */
export async function getLatestNpmPackageInfo(name: string, registry: string = 'https://registry.npm.taobao.org/') {
  const npmApi = http.create({
    baseURL: `${registry}`,
    timeout: 30000,
    headers: {
      Accept: '*/*',
    },
  })
  const res: any = await npmApi.get(`${registry}${registry.slice(-1) === '/' ? '' : '/'}${name}/latest`)
  let error
  if (res && res.data) {
    debug('Get latest npm package info: ', JSON.stringify(res.data))
    if (res.data.error) {
      if (/not_found/.test(res.data.error)) {
        error = ErrorType.PACKAGE_NOT_FOUND
      }
    } else if (res.data['version']) {
      const latest = res.data['version']
      return {
        latest: latest,
        package: res.data,
      }
    }
  } else {
    error = `can't found ${name} latest version`
  }
  return {
    error: error,
  }
}

/**
 * Pick suitable search from stack
 * @param stack error stack
 */
export function pickSearchKey(stack: string) {
  let res = /error:/gi.exec(stack)
  let errorIndex
  if (res) {
    errorIndex = res.index
  } else {
    errorIndex = -6
  }
  if (errorIndex) {
    return stack
      .slice(errorIndex + 6)
      .split('\n')[0]
      .split(' ')
      .join('+')
  } else {
    return stack
      .split('\n')[0]
      .split(' ')
      .join('+')
  }
}

/**
 * Show help message while catch an unknow issue
 * @param stack
 */
export function showUnknowErrorsHelp(stack: string) {
  logger.error(stack)
  logger.log(logger.colors.grey(`Search for existing GitHub issues similar to yours:`))
  let searchKey = pickSearchKey(stack)
  logger.log(`https://github.com/weexteam/weex-toolkit/issues?q=${searchKey}&type=issue`)

  logger.log(logger.colors.grey(`\nIf none exists, create a ticket, with the template displayed above, on:`))
  logger.log(`https://github.com/weexteam/weex-toolkit/issues/new`)

  logger.log(
    logger.colors.grey(
      `\nBe sure to first read the contributing guide for details on how to properly submit a ticket:`,
    ),
  )
  logger.log(`https://github.com/weexteam/weex-toolkit/master/CONTRIBUTING.md`)

  logger.log(logger.colors.grey(`\nDon't forget to anonymize any private data!`))

  logger.log(logger.colors.grey(`\nLooking for related issues on:`))
  logger.log('https://github.com/weexteam/weex-toolkit/issues?q=is%3Aclosed')
}

/**
 * Analyzer error stack and give some solution.
 *
 * @param type command type
 * @param stack error stack
 * @param options data from error stack
 */
export async function analyzer(type: string, stack: any, options?: any) {
  if (type === 'repair') {
    if (ErrorType.PACKAGE_NOT_FOUND === stack) {
      const innerMods = [
        '@weex-cli/debug',
        '@weex-cli/generator',
        '@weex-cli/build',
        '@weex-cli/preview',
        '@weex-cli/run',
        '@weex-cli/doctor',
        '@weex-cli/lint',
        '@weex-cli/device',
      ]
      let score
      let tempScore
      let suggestName
      innerMods.forEach(mod => {
        tempScore = strings.strSimilarity2Number(mod, options.name)
        if (!score) {
          score = tempScore
          suggestName = mod
        } else if (tempScore < score) {
          score = tempScore
          suggestName = mod
        }
      })
      logger.warn(`Module "${options.name}" not found, do you mean "${suggestName}"?`)
    } else if (ErrorType.PACKAGE_VERSION_NOT_FOUND === stack) {
      logger.warn(`Module "${options.name}@${options.version}" not found`)
      if (Array.isArray(options.versions) && options.versions.length > 0) {
        logger.info('Chose one of the versions:')
        options.versions.forEach(version => {
          logger.info(`- ${version}`)
        })
      }
    } else if (typeof stack === 'string') {
      if (/module is locked/.test(stack)) {
        logger.log(`The module is locked now, please be patient and wait for other installation processes to complete.`)
        logger.warn(`You can also enforce it by adding \`-f\` or \`--force\` flag.`)
      }
      showUnknowErrorsHelp(stack)
    }
  } else if (type === 'request') {
    if (stack === 'CONNECTION_ERROR') {
      logger.log(`Please check if your network can access ${logger.colors.yellow(options.registry)} normally`)
      logger.log(`Or you can use \`weex config set registry [registry-url]\` command to use other npm registry`)
    } else if (stack === 'TIMEOUT_ERROR') {
      logger.log(`Please check if your network can access ${logger.colors.yellow(options.registry)} normally`)
      logger.info(`Or you can use the \`install\` command to install the plugin.`)
    }
  } else if (type === 'compile') {
    let vueMismatchReg = /Vue packages version mismatch/gi
    if (vueMismatchReg.test(stack)) {
      logger.error(stack)
      logger.warn('\n Try `weex doctor` command to fix this problem.')
    } else {
      showUnknowErrorsHelp(stack)
    }
  } else if (typeof stack === 'string') {
    showUnknowErrorsHelp(stack)
    usertrack('error_track', {type, stack}, cliConfiguration.configs.telemetry)
  }
}

/**
 * usertrack
 * @param stage usertrack usage
 * @param track data
 * @param telemetry can report data or not
 */
export function usertrack (stage: string, track: any, telemetry: boolean) {
  if (!telemetry) {
    return 
  }
  // usertrack
  const usertrackapi = http.create({
    baseURL: `http://gm.mmstat.com/`,
  })
  let trackQuery = `weex-cli-2.0.tool_usage.${stage}?`
  for (let key in track) {
    trackQuery += `${key}=${track[key]}&`
  }
  trackQuery +=`t=${new Date().getTime()}`
  try {
    /* tslint-disabled */
    usertrackapi.get(trackQuery)
  } catch (error) {
    debug('Http request error', error)
  }
}

/**
 * Formate time to hh:mm:ss
 * @param date
 */
export function formateTime(date: Date) {
  let hourse = date.getHours() > 9 ? date.getHours() : '0' + date.getHours()
  let min = date.getHours() > 9 ? date.getMinutes() : '0' + date.getMinutes()
  let seconds = date.getSeconds() > 9 ? date.getSeconds() : '0' + date.getSeconds()
  return `${hourse}:${min}:${seconds}`
}

/**
 * Pick plugin items for cli toolbox.
 *
 * @param modules data from module.json
 */
export function pickPlugins(modules: ModData): PluginItem[] {
  if (!modules) return []
  let plugins = []
  for (let item in modules.mods) {
    let mod: ModItem = modules.mods[item]
    plugins.push({
      value: mod.local,
      options: {},
      commands: mod.commands,
      name: item,
    })
  }
  return plugins
}

/**
 * Map command to a package module.
 *
 * @param command
 * @param mods
 */
export function searchPlugin(command: string, mods: PluginItem[]): PluginItem {
  if (mods.length > 0) {
    let result
    mods.forEach((mod: PluginItem) => {
      if (mod.commands && Array.isArray(mod.commands)) {
        mod.commands.forEach(cmd => {
          if (cmd.name === command || cmd.alias === command) {
            result = mod
          }
        })
      }
    })
    return result
  } else {
    return {}
  }
}