text: const { file, parser, logger, checker, m3u } = require('../../core')
  const { program } = require('commander')
  
  program
    .argument('[filepath]', 'Path to file to validate')
    .option('-t, --timeout <timeout>', 'Set timeout for each request', parser.parseNumber, 60000)
    .option('-d, --delay <delay>', 'Set delay for each request', parser.parseNumber, 0)
    .option('--debug', 'Enable debug mode')
    .parse(process.argv)
  
  const options = program.opts()
  
  async function main() {
    const files = program.args.length ? program.args : await file.list('streams/*.m3u')
  
    for (const filepath of files) {
      if (!filepath.endsWith('.m3u')) continue
      logger.info(`${filepath}`)
      const playlist = await parser.parsePlaylist(filepath)
      const before = playlist.items.length
      for (const stream of playlist.items) {
        if (options.debug) logger.info(stream.url)
        const [_, status] = stream.raw.match(/status="([a-z]+)"/) || [null, null]
        stream.status = status
        if (status === 'error' && /^(http|https)/.test(stream.url)) {
          const result = await checkStream(stream)
          const newStatus = parseStatus(result.error)
          if (status === newStatus) {
            stream.remove = true
            logger.info(`removed "${stream.name}"`)
          }
        }
      }
  
      const items = playlist.items
        .filter(i => !i.remove)
        .map(item => ({
          attrs: {
            'tvg-id': item.tvg.id,
            status: item.status,
            'user-agent': item.http['user-agent'] || undefined
          },
          title: item.name,
          url: item.url,
          vlcOpts: {
            'http-referrer': item.http.referrer || undefined,
            'http-user-agent': item.http['user-agent'] || undefined
          }
        }))
  
      if (before !== items.length) {
        const output = m3u.create(items)
        await file.create(filepath, output)
        logger.info(`saved`)
      }
    }
  }
  
  main()
  
  async function checkStream(item) {
    const config = {
      timeout: options.timeout,
      delay: options.delay,
      debug: options.debug
    }
  
    const request = {
      url: item.url,
      http: {
        referrer: item.http.referrer,
        'user-agent': item.http['user-agent']
      }
    }
  
    return checker.check(request, config)
  }
  
  function parseStatus(error) {
    if (!error) return 'online'
  
    switch (error) {
      case 'Operation timed out':
        return 'timeout'
      case 'Server returned 403 Forbidden (access denied)':
        return 'blocked'
      default:
        return 'error'
    }
  }
  