path: root/index.js

#!/usr/bin/env node

// omg I am tired of code

const { getAllCrawlersForArg } = require('./crawlers')
const { getPlayer } = require('./players')
const { parseOptions } = require('./general-util')
const AppElement = require('./ui')
const Backend = require('./backend')
const TelnetServer = require('./telnet')
const processSmartPlaylist = require('./smart-playlist')
const setupClient = require('./client')

const {
  makeSocketServer,
  makeSocketClient,
  attachBackendToSocketClient,
  attachSocketServerToBackend
} = require('./socket')

const {
  getItemPathString,
  updatePlaylistFormat
} = require('./playlist-utils')

const {
  ui: {
    Root
  },
  util: {
    ansi,
    CommandLineInterfacer,
    Flushable
  }
} = require('tui-lib')

const { promisify } = require('util')
const fs = require('fs')
const readFile = promisify(fs.readFile)
const writeFile = promisify(fs.writeFile)

// Hack to get around errors when piping many things to stdout/err
// (from general-util promisifyProcess)
process.stdout.setMaxListeners(Infinity)
process.stderr.setMaxListeners(Infinity)

process.on('unhandledRejection', error => {
  console.error(ansi.setForeground(ansi.C_RED) + "** There was an uncatched error! **" + ansi.resetAttributes())
  console.error("Don't worry, your music files are all okay.")
  console.error("This just means there was a bug in mtui.")
  console.error("In order to verify that the program won't run weirdly, it has stopped.")
  console.error(ansi.setForeground(ansi.C_RED) + "Error stack:" + ansi.resetAttributes())
  console.error(error.stack)
  console.error(ansi.setForeground(ansi.C_RED) + "Error object:" + ansi.resetAttributes())
  console.error(error)
  console.error("(End of error log.)")
  process.stdout.write(ansi.cleanCursor())
  process.exit(1)
})

async function main() {
  const playlistSources = []

  const options = await parseOptions(process.argv.slice(2), {
    'player': {
      type: 'value',
      async validate(playerName) {
        if (await getPlayer(playerName)) {
          return true
        } else {
          return 'a known player identifier'
        }
      }
    },
    'player-options': {type: 'series'},
    'stress-test': {type: 'flag'},
    'socket-client': {type: 'value'},
    'socket-name': {type: 'value'},
    'socket-server': {type: 'value'},
    'telnet-server': {type: 'flag'},
    [parseOptions.handleDashless](option) {
      playlistSources.push(option)
    }
  })

  if (options['player-options'] && !options['player']) {
    console.error('--player must be specified in order to use --player-options')
    process.exit(1)
  }

  const backend = new Backend({
    playerName: options['player'],
    playerOptions: options['player-options']
  })

  const result = await backend.setup()
  if (result.error) {
    console.error(result.error)
    process.exit(1)
  }

  backend.on('playing', track => {
    if (track) {
      writeFile(backend.rootDirectory + '/current-track.txt',
        getItemPathString(track))
      writeFile(backend.rootDirectory + '/current-track.json',
        JSON.stringify(track, null, 2))
    }
  })

  const { appElement, dirtyTerminal, flushable, root } = await setupClient({
    backend,
    interfacer: new CommandLineInterfacer(),
    writable: process.stdout
  })

  appElement.on('quitRequested', () => {
    if (telnetServer) {
      telnetServer.disconnectAllSockets('User closed mtui - see you!')
    }
    process.exit(0)
  })

  appElement.on('suspendRequested', () => {
    process.kill(process.pid, 'SIGTSTP')
  })

  process.on('SIGCONT', () => {
    flushable.resizeScreen({lines: flushable.screenLines, cols: flushable.screenCols})
    process.stdin.setRawMode(false)
    process.stdin.setRawMode(true)
    dirtyTerminal()
    root.renderNow()
  })

  const loadPlaylists = async () => {
    for (const source of playlistSources) {
      await appElement.loadPlaylistOrSource(source, true)
    }
  }

  const loadPlaylistPromise = loadPlaylists()

  let telnetServer
  if (options['telnet-server']) {
    telnetServer = new TelnetServer(backend)
    await telnetServer.listen(1244)
    appElement.attachAsServerHost(telnetServer)
  }

  let socketClient
  let socketServer
  if (options['socket-server']) {
    socketServer = makeSocketServer()
    attachSocketServerToBackend(socketServer, backend)
    socketServer.listen(options['socket-server'])

    socketClient = makeSocketClient()
    socketClient.socket.connect(options['socket-server'])
  }

  if (options['socket-client']) {
    socketClient = makeSocketClient()
    const [ p1, p2 ] = options['socket-client'].split(':')
    const host = p2 && p1
    const port = p2 ? p2 : p1
    socketClient.socket.connect(port, host)
  }

  if (socketClient) {
    attachBackendToSocketClient(backend, socketClient, {
      getPlaylistSources: () => appElement.playlistSources
    })

    let nickname = process.env.USER
    if (options['socket-name']) {
      nickname = options['socket-name']
    }
    socketClient.setNickname(nickname)
  }

  if (options['stress-test']) {
    await loadPlaylistPromise

    const w = 80
    const h = 40
    flushable.resizeScreen({lines: w, cols: h})
    root.w = w
    root.h = h
    root.fixAllLayout()

    const XXstress = func => '[disabled]'

    const stress = func => {
      const start = Date.now()
      let n = 0
      while (Date.now() < start + 1000) {
        func()
        n++
      }
      return n
    }

    const nRenderAndFlush = stress(() => {
      root.renderTo(flushable)
      flushable.flush()
    })

    const nFixAllLayout = stress(() => {
      root.fixAllLayout()
    })

    const listings = appElement.tabber.tabberElements
    const lastListing = listings[listings.length - 1]
    const nBuildItems = stress(() => {
      lastListing.buildItems()
    })

    process.stdout.write(ansi.cleanCursor() + ansi.clearScreen() + '\n')
    console.log('# of times we can render & flush:', nRenderAndFlush)
    console.log('# of times we can fix all layout:', nFixAllLayout)
    console.log('# of times we can build items:', nBuildItems)

    process.exit(0)

    return
  }
}

main().catch(err => {
  console.error(err)
  process.exit(1)
})