const account = require("../models/accounts");
const savedTokens = require("../models/saveToken");
import { createString } from "../utils/createString";
import { getTheme } from "../utils/getTheme";
import { logo } from "../utils/logo";
import utilsLogo from "../utils/utilsLogo";
import { main } from "./main";
import moment from "moment";
import templates from "../models/templates";
import scrape from "../models/scrape";
import * as fs from "fs";
import { config } from "./config";
import { rapid } from "./rapidTitlePromise";
import { mainMongoose } from "../main";
import { main as wizz } from "./main";
import extraUtils from "../utils/extraUtilsLogo";
import { mainMenu } from "../utils/mainMenu";
import { white } from "chalk";

module.exports = (client, db, rl) => {
  console.clear();
  async function mainFunc(client, db, rl) {
    rapid("[External-Nuker] - Utility", 1).then(() => {
      setTimeout(() => {
        process.title = "[External-Nuker] - Utility";
      }, 40);
    });
    console.clear();
    let mainColor = getTheme(db);
    utilsLogo(db);
    console.log(" ");
    console.log(" ");
    function nukeStr(str, type) {
      let r = `${mainColor("[")}${white(
        type === "rateLimit"
          ? "!"
          : type === "success"
          ? "+"
          : type === "fail"
          ? "-"
          : ""
      )}${mainColor("]")} ${white(str)}`;
      return r;
    }
    rl.question(createString("Enter option", db), async (option) => {
      if (
        ![
          "menu",
          "1",
          "2",
          "3",
          "c",
          "4",
          "5",
          "6",
          "7",
          "8",
          "9",
          "x",
          "z",
          "f",
          "h",
          "g",
        ].includes(option)
      ) {
        console.log(createString("Invalid option", db, "semi", "fail"));
        setTimeout(() => {
          mainFunc(client, db, rl);
        }, 1000);
        return;
      }
      if (option === "g") {
        console.clear();
        extraUtils(db);
        console.log(" ");
        rl.question(createString("Enter option", db), (op) => {
          op = op.trim();
          if (op === "menu") {
            console.clear();
            main(db, rl, client);
          }

          if (op === "3") {
            rl.question(createString("Enter new password", db), (newPass) => {
              account
                .findOneAndUpdate(
                  { Username: db.get("username") },
                  { Password: newPass }
                )
                .exec()
                .then(() => {
                  console.log(
                    createString("Successfully changed password", db, "semi")
                  );
                  setTimeout(() => {
                    main(db, rl, client);
                  }, 1000);
                });
            });
          }

          rl.question(createString("Enter server ID", db), async (guildID) => {
            let server = client.guilds.cache.get(guildID);

            if (!server) {
              console.log(createString("Unknown server", db, "semi", "fail"));
              setTimeout(() => {
                main(db, rl, client);
              }, 2000);
              return;
            }

            if (op === "1") {
              let scrapedF = <unknown>await scrape.findOne({
                Guild: guildID,
                Username: db.get("username"),
              });

              if (!scrapedF) {
                console.log(
                  createString("No scrape data found", db, "semi", "fail")
                );
                setTimeout(() => {
                  main(db, rl, client);
                }, 2000);
                return;
              }

              interface MassNickInterface {
                Members: String[];
                Roles: String[];
                Channels: String[];
              }

              let data = <MassNickInterface>scrapedF;

              if (!data) {
                console.log(
                  createString("No scrape data found", db, "semi", "fail")
                );
                setTimeout(() => {
                  main(db, rl, client);
                }, 2000);
                return;
              }

              rl.question(
                createString("Enter nickname to change to", db),
                (nick) => {
                  let ci = 1;
                  data.Members.map((m, i) => {
                    if (ci === data.Members.length) {
                      setTimeout(() => {
                        console.clear();
                        main(db, rl, client);
                      }, 4000);
                    }
                    let memq = server.members.cache.get(m);
                    if (memq) {
                      memq
                        .setNickname(nick)
                        .then(() => {
                          ci++;
                          console.log(
                            nukeStr(
                              `Changed ${mainColor(m)} nickname`,
                              "success"
                            )
                          );
                          if (ci === data.Members.length) {
                            console.clear();
                            main(db, rl, client);
                          }
                        })
                        .catch(() => {
                          ci++;
                          console.log(
                            nukeStr(
                              `Failed to change ${mainColor(m)} nickname`,
                              "success"
                            )
                          );
                          if (ci === data.Members.length) {
                            console.clear();
                            main(db, rl, client);
                          }
                        });
                    } else if (ci + 1 >= data.Members.length) {
                      console.clear();
                      main(db, rl, client);
                    } else ci++;
                  });
                }
              );
            }

            if (op === "2") {
              let scrapedF = <unknown>await scrape.findOne({
                Guild: guildID,
                Username: db.get("username"),
              });

              if (!scrapedF) {
                console.log(
                  createString("No scrape data found", db, "semi", "fail")
                );
                setTimeout(() => {
                  main(db, rl, client);
                }, 2000);
                return;
              }

              interface MassNickInterface {
                Members: String[];
                Roles: String[];
                Channels: String[];
              }

              let data = <MassNickInterface>scrapedF;

              if (!data) {
                console.log(
                  createString("No scrape data found", db, "semi", "fail")
                );
                setTimeout(() => {
                  main(db, rl, client);
                }, 2000);
                return;
              }

              rl.question(createString("Enter message to send", db), (msg) => {
                let ci = 1;
                data.Members.map((m, i) => {
                  if (ci === data.Members.length) {
                    setTimeout(() => {
                      console.clear();
                      main(db, rl, client);
                    }, 4000);
                  }
                  let memq = server.members.cache.get(m);
                  if (memq) {
                    memq
                      .send(msg)
                      .then(() => {
                        ci++;
                        console.log(
                          nukeStr(`Sent message to ${mainColor(m)}`, "success")
                        );
                        if (ci === data.Members.length) {
                          console.clear();
                          main(db, rl, client);
                        }
                      })
                      .catch(() => {
                        console.log(
                          nukeStr(
                            `Failed to send message to ${mainColor(m)}`,
                            "success"
                          )
                        );
                        if (ci === data.Members.length) {
                          console.clear();
                          main(db, rl, client);
                        }
                      });
                  } else if (ci + 1 >= data.Members.length) {
                    console.clear();
                    main(db, rl, client);
                  } else ci++;
                });
              });
            }
          });
        });
      }
      if (option === "2") {
        rl.question(
          createString("Enter server ID to save scrapes to", db),
          (serverID) => {
            if (!client.guilds.cache.has(serverID)) {
              setTimeout(() => {
                mainFunc(client, db, rl);
              }, 1000);
              console.log(createString("Unknown server", db, "semi", "fail"));
              return;
            }
            if (!fs.existsSync("./scrapes.txt")) {
              setTimeout(() => {
                mainFunc(client, db, rl);
              }, 1000);
              console.log(
                createString(
                  "Create a scrapes file and add IDS serated with a new line",
                  db,
                  "semi",
                  "fail"
                )
              );
              return;
            }
            let content = fs.readFileSync("./scrapes.txt");

            let splitedContent = content.toString().split("\n");

            let newContent = [];

            // splitedContent.map((element: string) => {
            //   newContent.push(element.toString());
            // });

            splitedContent.map((element) => {
              if (element.includes("\r")) {
                element = element.replace("\r", "");
                newContent.push(element);
              } else {
                newContent.push(element);
              }
            });

            let IDS = newContent;
            // content = content.toString().split("\n");

            // let newContent = [];

            // content.map((element: number) => {
            //   newContent.push(element.toString());
            // });

            // content = newContent;

            // let newNew = [];
            // content.map((element) => {
            //   if (element.includes("\r")) {
            //     element = element.replace("\r", "");
            //     newNew.push(element);
            //   } else newNew.push(element);
            // });

            // content = newNew;
            scrape
              .findOneAndUpdate(
                { Guild: serverID, Username: db.get("username") },
                { Members: [...IDS] },
                { upsert: true }
              )
              .exec()
              .then(() => {
                let g = client.guilds.cache.get(serverID);
                console.log(
                  createString(
                    `Added ${IDS.length} scrapes to ${g.name} server`,
                    db,
                    "semi"
                  )
                );
                setTimeout(() => {
                  main(db, rl, client);
                }, 1000);
              });
          }
        );
      }
      if (option === "h") {
        let i = 0;
        let askedQuestions = [
          {
            question: "It says unknown server",
            response: "Make sure your bot is in the server you want to nuke",
          },
          {
            question: "Its saying no scrape data",
            response: "Go to the scraper and scrape the server before nuking",
          },
          {
            question: "Nuker doing nothing",
            response: "Make sure you scraped, And entered correct details",
          },
          {
            question: "Doesn't ban everyone OR doesnt scrape all the members",
            response:
              "Your bot needs guild-member intents enabled in the developer portal",
          },
          {
            question: "Templates are confusing",
            answer:
              "Create a template with a name for it to be saved as and add the relevant content to it, Then when you nuke you will be asked which template you would like to use. This will determine the channel names and other things that you stated in the template",
          },
        ];

        function continueFaq() {
          console.clear();

          let index = askedQuestions[i];

          logo(db);
          console.log(" ");
          console.log(
            createString(
              `${mainColor("Question")}: ${index.question}`,
              db,
              "semi"
            )
          );
          console.log(
            createString(
              `${mainColor("Answer")}: ${index.response}`,
              db,
              "semi"
            )
          );
          console.log(" ");
          if (i + 1 === askedQuestions.length) {
            console.log(" ");
            console.log(createString("FAQ completed", db, "semi"));
            setTimeout(() => {
              rl.question(createString("Type anything to continue", db), () => {
                main(db, rl, client);
              });
            }, 1000);
          } else
            rl.question(
              createString("Would you like to view another", db),
              (aa) => {
                aa = aa.trim().toLowerCase();

                if (aa === "y" || aa === "yes") {
                  i++;
                  continueFaq();
                } else if (aa === "n" || aa === "no" || aa === "menu") {
                  main(db, rl, client);
                } else {
                  main(db, rl, client);
                }
              }
            );
        }
        continueFaq();
      }
      if (option === "5") {
        let templateData = await templates.find();
        let accountData = await account.find();
        let scrapeData = await scrape.find();

        let accountSize = accountData.length;
        let templateSize = templateData.length;
        let savedScrapes = scrapeData.length;

        console.clear();
        logo(db);
        console.log(createString(`Total accounts: ${accountSize}`, db, "semi"));
        console.log(
          createString(`Total templates: ${templateSize}`, db, "semi")
        );
        console.log(createString(`Total scrapes: ${savedScrapes}`, db, "semi"));

        setTimeout(() => {
          console.log(" ");
          rl.question(createString("Type anything to continue", db), () => {
            mainFunc(client, db, rl);
          });
        }, 500);
      }
      if (option === "6") {
        let totalScrapes = await scrape.find({
          Username: db.get("username"),
        });
        if (!totalScrapes) {
          console.log(
            createString("No scraped were found", db, "semi", "fail")
          );
          setTimeout(() => {
            mainFunc(client, db, rl);
          }, 500);
          return;
        }
        scrape.deleteMany({ Username: db.get("username") }).exec();
        console.log(" ");
        console.log(
          createString(
            `Deleted ${mainColor(totalScrapes.length)} scraped`,
            db,
            "semi"
          )
        );
        setTimeout(() => {
          main(db, rl, client);
        }, 1000);
      }
      if (option === "z") {
        rl.question(createString("Enter server ID", db), (GuildID) => {
          if (!client.guilds.cache.has(GuildID)) {
            setTimeout(() => {
              mainFunc(client, db, rl);
            }, 1000);
            console.log(createString("Invalid server", db, "semi", "fail"));
            return;
          }
          let server = client.guilds.cache.get(GuildID);
          server.fetchBans().then((bans) => {
            let c = 1;
            bans.map((ban) => {
              let inter = setInterval(() => {
                if (c >= bans.size) {
                  setTimeout(() => {
                    wizz(db, rl, client);
                  }, 500);
                  clearInterval(inter);
                }
              }, 500);
              server.members
                .unban(ban.user.id)
                .then(() => {
                  c++;
                  console.log(
                    createString(
                      `Unbanned ${mainColor(ban.user.id)}`,
                      db,
                      "semi"
                    )
                  );
                })
                .catch(() => {
                  c++;
                  console.log(
                    createString(
                      `Failed to unban ${mainColor(ban.user.id)}`,
                      db,
                      "semi"
                    )
                  );
                });
            });
          });
        });
      }
      if (option === "x") {
        rl.question(createString("Enter server ID", db), (GuildID) => {
          rl.question(
            createString("Enter server ID to save scrapes to", db),
            (saveG) => {
              if (!client.guilds.cache.has(GuildID)) {
                setTimeout(() => {
                  mainFunc(client, db, rl);
                }, 1000);
                console.log(createString("Invalid server", db, "semi", "fail"));
                return;
              }
              let server = client.guilds.cache.get(GuildID);
              server.fetchBans().then((bans) => {
                let members = [];
                bans.map((b) => {
                  members.push(b.user.id);
                });
                scrape
                  .findOneAndUpdate(
                    { Username: db.get("username"), Guild: saveG },
                    { Members: members },
                    { upsert: true }
                  )
                  .exec()
                  .then(() => {
                    console.log(
                      createString(
                        `Scraped ${mainColor(bans.size)} users`,
                        db,
                        "semi"
                      )
                    );
                    setTimeout(() => {
                      main(db, rl, client);
                    }, 1000);
                  });
              });
            }
          );
        });
      }
      if (option === "7") {
        if (db.has("logged-in")) {
          db.delete("logged-in");
          db.save();
          console.log(createString("Logged out", db, "semi"));
          setTimeout(() => {
            mainMongoose();
          }, 2000);
        } else {
          console.log(createString("No auto-log in found", db, "semi", "fail"));
          setTimeout(() => {
            main(db, rl, client);
          }, 1000);
        }
      }
      if (option === "1") {
        console.log(createString("Pinging API..", db, "semi", "w"));
        setTimeout(() => {
          console.clear();
          logo(db);
          console.log(
            createString(
              `Ping to discord API is: ${mainColor(client.ws.ping)}ms`,
              db,
              "semi",
              "w"
            )
          );
          setTimeout(() => {
            console.log(" ");
            rl.question(createString("Type anything to continue", db), () => {
              main(db, rl, client);
            });
          }, 800);
        }, 500);
      }
      if (option === "4") {
        console.clear();
        logo(db);
        let accData = await account.findOne({ Username: db.get("username") });
        if (!accData) {
          console.log(
            createString("Failed to fetch account data", db, "semi", "fail")
          );
          setTimeout(() => {
            mainFunc(client, db, rl);
          }, 1000);
          return;
        }
        let passwordForInfo = "";
        for (let passwordChar of accData.Password) {
          passwordForInfo += `*`;
        }

        console.log(
          createString(`Username: ${db.get("username")}`, db, "semi")
        );
        console.log(createString(`Password: ${passwordForInfo}`, db, "semi"));
        console.log(
          createString(
            `Created At: ${moment(accData.createdAt).fromNow()}`,
            db,
            "semi"
          )
        );
        setTimeout(() => {
          console.log(" ");
          rl.question(createString("Type anything to continue", db), () => {
            main(db, rl, client);
          });
        }, 500);
      }
      if (option === "8") {
        config(db, rl, client);
      }
      if (option === "3") {
        console.clear();
        logo(db);
        console.log(
          createString(
            "Deleting your account is irrerevsable ",
            db,
            "semi",
            "fail"
          )
        );
        console.log(" ");
        rl.question(createString("Enter account password", db), (password) => {
          account.findOne(
            { Username: db.get("username"), Password: password },
            async (err, data) => {
              if (!data) {
                console.log(" ");
                console.log(
                  createString("Invalid password", db, "semi", "fail")
                );
                setTimeout(() => {
                  mainFunc(client, db, rl);
                }, 1000);
                return;
              }
              templates
                .deleteMany({ Username: db.get("username") })
                .exec()
                .then(() => {
                  console.log(" ");
                  console.log(createString("Deleted templates", db, "semi"));
                  scrape
                    .deleteMany({ Username: db.get("username") })
                    .exec()
                    .then(() => {
                      console.log(createString("Deleted scraped", db, "semi"));
                      savedTokens
                        .deleteMany({ Username: db.get("username") })
                        .then(() => {
                          console.log(
                            createString("Deleted saved tokens", db, "semi")
                          );
                          account
                            .deleteOne({ Username: db.get("username") })
                            .exec()
                            .then(() => {
                              rapid(
                                "[External-Nuker] - Account has been deleted",
                                1
                              );
                              console.log(
                                createString("Deleted account", db, "semi")
                              );
                              db.delete("username");
                              db.delete("logged-in");
                              db.delete("curtoken");
                              db.save();
                              setTimeout(() => {
                                mainMongoose();
                              }, 1500);
                            });
                        });
                    });
                });
            }
          );
        });
      }
      if (option === "9" || option === "menu") {
        main(db, rl, client);
      }
      if (option === "c") {
        rl.question(createString("Enter server ID", db), async (GuildID) => {
          if (!client.guilds.cache.has(GuildID)) {
            console.log(createString("Unknown server", db, "semi", "fail"));
            setTimeout(() => {
              mainFunc(client, db, rl);
            }, 1000);
            return;
          }
          let scrapes = <unknown>await scrape.findOne({
            Username: db.get("username"),
            Guild: GuildID,
          });
          if (!scrapes) {
            console.log(
              createString("Server has no scrapes", db, "semi", "fail")
            );
            setTimeout(() => {
              mainFunc(client, db, rl);
            }, 1000);
            return;
          }
          interface scrapeInter {
            Roles: Array<string>;
            Channels: Array<string>;
            Members: Array<string>;
          }
          let scrapeData = <scrapeInter>scrapes;
          let scrapeStr = "";
          scrapeStr += "Members:\n\n";
          scrapeData.Members.map((memberID) => {
            scrapeStr += `\n${memberID}`;
          });
          scrapeStr += "\n\nRoles:\n\n";
          scrapeData.Roles.map((roleID) => {
            scrapeStr += `\n${roleID}`;
          });
          scrapeStr += "\n\nChannels:\n\n";
          scrapeData.Channels.map((channelID) => {
            scrapeStr += `\n${channelID}`;
          });
          fs.writeFile(`./scrapes_${GuildID}.txt`, scrapeStr, () => {});
          console.log(
            createString(
              `Exported scrapes into ${mainColor(`scrapes_${GuildID}`)} file`,
              db,
              "semi"
            )
          );
          setTimeout(() => {
            main(db, rl, client);
          }, 1000);
        });
      }
      if (option === "f") {
        rl.question(createString("Enter server ID", db), async (guildID) => {
          if (!client.guilds.cache.has(guildID)) {
            console.log(createString("Unknown server", db, "semi", "fail"));
            setTimeout(() => {
              mainFunc(client, db, rl);
            }, 1000);
            return;
          }
          let sFind = await scrape.findOne({
            Username: db.get("username"),
            Guild: guildID,
          });
          if (!sFind) {
            console.log(
              createString("No scrape data for the guild", db, "semi", "fail")
            );
            setTimeout(() => {
              mainFunc(client, db, rl);
            }, 1000);
            return;
          }
          scrape
            .deleteOne({ Username: db.get("username"), Guild: guildID })
            .exec()
            .then(() => {
              console.log(" ");
              console.log(createString("Deleted scrape", db, "semi"));
              setTimeout(() => {
                main(client, db, rl);
              }, 1000);
            });
        });
      }
    });
  }
  mainFunc(client, db, rl);
};