import {
  Translation,
  TranslationData,
  TranslationCache
} from '../src/Translation'

interface RemoteTranslation {
  locale: string
  key: string
  text: string
  replacedKeys: TranslationData
  defaultText: string
}

let BATCH_SIZE = 10
const log = new Log('translate')

const nonTranslatable = ['Decentraland', 'LAND', 'MANA']

const TRANSLATION_KEY = 'tk'
const NON_TRANSLATABLE_KEY = 'nt'
const DEFAULT_LOCALE = Translation.DEFAULT_LOCALE

async function main() {
  const translation = new Translation()

  const mainTranslations = await translation.fetch(DEFAULT_LOCALE)
  const availableLocales = await getAvailableLocales()

  const mainKeys = Object.keys(mainTranslations)
  let flatMissingTranslations = {}

async function upsertDistrictAccountsFromContributions() {
  const districtEntries: DistrictEntry[] = await db.query(
    SQL`SELECT D.address, D.project_id, SUM(D.lands) AS lands,
      (SELECT row_to_json(P.*) FROM projects P WHERE P.id = D.project_id) AS project
        FROM district_entries D
        GROUP BY D.address, D.project_id`
  )

  log.info(`Normalizing ${districtEntries.length} district_entries.`)

  for (const districtEntry of districtEntries) {
    const token = await upsertToken(districtEntry.project)
    if (!token) continue

    const address = districtEntry.address.toLowerCase()

    log.info(`Upserting ${address}`)
    const account = new AccountBalance({
      address,
      token_address: token.get('address'),
      balance: districtEntry.lands.toString()
    })
    await account.upsert({ target: ['address', 'token_address'] })
  }
}

export async function main() {
  log.info('Connecting database')
  await db.connect()

  const tokens = await Token.find<TokenAttributes>()

  for (const token of tokens) {
    if (DistrictToken.isValid(token)) continue

    const tokenContract = Object.create(new contracts.ERC20Token(token.address))
    tokenContract.getContractName = () => token.name
    tokenContracts[token.address] = tokenContract
  }

  try {
    log.info(`Connecting to Ethereum Node with ${tokens.map(t => t.name)}`)
    await eth.connect({
      contracts: Object.values(tokenContracts),
      provider: env.get('RPC_URL')
    })

    const delay = env.get('MONITOR_BALANCES_DELAY', '10000')
    log.info(`Using ${delay}ms as delay between updates`)
    await monitorBalances(Number(delay))
  } catch (error) {
    log.info('Whoops, something went wrong')
    log.info(error)

    process.exit()
  }
}

export async function initializeDatabase() {
  const shouldContinue = await cli.confirm(
    `Careful! this will DROP 'projects' and 'district_entries,
  upsert 'account_balances' and a district token.
Do you wish to continue?`
  )
  if (!shouldContinue) return process.exit()

  log.info('Connecting database')
  await db.connect()

  log.info('Initializing state')
  await dropDumps()

  log.info('Restoring district_entries')
  execSync(runpsql('../dumps/districts.20180105.sql'))

  log.info('Restoring projects')
  execSync(runpsql('../dumps/projects.20180105.sql'))

  log.info('Upserting district accounts')
  await upsertDistrictAccountsFromContributions()

  log.info('Dropping leftover tables')
  await dropDumps()

  log.info('All done!')
  process.exit()
}

async function upsertToken(project: Project) {
  if (!project.lookup) return null
  const name = project.name

  log.info(`Upserting Token for ${name}`)
  const token = new DistrictToken(name)
  await token.upsert({ target: ['address'] })

  return token
}

async function updateAccountBalances() {
  const accounts = await AccountBalance.find<AccountBalanceAttributes>()

  for (const account of accounts) {
    const { address, token_address } = account
    const contract = tokenContracts[token_address]

    /*
      Perf improvement to avoid updating contributors account balances
      as they are fixed and only set once. It's important that a proper
      row exist before using the app that map a contributor address to
      it's contributions for each district
      ref: https://github.com/decentraland/agora/pull/126
    */
    if (DistrictToken.isAddress(token_address)) {
      continue
    }

    if (!contract) {
      log.info(`No contract for address ${token_address} in account ${address}`)
      continue
    }

    const contractBalance = await contract.balanceOf(address)
    const balance = eth.utils.fromWei(contractBalance).toString()

    log.info(`Updating Accounts and votes ${address} with balance ${balance}`)
    await Promise.all([
      AccountBalance.update<AccountBalanceAttributes>(
        { balance },
        { address, token_address }
      ),
      Vote.updateBalance(account, balance)
    ])
  }
}

async function main() {
  const translation = new Translation()

  const mainTranslations = await translation.fetch(DEFAULT_LOCALE)
  const availableLocales = await getAvailableLocales()

  const mainKeys = Object.keys(mainTranslations)
  let flatMissingTranslations = {}

  for (const locale of availableLocales) {
    const translations = await translation.fetch(locale)
    let requests: Promise<RemoteTranslation>[] = []

    for (const key of mainKeys) {
      if (key in translations) continue

      const defaultText = mainTranslations[key]
      const { textToTranslate, replacedKeys } = replaceTextKeys(defaultText)

      requests.push(
        translate(locale, textToTranslate).then(text => {
          const remoteTranslation: RemoteTranslation = {
            locale,
            key,
            text,
            replacedKeys,
            defaultText
          }
          return remoteTranslation
        })
      )

      if (requests.length > BATCH_SIZE) {
        await updateMissingTranslations(flatMissingTranslations, requests)
        requests = []
      }
    }

    await updateMissingTranslations(flatMissingTranslations, requests)
  }

  await writeTranslations(flatMissingTranslations)
  log.info('Done!')
}

async function updateMissingTranslations(
  flatMissingTranslations: TranslationCache,
  requests: Promise<RemoteTranslation>[]
) {
  const translated = await Promise.all(requests)

  for (let { locale, key, text, replacedKeys, defaultText } of translated) {
    text = restoreTextKeys(text, replacedKeys)

    if (isCapitalized(defaultText) && !isCapitalized(text)) {
      text = capitalize(text)
    }

    if (!flatMissingTranslations[locale]) {
      flatMissingTranslations[locale] = {}
    }
    flatMissingTranslations[locale][key] = text
    log.info(`${locale}(${key}): ${defaultText} -> ${text}`)
  }
}