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";
import ExpressClientError from "../util/ExpressClientError.js";
import {
  getFtpContainer,
  getServerContainer,
  getBackupContainer,
} from "./server-containers.js";

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 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 createServerDeploy(serverSpec) {
  const { name, host } = serverSpec;
  const deployYaml = loadYaml("lib/k8s/configs/server-deployment.yml");
  const { metadata } = deployYaml;
  const serverContainer = getServerContainer(serverSpec);
  const backupContainer = getBackupContainer(serverSpec);
  const ftpContainer = getFtpContainer(serverSpec);

  // Configure Metadata;
  metadata.name = `mcl-${name}`;
  metadata.namespace = namespace;
  metadata.annotations["minecluster.dunemask.net/server-name"] = name;
  deployYaml.metadata = metadata;

  // Configure Lables & Selectors
  deployYaml.spec.selector.matchLabels.app = `mcl-${name}-app`;
  deployYaml.spec.template.metadata.labels.app = `mcl-${name}-app`;

  // Volumes
  deployYaml.spec.template.spec.volumes.find(
    ({ name }) => name === "datadir",
  ).persistentVolumeClaim.claimName = `mcl-${name}-volume`;

  // Apply Containers  TODO: User control for autostart
  deployYaml.spec.template.spec.containers.push(serverContainer);
  deployYaml.spec.template.spec.containers.push(ftpContainer);
  deployYaml.spec.replicas = 1;
  return deployYaml;
}

function createServerService(serverSpec) {
  const { name, host } = serverSpec;
  const serviceYaml = loadYaml("lib/k8s/configs/server-svc.yml");
  serviceYaml.metadata.annotations["ingress.qumine.io/hostname"] = host;
  serviceYaml.metadata.annotations["mc-router.itzg.me/externalServerName"] =
    host;
  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`;
  // Port List:
  const serverPortList = [{ p: 25565, n: "minecraft" }];

  // 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}` });

  const portList = [...serverPortList, ...ftpPortList];
  serviceYaml.spec.ports = portList.map(({ p: port, n: name }) => ({
    port,
    name,
    protocol: "TCP",
    targetPort: port,
  }));
  return serviceYaml;
}

function createRconService(serverSpec) {
  const { name } = 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 createServerResources(serverSpec) {
  const deploymentRes = await k8sDeps.listNamespacedDeployment(namespace);
  const deployments = deploymentRes.body.items.map((i) => i.metadata.name);
  if (deployments.includes(`mcl-${serverSpec.name}`))
    throw new ExpressClientError({ m: "Server already exists!", c: 409 });
  const pvcRes = await k8sCore.listNamespacedPersistentVolumeClaim(namespace);
  const pvcs = pvcRes.body.items.map((i) => i.metadata.name);
  if (pvcs.includes(`mcl-${serverSpec.name}-volume`))
    throw new ExpressClientError({ m: "Server PVC already exists!", c: 409 });
  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);
}