// Imports
const router = require("express").Router();
const storageUtil = require("../utils/storage-util");
const crudFiles = require("../crud/files");
const crudUsers = require("../crud/users");
// Constants
const bucket = "uploads";
const container = (req) => req.user.cairo_id;
const uploadField = "user-selected-file";
const upload = storageUtil.buildBucketUpload(bucket, uploadField, container);
const upsertMiddleware = [authMiddleware, bodyParserMiddleware];
const uploadMiddleware = [authMiddleware, urlEncodedMiddleware, upload];
router.get("/files", authMiddleware, (req, res) => {
  crudFiles.queryOwnedFiles(req.user.cairo_id).then((files) => res.json(files));
});

router.post("/upload", uploadMiddleware, async (req, res) => {
  const users = await crudUsers.queryUserByCairoId(req.user.cairo_id);
  const user = users[0];
  user.used_storage = parseInt(user.used_storage);
  user.storage = parseInt(user.storage);
  if (req.file.size + user.used_storage > user.storage) {
    storageUtil.cancelUpload(req, req.file.filename);
    return res.sendStatus(500);
  }
  const fileInsert = crudFiles.insertFile(
    req.user.cairo_id,
    req.file.filename,
    req.file.originalname,
    req.file.size
  );

  const userInsert = crudUsers.updateUsedStorage(
    req.user.cairo_id,
    req.file.size + user.used_storage
  );

  Promise.all([fileInsert, userInsert])
    .then((results) => res.json(results[0][0]))
    .catch((err) => res.sendStatus(500));
});

router.post("/delete", upsertMiddleware, (req, res) => {
  if (!req.body || !Array.isArray(req.body))
    return res.sendStatus(400).send("Files must be an array!");
  const files = req.body;
  // Technically this should be checked to see if they own it/can edit it
  // but timecrunch so will fix later
  const queries = files.map((fileId) =>
    crudFiles.deleteFile(fileId).then((files) => {
      try {
        storageUtil.deleteUpload(bucket, req.user.cairo_id, files[0].filename);
        return files[0];
      } catch (err) {
        logError("STASH", `Could not delete file(s)`, files);
        return { filesize: 0 };
      }
    })
  );
  Promise.all(queries)
    .then((results) => {
      var deletedData = 0;
      results.forEach((file) => (deletedData += file.filesize));
      crudUsers
        .updateUsedStorage(
          req.user.cairo_id,
          Math.max(parseInt(req.user.used_storage) - deletedData, 0)
        )
        .catch((err) =>
          logError(
            "STASH",
            "Could not update storage for ",
            req.user.cairo_id,
            err
          )
        );
      res.sendStatus(200);
    })
    .catch((err) => res.status(500).json([]));
  // Delete the file
});

router.get("/download", authOptMiddleware, async (req, res) => {
  if (!req.query || !req.query.target) return res.sendStatus(404);
  const files = await crudFiles.getFile(req.query.target);
  if (files.length !== 1) return res.sendStatus(404);
  const file = files[0];
  file.view = file.view ?? [];
  file.edit = file.edit ?? [];
  var fpath = storageUtil.fetchUpload(bucket, file.owner, file.filename);
  if (file.public) return res.download(fpath); // Send if public
  if (!req.user) return res.sendStatus(401);
  const userId = req.user.cairo_id;
  if (file.owner === userId) return res.download(fpath); // Send if owner
  if (file.edit.includes(userId) || file.view.includes(userId))
    return res.download(fpath); // Send if view/edit
  return res.sendStatus(401);
});

router.post("/public", upsertMiddleware, async (req, res) => {
  if (!req.body || !Array.isArray(req.body))
    return res.sendStatus(400).send("Files must be an array!");
  req.body.forEach((fileId) => crudFiles.setPublic(fileId));
  res.sendStatus(200);
});

module.exports = router;