const express = require('express')
const multiparty = require('multiparty')
const path = require('path')
const fsa = require('fs')
const fs = fsa.promises
const sqlite = require('sqlite')

const router = express.Router()
const cfgLoader = require(path.join('..', '..', 'config-loader'))(path.join(__dirname, 'config.json'), {
  database: 'index.db',
  root: './files',
  expiry: 2246400,
  baseurl: 'https://i.lunasqu.ee/',
  tokens: {}
})

function asyncForm (req, form) {
  return new Promise(function (resolve, reject) {
    form.parse(req, function(err, fields, files) {
      if (err) return reject(err)
      resolve({ fields, files })
    })
  })
}

async function init () {
  let config = await cfgLoader
  let root = path.resolve(config.root)
  let baseurl = config.baseurl

  await fs.access(root, fsa.constants.F_OK)

  const dbPromise = Promise.resolve()
    .then(() => sqlite.open(path.join(__dirname, config.database), { Promise, cache: true }))
    .then(db => db.migrate({ migrationsPath: path.join(__dirname, 'migrations') }))

  router.get('/:hash', async (req, res, next) => {
    if (!req.params.hash) return res.status(400).send('Invalid request')

    let db = await dbPromise
    let file = await db.get('SELECT * FROM File WHERE path = ?', req.params.hash)
    if (!file) return res.status(404).end()

    res.header('Cache-Control', 'max-age=' + 7 * 24 * 60 * 60 * 1000)
    res.sendFile(path.join(root, file.path))
  })

  router.post('/publish', async (req, res, next) => {
    let token = req.header('token') || req.body.token
    if (!token || !config.tokens[token]) return res.status(402).send('Forbidden')

    // Handle multipart data
    let form = new multiparty.Form()
    let { fields, files } = await asyncForm(req, form)

    // Detect all files
    let allFiles = []
    for (let i in files) {
      for (let j in files[i]) {
        allFiles.push(files[i][j])
      }
    }

    if (!allFiles.length) return res.status(400).send('Invalid request')

    // Determine real IP address
    let ip
    if (req.header('x-forwarded-for')) {
      ip = req.header('x-forwarded-for')
    } else {
      ip = req.connection.remoteAddress
    }

    console.log('[%s] from %s request to upload %d file(s)', new Date(), ip, allFiles.length)

    // Handle all files provided
    let db = await dbPromise
    let uploadedFiles = []
    for (let i in allFiles) {
      let file = allFiles[i]
      let fname = file.originalFilename
      let target = path.join(root, fname)

      // Handle already exists case (overwrite)
      try {
        await fs.access(target, fsa.constants.F_OK)
        await fs.unlink(target)
        await fs.copyFile(file.path, target)
        await fs.unlink(file.path)

        await db.run('UPDATE File SET ip = ?, upload = ? WHERE path = ?', ip, new Date(), fname)

        uploadedFiles.push(baseurl + fname)
        continue
      } catch (e) {
        if (e.code !== 'ENOENT') throw e
      }

      // Copy to target and unlink temporary file
      await fs.copyFile(file.path, target)
      await fs.unlink(file.path)

      await db.run('INSERT INTO File (path,ip,upload) VALUES (?,?,?)', fname, ip, new Date())
      uploadedFiles.push(baseurl + fname)
    }

    if (uploadedFiles.length === 0) return res.status(400).send('No files were uploaded')

    res.send(uploadedFiles.join('\n'))
  })

  return router
}

module.exports = init