import { readFile, readdir, access } from "fs/promises";
import path from "path";

import matter from "gray-matter";
import { Client } from "ldapts";
import { serialize } from "next-mdx-remote/serialize";

import { getCurrentTerm } from "@/lib/events";

const EXECS_PATH = path.join("content", "team", "execs");
const fileType = ".md";
const { year, term } = getCurrentTerm();

const execPositions: { [name: string]: { order: number; name: string } } = {
  president: { order: 1, name: "President" },
  "vice-president": { order: 2, name: "Vice President" },
  treasurer: { order: 3, name: "Treasurer" },
  secretary: { order: 4, name: "Assistant Vice President" },
  sysadmin: { order: 5, name: "System Administrator" },
};

export interface execMembers {
  name: string;
  position: string;
}

export interface Metadata {
  name: string;
  role: string;
  image: string;
}

export async function getExecNames() {
  if (process.env.USE_LDAP?.toLowerCase() !== "true") {
    return (await readdir(EXECS_PATH))
      .filter((name) => name.endsWith(fileType))
      .map((name) => name.slice(0, -1 * fileType.length));
  }

  const url = "ldap://ldap1.csclub.uwaterloo.ca";
  const searchDN = "ou=People,dc=csclub,dc=uwaterloo,dc=ca";
  const client = new Client({ url });

  let execMembers: execMembers[] = [];
  let formattedExec: string[];

  try {
    await client.bind("", "");
    const { searchEntries } = await client.search(searchDN, {
      scope: "sub",
      filter: `(&(objectClass=member)(term=${(term as string).slice(
        0,
        1
      )}${year})(position=*))`,
    });

    execMembers = searchEntries
      .map((item) => {
        return {
          name: item.cn as string,
          position: item.position as string,
        };
      })
      .filter((item: execMembers) => item.position in execPositions)
      .sort((item1: execMembers, item2: execMembers) => {
        return (
          execPositions[item1.position].order -
          execPositions[item2.position].order
        );
      });

    formattedExec = execMembers.map(
      (member) =>
        `0${execPositions[member.position].order}-
        ${member.name.split(" ")[1].toLowerCase()}-
        ${member.name.split(" ")[0].toLowerCase()}`
    );
  } finally {
    await client.unbind();
  }

  return formattedExec;
}

export async function getExec(fileName: string, convert = true) {
  // const firstName =
  //   fileName.split("-")[1][0].toUpperCase() + fileName.split("-")[1].slice(1);
  // const lastName =
  //   fileName.split("-")[2][0].toUpperCase() + fileName.split("-")[2].slice(1);
  // const posOrder = fileName.split("-")[0];
  // const pos = posDict[posOrder];

  // let content, metadata;

  // try {
  const raw = await readFile(path.join(EXECS_PATH, `${fileName}${fileType}`));
  const { content, data: metadata } = matter(raw);

  const image =
    (metadata.image as string | undefined) ??
    (await getMemberImagePath(metadata.name));

  return {
    content: convert ? await serialize(content) : content,
    metadata: { ...metadata, image } as Metadata,
  };
  // };
  // } catch (err) {
  //   console.log(err);
  //   ({ content, metadata } = {
  //     content: "Coming soon!",
  //     metadata: {
  //       name: `${firstName} ${lastName}`,
  //       role: `${pos}`,
  //     },
  //   });

  //   const image = await getMemberImagePath(metadata.name);

  //   return {
  //     content: convert ? await serialize(content) : content,
  //     metadata: { ...metadata, image } as Metadata,
  //   };
  // }
}

async function getImage(imgPath: string) {
  try {
    await access(path.join("public", imgPath));
    return imgPath;
  } catch {
    return undefined;
  }
}

export async function getMemberImagePath(name: string) {
  const imgPath = path.join("images", "team", name.replace(" ", ""));
  const placeholder = path.join(
    "images",
    "team",
    "team-member-placeholder.svg"
  );
  const img =
    (await getImage(imgPath + ".jpg")) ??
    (await getImage(imgPath + ".png")) ??
    (await getImage(imgPath + ".gif")) ??
    (await getImage(imgPath + ".jpeg")) ??
    placeholder;
  return img;
}