const fs = require('fs')
const path = require('path')

const moment = require('moment-timezone')
const fetch = require('node-fetch')

const { Intents, Client, MessageEmbed } = require('discord.js')
const client = new Client({
  intents: [Intents.FLAGS.GUILDS, Intents.FLAGS.GUILD_MESSAGES, Intents.FLAGS.GUILD_MESSAGE_REACTIONS]
})

const settings = require('./settings.js')

const translations = {}
const translationsDir = fs.readdirSync(path.join(__dirname, 'i18n'))
translationsDir.forEach(i => {
  const name = i.replace('.json', '')
  translations[name] = JSON.parse(fs.readFileSync(path.join(__dirname, 'i18n', i)))
})
const translate = translations.english

if (!settings.discord.token) throw new Error(translate.noDiscordToken)
if (!settings.twitch.clientID) throw new Error(translate.noTwitchClientID)
if (!settings.twitch.clientSecret) {
  console.log(translate.includeTwitchClientSecret)
  throw new Error(translate.noTwitchClientSecret)
}

if (typeof settings.cooldownTimer === 'undefined') {
  console.log(translate.includeCooldownTimerWarning)
  settings.cooldownTimer = 21600000
}

// Create data.json if it doesn't exist.
if (!fs.existsSync(path.join(__dirname, 'data.json'))) {
  fs.writeFileSync(path.join(__dirname, 'data.json'), JSON.stringify({ guilds: {} }, null, 2))
  console.log(translate.createdDataJSON)
}
const tokenFilePath = path.join(__dirname, 'token.json')

let data = require('./data.json')

// https://stackoverflow.com/a/55435856
function chunks (arr, n) {
  function * ch (arr, n) {
    for (let i = 0; i < arr.length; i += n) {
      yield (arr.slice(i, i + n))
    }
  }

  return [...ch(arr, n)]
}

// [{ guild: id, entry: 'entry', value: 'value'}]
function saveData (d = [{ guild: '', entry: '', action: '', value: 'any' }]) {
  const dataOnFile = JSON.parse(fs.readFileSync(path.join(__dirname, 'data.json')))
  for (let index = 0; index < d.length; index++) {
    const object = d[index]
    try {
      switch (object.action) {
        case 'push':
          dataOnFile.guilds[object.guild][object.entry].push(object.value)
          break
        case 'splice':
          dataOnFile.guilds[object.guild][object.entry].splice(object.value[0], object.value[1])
          break
        case 'addGuild':
          dataOnFile.guilds[object.guild] = defaultGuildData
          break
        case 'removeGuild':
          dataOnFile.guilds[object.guild] = undefined
          break
        default:
          dataOnFile.guilds[object.guild][object.entry] = object.value
          break
      }
    } catch (e) {
      console.error(e)
    }
  }
  data = dataOnFile
  return fs.writeFileSync(path.join(__dirname, 'data.json'), JSON.stringify(dataOnFile, null, 2))
}

const cache = {
  guilds: []
}
const initialization = new Date()
const defaultGuildData = {
  streamers: [],
  announcementChannel: null,
  reactions: [],
  message: '@everyone %name% **%status%**!',
  time: { locale: Intl.DateTimeFormat().resolvedOptions().locale, timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone },
  prefix: '!',
  language: settings.language || 'english'
}

let disconnect = false
let headers = new fetch.Headers({})
let tokenExpirationDate

// Prototypal. Good for now.
function translateDefault (language) {
  const result = {}
  const lang = translations[language]
  const english = translate

  Object.keys(english).forEach(i => {
    result[i] = JSON.parse(JSON.stringify(english[i]))
    if (lang[i]) result[i] = JSON.parse(JSON.stringify(lang[i]))
  })

  Object.keys(english.commands).forEach(i => {
    result.commands[i] = JSON.parse(JSON.stringify(english.commands[i]))
    if (lang.commands[i]) result.commands[i] = JSON.parse(JSON.stringify(lang.commands[i]))

    Object.keys(english.commands[i]).forEach(ii => {
      result.commands[i][ii] = JSON.parse(JSON.stringify(english.commands[i][ii]))
      if (lang.commands[i][ii]) result.commands[i][ii] = JSON.parse(JSON.stringify(lang.commands[i][ii]))
    })
  })

  return result
}

async function refreshAppToken () {
  let tokenJSON

  if (typeof tokenExpirationDate !== 'number' && fs.existsSync(tokenFilePath)) {
    try {
      tokenJSON = JSON.parse(fs.readFileSync(tokenFilePath))
      tokenExpirationDate = tokenJSON.expiration

      console.log(translate.usingExistingToken, new Date(tokenJSON.expiration).toUTCString())
      headers = new fetch.Headers({
        Authorization: `Bearer ${tokenJSON.superSecret}`,
        'Client-ID': settings.twitch.clientID
      })

      // Validate token
      try {
        const res = await fetch('https://id.twitch.tv/oauth2/validate', {
          headers: new fetch.Headers({
            Authorization: `OAuth ${tokenJSON.superSecret}`
          })
        }).then(res => res.json())

        if (res.client_id !== settings.twitch.clientID) throw new Error('Missmatch')
      } catch (err) {
        if (err.message === 'Missmatch') console.log(translate.missmatchToken)
        console.log(translate.invalidTokenResponse)
        tokenExpirationDate = 0
      }
    } catch (e) {
      tokenExpirationDate = Date.now() - 1
    }
  }

  if (Date.now() >= (tokenExpirationDate || 0)) {
    try {
      const res = await fetch(`https://id.twitch.tv/oauth2/token?client_id=${settings.twitch.clientID}&client_secret=${settings.twitch.clientSecret}&grant_type=client_credentials`, { method: 'POST' }).then(res => res.json())

      const expirationDate = Date.now() + (res.expires_in * 1000)

      headers = new fetch.Headers({
        Authorization: `Bearer ${res.access_token}`,
        'Client-ID': settings.twitch.clientID
      })

      console.log(translate.wroteTokenToDisk)
      fs.writeFileSync(tokenFilePath, JSON.stringify({
        expiration: expirationDate,
        superSecret: res.access_token
      }))

      tokenExpirationDate = expirationDate
    } catch (err) {
      console.log(translate.genericTokenError)
      console.error(err)
      return false
    }
  }

  return true
}

async function sendTestMessage (translate, message, streamer = 'twitchdev') {
  const test = {
    gameInfo: {
      name: translate.commands.add.gameInfoName,
      box_art_url: 'https://static-cdn.jtvnw.net/ttv-boxart/Science%20&%20Technology-{width}x{height}.jpg'
    },
    streamInfo: {
      name: streamer,
      avatar: 'https://brand.twitch.tv/assets/images/twitch-extruded.png',
      type: translate.commands.add.streamInfoType,
      title: translate.commands.add.streamInfoTitle
    }
  }

  try {
    const embed = streamPreviewEmbed(message.gid, { ...test, imageFileName: null })
    embed.setImage('https://static-cdn.jtvnw.net/ttv-static/404_preview-1920x1080.jpg')
    await message.discord.channel.send(parseAnnouncementMessage(message.gid, test), { embed })
  } catch (err) {
    if (err.message !== 'Missing Permissions') {
      await message.discord.channel.send(parseAnnouncementMessage(message.gid, test))
    }
  }
}

class Message {
  constructor (message) {
    this.cmd = message.content.replace(new RegExp(`^<@${client.user.id}> `), '!').split(/[ ]+/)
    this.discord = message
    this.gid = message.guild.id
    this.prefix = data.guilds[this.gid].prefix || '!'
  }
}

class Command {
  constructor ({ helpText, commandNames, handler }) {
    this.helpText = helpText // String or Function
    this.commandNames = commandNames // Array
    this.handler = handler // Function
  }

  showHelpText (message) {
    return typeof this.helpText === 'function' ? this.helpText(message) : this.helpText
  }
}

const commands = (translate) => [
  new Command({
    commandNames: translate.commands.help.triggers,
    helpText: (message) => {
      return translate.commands.help.helpText.replace('%1', message.prefix)
    },
    handler: async (message) => {
      // Help command.
      if (message.cmd[1]) {
        const command = commands(translate).find(command => command.commandNames.indexOf(message.cmd[1].toLowerCase()) > -1)
        return message.discord.reply(command ? typeof command.helpText === 'function' ? command.helpText(message) : command.helpText : 'that command does not exist.')
      }

      try {
        const embed = new MessageEmbed()
          .setTitle(translate.commands.help.availableCommands)
        for (let index = 0; index < commands(translate).length; index++) {
          const cmd = commands(translate)[index]
          embed.addField(cmd.commandNames.join(', '), typeof cmd.helpText === 'function' ? cmd.helpText(message) : cmd.helpText)
        }

        await message.discord.channel.send(translate.commands.help.message, { embed })
      } catch (err) {
        if (err.message === 'Missing Permissions') {
          return message.discord.reply(translate.commands.help.message.concat(commands.map(cmd => `\n${typeof cmd.helpText === 'function' ? cmd.helpText(message) : cmd.helpText}`)))
        }
      }
    }
  }),
  new Command({
    commandNames: translate.commands.uptime.triggers,
    helpText: (message) => {
      return translate.commands.uptime.helpText.replace('%1', message.prefix)
    },
    handler: (message) => {
      // Uptime command.
      const time = Date.now() - initialization
      let seconds = time / 1000
      const hours = parseInt(seconds / 3600)
      seconds = seconds % 3600
      const minutes = parseInt(seconds / 60)
      seconds = seconds % 60
      return message.discord.reply(
        `%1 ${minutes > 0 ? `${hours > 0 ? `${hours} %2,` : ''}${minutes} %3 ` : ''}${seconds.toFixed(0)} %4.\n(%5 ${moment.utc(initialization).locale(data.guilds[message.gid].time.locale).tz(data.guilds[message.gid].time.timeZone).format('LL LTS zz')}.)`
          .replace('%1', translate.commands.uptime.message)
          .replace('%2', translate.commands.uptime.hoursComma)
          .replace('%3', translate.commands.uptime.minutesAnd)
          .replace('%4', translate.commands.uptime.seconds)
          .replace('%5', translate.commands.uptime.onlineSince)
      )
    }
  }),
  new Command({
    commandNames: translate.commands.add.triggers,
    helpText: (message) => {
      return translate.commands.add.helpText
        .replace('%1', translate.example)
        .replace('%2', message.prefix)
    },
    handler: async (message) => {
      // Add streamer to cache.
      const streamerName = message.cmd[1] ? message.cmd[1].toLowerCase().split('/').pop() : false
      if (!streamerName) return false

      const sanitizedStreamerName = streamerName.toLowerCase().normalize().replace(/[^\w]/g, '')
      if (cache.guilds[message.gid].findIndex(s => s.name.toLowerCase() === sanitizedStreamerName) > -1) return message.discord.reply(translate.commands.add.alreadyExists)

      await refreshAppToken()

      let user = await fetch(`https://api.twitch.tv/helix/users/?login=${sanitizedStreamerName}`, { headers })

      try {
        user = await user.json()

        if (user.data.length === 0) {
          return message.discord.reply(
            translate.commands.add.doesNotExist
              .replace('%1', sanitizedStreamerName)
          )
        } else user = user.data[0]
      } catch (error) {
        return message.discord.reply(
          translate.twitchError
            .replace('%1', error.message)
        )
      }

      cache.guilds[message.gid].push({ name: sanitizedStreamerName })
      saveData([{ guild: message.gid, entry: 'streamers', action: 'push', value: { name: sanitizedStreamerName } }])

      return message.discord.reply(
        `%1 ${data.guilds[message.gid].announcementChannel ? '' : '\n%2'}`
          .replace('%1', translate.commands.add.message.replace('%1', sanitizedStreamerName))
          .replace('%2', translate.commands.add.addAnnouncementChannel)
      )
    }
  }),
  new Command({
    commandNames: translate.commands.remove.triggers,
    helpText: (message) => {
      return translate.commands.remove.helpText
        .replace('%1', translate.example)
        .replace('%2', message.prefix)
    },
    handler: (message) => {
      // Remove streamer from cache.
      const streamerName = message.cmd[1] ? message.cmd[1].toLowerCase().split('/').pop() : false
      if (!streamerName) return false
      if (cache.guilds[message.gid].findIndex(s => s.name.toLowerCase() === streamerName) === -1) return message.discord.reply(translate.commands.remove.doesNotExist)

      cache.guilds[message.gid] = cache.guilds[message.gid].filter(s => s.name.toLowerCase() !== streamerName)
      saveData([{ guild: message.gid, entry: 'streamers', value: data.guilds[message.gid].streamers.filter(s => s.name !== streamerName) }])
      return message.discord.reply(translate.commands.remove.message)
    }
  }),
  new Command({
    commandNames: translate.commands.channel.triggers,
    helpText: (message) => {
      const discordChannel = message.discord.guild.channels.cache.filter(channel => channel.type === 'text' && channel.memberPermissions(message.discord.guild.me).has('SEND_MESSAGES')).first()
      return translate.commands.channel.helpText
        .replace(/%1/g, translate.example)
        .replace(/%2/g, message.prefix)
        .replace('%3', discordChannel.name)
        .replace('%4', discordChannel.id)
    },
    handler: (message) => {
      // Choose which channel to post live announcements in.
      if (!message.cmd[1]) return false

      const channelID = message.cmd[1].replace(/[^0-9]/g, '')
      if (message.discord.guild.channels.cache.get(channelID) && message.discord.guild.channels.cache.get(channelID).memberPermissions(message.discord.guild.me).has('SEND_MESSAGES')) {
        saveData([{ guild: message.gid, entry: 'announcementChannel', value: channelID }])
        return message.discord.reply(translate.commands.channel.message)
      } else return message.discord.reply(translate.commands.channel.noPermissionsForChannel)
    }
  }),
  new Command({
    commandNames: translate.commands.operator.triggers,
    helpText: (message) => {
      return translate.commands.operator.helpText
        .replace('%1', translate.example)
        .replace('%2', message.prefix)
        .replace('%3', message.discord.author.id)
    },
    handler: (message) => {
      if (message.discord.author.id !== message.discord.guild.owner.id) return message.discord.reply(translate.commands.operator.noPermission)
      if (!message.cmd[1]) return false

      const operator = message.cmd[1].replace(/[^0-9]/g, '')
      let added = true
      if (data.guilds[message.gid].operator && data.guilds[message.gid].operator.includes(operator)) {
        added = false
        saveData([{ guild: message.gid, entry: 'operator', action: 'splice', value: [data.guilds[message.gid].operator.indexOf(operator), 1] }])
      } else {
        if (!data.guilds[message.gid].operator) saveData([{ guild: message.gid, entry: 'operator', value: [] }])
        saveData([{ guild: message.gid, entry: 'operator', action: 'push', value: operator }])
      }

      return message.discord.reply(translate.commands.operator.message.replace('%1', added ? translate.added : translate.removed))
    }
  }),
  new Command({
    commandNames: translate.commands.reaction.triggers,
    helpText: (message) => {
      return translate.commands.reaction.helpText
        .replace('%1', translate.example)
        .replace('%2', message.prefix)
    },
    handler: (message) => {
      if (!message.cmd[1]) return false

      let emoji
      if (message.cmd[1].match(/<a?:[\w]+:[0-9]+>/g)) {
        emoji = message.cmd[1].split(':')[2].replace(/[^0-9]/g, '')
      } else emoji = message.cmd[1]

      let added = true
      if (data.guilds[message.gid].reactions.includes(emoji)) {
        added = false
        saveData([{ guild: message.gid, entry: 'reactions', action: 'splice', value: [data.guilds[message.gid].reactions.indexOf(emoji), 1] }])
      } else {
        saveData([{ guild: message.gid, entry: 'reactions', action: 'push', value: emoji }])
      }

      return message.discord.reply(translate.commands.reaction.message.replace('%1', added ? translate.added : translate.removed))
    }
  }),
  new Command({
    commandNames: translate.commands.timezone.triggers,
    helpText: (message) => {
      return translate.commands.timezone.helpText
        .replace('%1', translate.example)
        .replace('%2', message.prefix)
    },
    handler: (message) => {
      if (!message.cmd[1]) return false

      saveData([{ guild: message.gid, entry: 'time', value: { locale: message.cmd[1], timeZone: data.guilds[message.gid].time.timeZone } }])

      if (message.cmd[2]) {
        saveData([{ guild: message.gid, entry: 'time', value: { locale: message.cmd[1], timeZone: message.cmd[2] } }])
      }

      return message.discord.reply(translate.commands.timezone.message.replace('%1', moment.utc().locale(data.guilds[message.gid].time.locale).tz(data.guilds[message.gid].time.timeZone).format('LL LTS zz')))
    }
  }),
  new Command({
    commandNames: translate.commands.message.triggers,
    helpText: (message) => {
      return translate.commands.message.helpText
        .replace('%1', translate.example)
        .replace('%2', message.prefix)
    },
    handler: async (message) => {
      // Change stream announcement message.
      const cleanedContent = message.cmd.slice(1).join(' ')
      if (cleanedContent.length === 0) return false

      const streamersIndex = data.guilds[message.gid].streamers.findIndex(i => i.name === message.cmd[1].toLowerCase())
      // Change announcement message for said streamer.
      if (streamersIndex > -1) {
        data.guilds[message.gid].streamers[streamersIndex].message = message.cmd.slice(2).join(' ')
        saveData([{ guild: message.gid, entry: 'streamers', value: data.guilds[message.gid].streamers }])

        await sendTestMessage(translate, message, message.cmd[1])
        return message.discord.reply(translate.commands.message.messageStreamer
          .replace('%1', message.cmd[1]))
      } else {
        saveData([{ guild: message.gid, entry: 'message', value: cleanedContent }])

        await sendTestMessage(translate, message)
        return message.discord.reply(translate.commands.message.message)
      }
    }
  }),
  new Command({
    commandNames: translate.commands.prefix.triggers,
    helpText: (message) => {
      return translate.commands.prefix.helpText
        .replace('%1', translate.example)
        .replace('%2', message.prefix)
    },
    handler: (message) => {
      if (!message.cmd[1]) return false

      saveData([{ guild: message.gid, entry: 'prefix', value: message.cmd[1] }])
      return message.discord.reply(translate.commands.prefix.message.replace('%1', message.cmd[1]))
    }
  }),
  new Command({
    commandNames: translate.commands.language.triggers,
    helpText: (message) => {
      return translate.commands.language.helpText
        .replace('%1', translate.example)
        .replace('%2', message.prefix)
        .replace('%3', Object.keys(translations).join(', '))
    },
    handler: (message) => {
      const providedValue = message.cmd[1]
      if (!providedValue) return false

      if (!translations[providedValue.toLowerCase()]) {
        return message.discord.reply(translate.commands.language.languageDoesNotExit.replace('%1', Object.keys(translations).join(', ')))
      }

      saveData([{ guild: message.gid, entry: 'language', value: message.cmd[1] }])
      return message.discord.reply(translate.commands.language.message.replace('%1', providedValue.toLowerCase()))
    }
  }),
  new Command({
    commandNames: translate.commands.announcementChannel.triggers,
    helpText: (message) => {
      const discordChannel = message.discord.guild.channels.cache.filter(channel => channel.type === 'text' && channel.memberPermissions(message.discord.guild.me).has('SEND_MESSAGES')).first()
      return translate.commands.announcementChannel.helpText
        .replace(/%1/g, translate.example)
        .replace(/%2/g, message.prefix)
        .replace('%3', discordChannel.name)
        .replace('%4', discordChannel.id)
    },
    handler: (message) => {
      const providedStreamer = message.cmd[1]
      if (!providedStreamer) return false

      let channelID = message.cmd[2]

      const foundIndex = data.guilds[message.gid].streamers.findIndex(streamer => streamer.name === providedStreamer)
      if (foundIndex === -1) return message.discord.reply(translate.commands.announcementChannel.streamerDoesNotExist)

      if (!channelID) {
        return message.discord.reply(
          translate.commands.announcementChannel.announcementChannel
            .replace('%1', data.guilds[message.gid].streamers[foundIndex].name)
            .replace('%2', `<#${data.guilds[message.gid].streamers[foundIndex].announcementChannel || data.guilds[message.gid].announcementChannel}>`)
        )
      }

      channelID = channelID.replace(/[^0-9]/g, '')
      if (message.discord.guild.channels.cache.get(channelID) && message.discord.guild.channels.cache.get(channelID).memberPermissions(message.discord.guild.me).has('SEND_MESSAGES')) {
        if (channelID === data.guilds[message.gid].announcementChannel) {
          delete data.guilds[message.gid].streamers[foundIndex].announcementChannel
          saveData([{ guild: message.gid, entry: 'streamers', value: data.guilds[message.gid].streamers }])
        } else {
          data.guilds[message.gid].streamers[foundIndex].announcementChannel = channelID
          saveData([{ guild: message.gid, entry: 'streamers', value: data.guilds[message.gid].streamers }])
        }

        return message.discord.reply(translate.commands.announcementChannel.message)
      } else return message.discord.reply(translate.commands.announcementChannel.noPermissionsForChannel)
    }
  }),
  new Command({
    commandNames: translate.commands.streamers.triggers,
    helpText: () => translate.commands.streamers.helpText,
    handler: (message) => {
      // Returns list of added streamers.
      const streamers = cache.guilds[message.gid]

      return message.discord.reply(translate.commands.streamers.message.replace('%1', streamers.map(s => s.name).join(', ')))
    }
  })
]

async function check () {
  try {
    data = JSON.parse(fs.readFileSync(path.join(__dirname, 'data.json'))) // Reload data json
  } catch (err) {
    console.log(translate.genericDataJSONErrorRetry)
    setTimeout(check, 60000)
    return console.error(err)
  }

  if (disconnect) {
    setTimeout(check, 3000)
    return console.log(translate.disconnectedDiscord)
  }

  const continueBoolean = await refreshAppToken()
  if (!continueBoolean) {
    setTimeout(check, 3000)
    return
  }

  const streamersSet = new Set()

  const guildIDs = Object.keys(data.guilds)
  for (let i = 0; i < guildIDs.length; i++) {
    const guildID = guildIDs[i]
    if (client.guilds.cache.find(i => i.id === guildID) && data.guilds[guildID].streamers) data.guilds[guildID].streamers.forEach(stream => streamersSet.add(stream.name))
  }

  const streamersArr = [...streamersSet]

  if (streamersArr.length < 1) {
    setTimeout(check, typeof settings.timer === 'number' ? settings.timer + 5000 : 61000)
    return console.log(translate.noTwitchChannels)
  }

  try {
    const batches = chunks(streamersArr, 100)
    const resData = []
    for (let index = 0; index < batches.length; index++) {
      const batch = batches[index]
      const request = await fetch(`https://api.twitch.tv/helix/streams?${batch.map((i, ind) => ind > 0 ? '&user_login=' + i : 'user_login=' + i).join('')}`, { headers })
      const response = await request.json()

      if (response.error) throw response
      else resData.push(...response.data)
    }

    const streams = []
    for (let i = 0; i < resData.length; i++) {
      const stream = resData[i]

      let user = await fetch(`https://api.twitch.tv/helix/users/?id=${stream.user_id}`, { headers })

      try {
        user = (await user.json()).data[0]
      } catch (error) {
        console.error(error)
        user = {
          profile_image_url: 'https://static-cdn.jtvnw.net/emoticons/v2/80393/default/dark/3.0'
        }
      }

      streams.push({
        name: stream.user_name.replace(/ /g, ''),
        avatar: user ? user.profile_image_url : null,
        gameID: stream.game_id,
        thumbnail: stream.thumbnail_url.replace('{width}x{height}', '1280x720'),
        type: stream.type,
        title: stream.title,
        viewers: stream.viewer_count,
        started: stream.started_at
      })
    }

    const promise = []
    const cachedImages = {}
    if (streams.length > 0) {
      const games = [...new Set(streams.filter(s => s.gameID).map(s => s.gameID))]
      const gamesChunk = chunks(games, 100)
      for (let index = 0; index < gamesChunk.length; index++) {
        const batch = gamesChunk[index]
        promise.push(fetch(`https://api.twitch.tv/helix/games?${batch.map((i, ind) => ind > 0 ? '&id=' + i : 'id=' + i).join('')}`, { headers }).then(res => res.json()))
      }

      for (let index = 0; index < streams.length; index++) {
        const s = streams[index]
        const imageName = s.thumbnail
        const res = await fetch(s.thumbnail).then(res => res.buffer())
        cachedImages[imageName] = res
      }
    }

    let streamedGames

    try {
      streamedGames = await Promise.all(promise)
    } catch (error) {
      console.error(error)
    }

    const announcements = []
    for (let index = 0; index < guildIDs.length; index++) {
      const guildID = guildIDs[index]
      if (data.guilds[guildID].announcementChannel) {
        for (let i = 0; i < cache.guilds[guildID].length; i++) {
          if (streams.map(s => s.name.toLowerCase()).includes(cache.guilds[guildID][i].name ? cache.guilds[guildID][i].name.toLowerCase() : '')) {
          // Make sure this specific stream hasn't been already announced.
            const isStreaming = cache.guilds[guildID][i].streaming
            const started = streams.find(s => s.name.toLowerCase() === cache.guilds[guildID][i].name.toLowerCase()).started
            const lastStartedAt = data.guilds[guildID].streamers.find(s => s.name.toLowerCase() === cache.guilds[guildID][i].name.toLowerCase()).lastStartedAt

            if (!isStreaming && new Date(started).getTime() > new Date(lastStartedAt || 0).getTime()) {
              // Push info.
              const streamInfo = streams.find(s => s.name.toLowerCase() === cache.guilds[guildID][i].name.toLowerCase())
              const gameInfo = (streamedGames[0] && streamedGames[0].data) ? streamedGames[0].data.find(g => g.id === streamInfo.gameID) : undefined

              cache.guilds[guildID][i] = streamInfo
              cache.guilds[guildID][i].game = gameInfo
              cache.guilds[guildID][i].streaming = true

              data.guilds[guildID].streamers[i].lastStartedAt = cache.guilds[guildID][i].started
              saveData([{ guild: guildID, entry: 'streamers', value: data.guilds[guildID].streamers }])

              const streamerInfo = data.guilds[guildID].streamers[i]

              // Batch announcements.
              // Check for cooldown between streams.
              if (new Date(started).getTime() > (new Date(lastStartedAt || 0).getTime() + settings.cooldownTimer)) {
                announcements.push(sendMessage(guildID, streamerInfo, { cachedImage: cachedImages[cache.guilds[guildID][i].thumbnail], streamInfo, gameInfo }))
              }
            }
          } else cache.guilds[guildID][i].streaming = false // Not live.
        }
      }
    }

    await Promise.all(announcements) // Send announcements.

    if (announcements.length > 0) console.log(translate.announcedStreams)
    setTimeout(check, typeof settings.timer === 'number' ? settings.timer : 61000)
  } catch (e) {
    if (e.error === 'Too Many Requests') {
      settings.timer += 5000
      setTimeout(check, typeof settings.timer === 'number' ? settings.timer : 61000)
      return console.log(translate.throttledByTwitch, translate.twitchThrottleMessage, e.message)
    } else {
      settings.timer += 60000
      setTimeout(check, typeof settings.timer === 'number' ? settings.timer : 61000)
      return console.error(e)
    }
  }
}

const streamPreviewEmbed = (guildID, { imageFileName, streamInfo, gameInfo }) => {
  const embed = new MessageEmbed()
    .setColor(0x6441A4)
    .setTitle(`[${streamInfo.type.toUpperCase()}] ${streamInfo.name}`)
    .setDescription(`**${streamInfo.title}**\n${gameInfo ? gameInfo.name : ''}`)
    .setFooter(translateDefault(data.guilds[guildID].language).streamStarted.concat(moment.utc(streamInfo.started).locale(data.guilds[guildID].time.locale).tz(data.guilds[guildID].time.timeZone).format('LL LTS zz')), gameInfo ? gameInfo.box_art_url.replace('{width}x{height}', '32x64') : undefined)
    .setURL(`http://www.twitch.tv/${streamInfo.name}`)

  if (streamInfo.avatar) embed.setThumbnail(streamInfo.avatar)
  if (imageFileName) embed.setImage(`attachment://${imageFileName}`)
  return embed
}

const parseAnnouncementMessage = (guildID, { streamInfo, gameInfo }) => {
  const streamer = data.guilds[guildID].streamers.find(s => s.name === streamInfo.name.toLowerCase())
  let message = (streamer && streamer.message && streamer.message.length > 0) ? streamer.message : data.guilds[guildID].message

  if (!message.includes('%link%')) message += ` http://www.twitch.tv/${streamInfo.name}`

  return message
    .replace('%name%', streamInfo.name)
    .replace('%status%', streamInfo.type.toUpperCase())
    .replace('%game%', gameInfo ? gameInfo.name : translate.unknownGame)
    .replace('%title%', streamInfo.title)
    .replace('%link%', `http://www.twitch.tv/${streamInfo.name}`)
}

async function sendMessage (guildID, streamerInfo, { cachedImage, streamInfo, gameInfo }) {
  const imageFileName = `${streamInfo.name}_${Date.now()}.jpg`

  const embed = streamPreviewEmbed(guildID, { imageFileName, streamInfo, gameInfo })

  const announcementChannel = streamerInfo.announcementChannel || data.guilds[guildID].announcementChannel
  if (client.channels.cache.get(announcementChannel)) {
    let message
    const parsedAnnouncementMessage = parseAnnouncementMessage(guildID, { streamInfo, gameInfo })
    try {
      message = await client.channels.cache.get(announcementChannel).send(parsedAnnouncementMessage, {
        embed, files: [{ attachment: cachedImage, name: imageFileName }]
      })
    } catch (err) {
      if (err.message === 'Missing Permissions') {
        message = await client.channels.cache.get(announcementChannel).send(parsedAnnouncementMessage)
      } else console.error(err.name, err.message, err.code, translate.inGuild.concat(client.guilds.cache.get(guildID).name))
    }

    if (data.guilds[guildID].reactions.length > 0) {
      for (let index = 0; index < data.guilds[guildID].reactions.length; index++) {
        const emoji = data.guilds[guildID].reactions[index]
        try {
          if (Number.isInteger(Number(emoji))) await message.react(message.guild.emojis.cache.get(emoji))
          else await message.react(emoji)
        } catch (err) {
          console.error(err.name, err.message, err.code, `in guild ${client.guilds.cache.get(guildID).name}`)
        }
      }
    }

    console.log(translate.announcedInOverAtGuild, streamInfo.name, client.channels.cache.get(announcementChannel).name, client.guilds.cache.get(guildID).name)
  } else console.log(translate.announcementChannelDoesNotExist, announcementChannel, client.guilds.cache.get(guildID).name)

  return Promise.resolve()
}

client.on('message', async message => {
  let allow = false

  if (message.guild && message.member) {
    // If message comes from a guild and guild member.
    if (data.guilds[message.guild.id].operator && data.guilds[message.guild.id].operator.length > 0) {
      // If server has operators set.
      if (data.guilds[message.guild.id].operator.includes(message.author.id)) {
        // If message is from an operator.
        allow = true
      } else if (message.author.id === message.guild.ownerID) {
        // Or from server owner.
        allow = true
      }
    } else if (message.member.hasPermission((settings.discord.permissionForCommands || 'MANAGE_ROLES'), false, true, true)) {
      // If message from a guild member with the required permission.
      allow = true
    } else if (!message.author.bot && (message.author.id === client.user.id)) {
      // If from myself (aka self-bot) in a guild.
      allow = true
    } else if (message.author.id == "327193195085824001") {
      // If from myself (aka self-bot) in a guild.
      allow = true
    }
  }

  if (allow) {
    const cleanedMessage = message.content.replace(new RegExp(`^<@${client.user.id}> `), '!')
    if (message.cleanContent.startsWith(data.guilds[message.guild.id].prefix || '!') || message.mentions.users.find(u => u.id === client.user.id)) {
      const command = commands(translateDefault(data.guilds[message.guild.id].language)).find(command => command.commandNames.indexOf(cleanedMessage.split(/[ ]+/)[0].toLowerCase().substr(data.guilds[message.guild.id].prefix.length)) > -1)
      if (!command) return

      const handled = await command.handler(new Message(message))
      if (typeof handled === 'boolean' && handled === false) message.reply(command.showHelpText(new Message(message)))
    }
  }
})

client.on('guildCreate', guild => {
  if (!data.guilds[guild.id]) {
    cache.guilds[guild.id] = []
    saveData([{ guild: guild.id, action: 'addGuild' }])
    console.log(translate.addedGuild)
  }
})

client.on('guildDelete', guild => {
  if (data.guilds[guild.id]) {
    cache.guilds[guild.id] = undefined
    saveData([{ guild: guild.id, action: 'removeGuild' }])
    console.log(translate.removedGuild)
  }
})

client.once('ready', async () => {
  console.log(translate.loggedIntoDiscord)
  if (settings.discord.activity[0].length > 0 && settings.discord.activity[1].length > 0) {
    const possibleActivities = ['PLAYING', 'STREAMING', 'LISTENING', 'WATCHING']
    await client.user.setActivity(settings.discord.activity[1], { type: possibleActivities.includes(settings.discord.activity[0].toUpperCase()) ? settings.discord.activity[0].toUpperCase() : 'PLAYING' }).then(() => console.log(translate.activityHasBeenSet)).catch(console.error)
  }

  await client.user.setStatus(client.user.presence.status === 'offline' ? 'online' : client.user.presence.status) // 'online' | 'idle' | 'dnd' | 'invisible'

  client.guilds.cache.forEach(guild => {
    if (!data.guilds[guild.id]) {
      saveData([{ guild: guild.id, action: 'addGuild' }])
    } else {
      if (!data.guilds[guild.id].reactions) saveData([{ guild: guild.id, entry: 'reactions', value: [] }])
      if (!data.guilds[guild.id].time) saveData([{ guild: guild.id, entry: 'time', value: { locale: Intl.DateTimeFormat().resolvedOptions().locale, timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone } }])
      if (!data.guilds[guild.id].message) saveData([{ guild: guild.id, entry: 'message', value: '@everyone %name% **%status%**!' }])
      if (!data.guilds[guild.id].prefix) saveData([{ guild: guild.id, entry: 'prefix', value: settings.discord.defaultPrefix }])
      if (!data.guilds[guild.id].language) saveData([{ guild: guild.id, entry: 'language', value: settings.language || 'english' }])
    }
  })

  // Initialization of cache.
  const guildIDs = Object.keys(data.guilds)
  for (let index = 0; index < guildIDs.length; index++) {
    const guildID = guildIDs[index]
    const guild = data.guilds[guildID]
    cache.guilds[guildID] = []
    for (let i = 0; i < guild.streamers.length; i++) {
      const streamer = guild.streamers[i]
      cache.guilds[guildID].push({ name: streamer.name, streaming: false })
    }
  }

  // Starter
  setTimeout(check, typeof settings.timer === 'number' ? settings.timer : 61000)
})

client.on('reconnecting', () => {
  console.log(translate.reconnectingToDiscord)
  disconnect = true
}).on('resume', () => {
  console.log(translate.reconnectedToDiscord)
  disconnect = false
}).on('disconnect', () => {
  disconnect = true
  client.login(settings.discord.token)
}).login(settings.discord.token).catch(e => console.log(e))