/**
 * @file HTTP surface for a user's OWN git identity (`server/lib/git-identity.js`),
 * mounted at `/api/me/git`: the SSH key a clone uses (make, replace, delete —
 * only the PUBLIC key is ever returned) and the HTTPS logins (save, delete —
 * `hasToken` only, never a password), and the commit author (`user.name` /
 * `user.email` of the account's global git config — a member's commits fail
 * without one). The account is the signed-in user's
 * own Linux account under S3, else the host's, which only an admin (or local
 * mode) may change (`EHOSTIDENTITY`). Nothing here takes a path from the
 * request, and every write passes the same-origin guard.
 * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
 */

const express = require("express");

const identity = require("../lib/git-identity");
const { sameOriginGuard } = require("../lib/same-origin");

const router = express.Router();

const STATUS = {
  EBADHOST: 400,
  EBADCRED: 400,
  EEXISTS: 409,
  EMEMBERGONE: 409,
  EHOSTIDENTITY: 403,
  EBADAUTHOR: 400,
  ESTOREUNREADABLE: 409,
  EBADKEYTYPE: 400,
};

function fail(res, e) {
  res
    .status(STATUS[e.code] || 500)
    .json({ error: { code: e.code || "EINTERNAL", message: e.message } });
}

async function view(account) {
  return {
    account: account.kind,
    writable: account.kind === "member" || account.writable !== false,
    ssh: identity.sshKeyInfo(account),
    https: identity.listHttps(account),
    author: await identity.getAuthor(account),
  };
}

/** The request's account; a write to the host's identity needs an admin. */
function accountOf(req, { write = false } = {}) {
  const account = identity.accountForRequest(req);
  if (write && account.kind === "host" && !account.writable) {
    throw Object.assign(new Error("the host's git identity is an admin's to change"), {
      code: "EHOSTIDENTITY",
    });
  }
  return account;
}

router.get("/", async (req, res) => {
  try {
    res.json(await view(accountOf(req)));
  } catch (e) {
    fail(res, e);
  }
});

router.post("/ssh-key", sameOriginGuard, async (req, res) => {
  try {
    const account = accountOf(req, { write: true });
    await identity.generateSshKey(account, {
      replace: req.body?.replace === true,
      type: req.body?.type === "rsa" ? "rsa" : "ed25519",
      comment: req.user?.username ? `${req.user.username}@agenthub` : "agenthub",
    });
    res.status(201).json(await view(account));
  } catch (e) {
    fail(res, e);
  }
});

router.delete("/ssh-key", sameOriginGuard, async (req, res) => {
  try {
    const account = accountOf(req, { write: true });
    if (!identity.removeSshKey(account)) {
      return res.status(404).json({ error: { code: "ENOTFOUND", message: "no SSH key" } });
    }
    res.json(await view(account));
  } catch (e) {
    fail(res, e);
  }
});

router.post("/https", sameOriginGuard, async (req, res) => {
  try {
    const account = accountOf(req, { write: true });
    const { host, username, password } = req.body || {};
    identity.saveHttps(account, { protocol: "https", host, username, password });
    res.json(await view(account));
  } catch (e) {
    fail(res, e);
  }
});

router.delete("/https/:host", sameOriginGuard, async (req, res) => {
  try {
    const account = accountOf(req, { write: true });
    if (!identity.removeHttps(account, "https", req.params.host)) {
      return res.status(404).json({ error: { code: "ENOTFOUND", message: "no such login" } });
    }
    res.json(await view(account));
  } catch (e) {
    fail(res, e);
  }
});

/** The account's commit author (`git config --global user.name/email`). */
router.put("/author", sameOriginGuard, async (req, res) => {
  try {
    const account = accountOf(req, { write: true });
    await identity.setAuthor(account, req.body || {});
    res.json(await view(account));
  } catch (e) {
    fail(res, e);
  }
});

module.exports = router;