import k8s from "@kubernetes/client-node";
import { VERB } from "../util/logging.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 mineclusterManaged = (o) =>
  o.metadata &&
  o.metadata.annotations &&
  o.metadata.annotations["minecluster.dunemask.net/server-name"] !== undefined;

const serverMatch = (serverName) => (o) =>
  o.metadata.annotations["minecluster.dunemask.net/server-name"] === serverName;

export async function getDeployments() {
  const deploymentRes = await k8sDeps.listNamespacedDeployment(namespace);
  const serverDeployments = deploymentRes.body.items.filter(mineclusterManaged);
  return serverDeployments;
}

export async function getServices() {
  const serviceRes = await k8sCore.listNamespacedService(namespace);
  const serverServices = serviceRes.body.items.filter(mineclusterManaged);
  return serverServices;
}

export async function getSecrets() {
  const secretRes = await k8sCore.listNamespacedSecret(namespace);
  const serverSecrets = secretRes.body.items.filter(mineclusterManaged);
  return serverSecrets;
}

export async function getVolumes() {
  const volumeRes =
    await k8sCore.listNamespacedPersistentVolumeClaim(namespace);
  const serverVolumes = volumeRes.body.items.filter(mineclusterManaged);
  return serverVolumes;
}

export function getServerAssets(serverName) {
  const serverFilter = serverMatch(serverName);
  return Promise.all([
    getDeployments(),
    getServices(),
    getSecrets(),
    getVolumes(),
  ])
    .then(([deps, svcs, scrts, vols]) => {
      const deployments = deps.filter(serverFilter);
      const services = svcs.filter(serverFilter);
      const secrets = scrts.filter(serverFilter);
      const volumes = vols.filter(serverFilter);

      if (deployments.length > 1) throw Error("Deployment filter broken!");
      if (volumes.length > 1) throw Error("Volume filter broken!");
      if (secrets.length > 1) throw Error("Secrets broken!");
      const serverAssets = {
        deployment: deployments[0],
        service: services.find(
          (s) => s.metadata.name === `mcl-${serverName}-server`,
        ),
        volume: volumes[0],
        rconService: services.find(
          (s) => s.metadata.name === `mcl-${serverName}-rcon`,
        ),
        rconSecret: secrets[0],
      };
      for (var k in serverAssets) if (serverAssets[k]) return serverAssets;
      // If no assets exist, return nothing
    })
    .catch((e) => console.log(e));
}

export async function getDeployment(serverName) {
  const servers = await getDeployments();
  const serverDeployment = servers.find(
    (s) =>
      s.metadata.annotations["minecluster.dunemask.net/server-name"] ===
      serverName,
  );
  if (!serverDeployment) {
    console.log(servers.map((s) => s.metadata.annotations));
    throw Error(`MCL Deployment '${serverName}' could not be found!`);
  }
  return serverDeployment;
}

export async function scaleDeployment(serverName, scaleUp = false) {
  const deployment = await getDeployment(serverName);
  if (deployment.spec.replicas === 1 && scaleUp)
    return VERB(
      "KSC",
      `MCL Deployment '${serverName}' is already scaled! Ignoring scale adjustment.`,
    );
  deployment.spec.replicas = scaleUp ? 1 : 0;
  return k8sDeps.replaceNamespacedDeployment(
    deployment.metadata.name,
    namespace,
    deployment,
  );
}