import { v4 as uuidv4 } from "uuid";
import bcrypt from "bcrypt";
import k8s from "@kubernetes/client-node";
import yaml from "js-yaml";
import fs from "node:fs";
import path from "node:path";
const kc = new k8s.KubeConfig();
kc.loadFromDefault();
const k8sDeps = kc.makeApiClient(k8s.AppsV1Api);
const k8sCore = kc.makeApiClient(k8s.CoreV1Api);
const namespace = process.env.MCL_SERVER_NAMESPACE;

const loadYaml = (f) => yaml.load(fs.readFileSync(path.resolve(f), "utf8"));

function payloadFilter(req, res) {
  const serverSpec = req.body;
  if (!serverSpec) return res.sendStatus(400);
  const { name, url, version, serverType, difficulty, gamemode, memory } =
    serverSpec;
  if (!name) return res.status(400).send("Server name is required!");
  if (!url) return res.status(400).send("Server url is required!");
  if (!version) return res.status(400).send("Server version is required!");
  if (!difficulty)
    return res.status(400).send("Server difficulty is required!");
  if (!serverType) return res.status(400).send("Server type is required!");
  if (!gamemode) return res.status(400).send("Server Gamemode is required!");
  if (!memory) return res.status(400).send("Memory is required!");
  req.body.name = req.body.name.toLowerCase();
  return "filtered";
}

function createRconSecret(serverSpec) {
  const { name } = serverSpec;
  const rconYaml = loadYaml("lib/k8s/configs/rcon-secret.yml");

  // TODO: Dyamic rconPassword
  const rconPassword = bcrypt.hashSync(uuidv4(), 10);
  rconYaml.data["rcon-password"] = Buffer.from(rconPassword).toString("base64");
  rconYaml.metadata.labels.app = `mcl-${name}-app`;
  rconYaml.metadata.name = `mcl-${name}-rcon-secret`;
  rconYaml.metadata.namespace = namespace;
  rconYaml.metadata.annotations["minecluster.dunemask.net/server-name"] = name;
  return rconYaml;
}

function createServerVolume(serverSpec) {
  const { name } = serverSpec;
  const volumeYaml = loadYaml("lib/k8s/configs/server-pvc.yml");
  volumeYaml.metadata.labels.service = `mcl-${name}-server`;
  volumeYaml.metadata.name = `mcl-${name}-volume`;
  volumeYaml.metadata.namespace = namespace;
  volumeYaml.metadata.annotations["minecluster.dunemask.net/server-name"] =
    name;
  volumeYaml.spec.resources.requests.storage = "1Gi"; // TODO: Changeme
  return volumeYaml;
}

function getFtpContainer() {
  const ftpContainer = loadYaml("lib/k8s/configs/containers/ftp-server.yml");
  const ftpPortList = [
    { p: 20, n: "ftp-data" },
    { p: 21, n: "ftp-commands" },
  ];
  for (var p = 40000; p <= 40009; p++)
    ftpPortList.push({ p, n: `ftp-passive-${p - 40000}` });
  ftpContainer.ports = ftpPortList.map(({ p: containerPort, n: name }) => ({
    containerPort,
    name,
    protocol: "TCP",
  }));
  return ftpContainer;
}

function createServerDeploy(serverSpec) {
  const {
    name,
    version,
    serverType,
    difficulty,
    gamemode,
    memory,
    motd,
    maxPlayers,
    seed,
    modpack,
    ops,
    whitelist,
  } = serverSpec;
  const deployYaml = loadYaml("lib/k8s/configs/server-deployment.yml");
  const serverContainer = loadYaml(
    "lib/k8s/configs/containers/minecraft-server.yml",
  );
  const backupContainer = loadYaml(
    "lib/k8s/configs/containers/minecraft-backup.yml",
  );
  const ftpContainer = getFtpContainer();
  deployYaml.metadata.name = `mcl-${name}`;

  deployYaml.metadata.namespace = namespace;
  deployYaml.metadata.annotations["minecluster.dunemask.net/server-name"] =
    name;
  deployYaml.spec.replicas = 0; // TODO: User control for autostart
  deployYaml.spec.selector.matchLabels.app = `mcl-${name}-app`;
  deployYaml.spec.template.metadata.labels.app = `mcl-${name}-app`;
  const findEnv = (k) => serverContainer.env.find(({ name: n }) => n === k);
  const updateEnv = (k, v) => (findEnv.value = v);
  // Enviornment variables
  updateEnv("TYPE", serverType);
  updateEnv("VERSION", version);
  updateEnv("DIFFICULTY", difficulty);
  updateEnv("MODE", gamemode);
  updateEnv("MOTD", motd);
  updateEnv("MAX_PLAYERS", maxPlayers);
  updateEnv("SEED", seed);
  updateEnv("OPS", ops);
  updateEnv("WHITELIST", whitelist);
  updateEnv("MEMORY", `${memory}M`);

  if (version !== "VANILLA") delete findEnv("MODPACK").value;
  else updateEnv("MODPACK", modpack);
  findEnv("RCON_PASSWORD").valueFrom.secretKeyRef.name =
    `mcl-${name}-rcon-secret`;

  // Server Container Name
  serverContainer.name = `mcl-${name}`;
  // Resources
  serverContainer.resources.requests.memory = `${memory}Mi`;
  // serverContainer.resources.limits.memory = `${memory}Mi`; // TODO Allow for limits beyond initial startup
  // Volumes
  deployYaml.spec.template.spec.volumes.find(
    ({ name }) => name === "datadir",
  ).persistentVolumeClaim.claimName = `mcl-${name}-volume`;
  deployYaml.spec.template.spec.containers.push(serverContainer);
  deployYaml.spec.template.spec.containers.push(ftpContainer);
  return deployYaml;
}

function createServerService(serverSpec) {
  const { name, url } = serverSpec;
  const serviceYaml = loadYaml("lib/k8s/configs/server-svc.yml");
  serviceYaml.metadata.annotations["ingress.qumine.io/hostname"] = url;
  serviceYaml.metadata.labels.app = `mcl-${name}-app`;
  serviceYaml.metadata.name = `mcl-${name}-server`;
  serviceYaml.metadata.namespace = namespace;
  serviceYaml.metadata.annotations["minecluster.dunemask.net/server-name"] =
    name;
  serviceYaml.spec.selector.app = `mcl-${name}-app`;

  // Apply FTP Port List
  const ftpPortList = [
    { p: 20, n: "ftp-data" },
    { p: 21, n: "ftp-commands" },
  ];
  for (var p = 40000; p <= 40009; p++)
    ftpPortList.push({ p, n: `ftp-passive-${p - 40000}` });
  serviceYaml.spec.ports = ftpPortList.map(({ p: port, n: name }) => ({
    port,
    name,
    protocol: "TCP",
    targetPort: port,
  }));
  return serviceYaml;
}

function createRconService(serverSpec) {
  const { name, url } = serverSpec;
  const rconSvcYaml = loadYaml("lib/k8s/configs/rcon-svc.yml");
  rconSvcYaml.metadata.labels.app = `mcl-${name}-app`;
  rconSvcYaml.metadata.name = `mcl-${name}-rcon`;
  rconSvcYaml.metadata.namespace = namespace;
  rconSvcYaml.metadata.annotations["minecluster.dunemask.net/server-name"] =
    name;
  rconSvcYaml.spec.selector.app = `mcl-${name}-app`;
  return rconSvcYaml;
}

export default async function createServer(req, res) {
  if (payloadFilter(req, res) !== "filtered") return;
  const serverSpec = req.body;
  const deploymentRes = await k8sDeps.listNamespacedDeployment(namespace);
  const deployments = deploymentRes.body.items.map((i) => i.metadata.name);
  if (deployments.includes(`mcl-${serverSpec.name}`))
    return res.status(409).send("Server already exists!");
  const pvcRes = await k8sCore.listNamespacedPersistentVolumeClaim(namespace);
  const pvcs = pvcRes.body.items.map((i) => i.metadata.name);
  if (pvcs.includes(`mcl-${serverSpec.name}-volume`))
    return res.status(409).send("Server PVC already exists!");
  const rconSecret = createRconSecret(serverSpec);
  const serverVolume = createServerVolume(serverSpec);
  const serverDeploy = createServerDeploy(serverSpec);
  const serverService = createServerService(serverSpec);
  const rconService = createRconService(serverSpec);
  k8sCore.createNamespacedPersistentVolumeClaim(namespace, serverVolume);
  k8sCore.createNamespacedSecret(namespace, rconSecret);
  k8sCore.createNamespacedService(namespace, serverService);
  k8sCore.createNamespacedService(namespace, rconService);
  k8sDeps.createNamespacedDeployment(namespace, serverDeploy);

  res.sendStatus(200);
}