/* eslint-disable no-continue */
/* eslint-disable one-var-declaration-per-line */
/* eslint-disable no-await-in-loop */
import axios from 'axios';
import { TextChannel } from 'eris';
import { Client } from '../class';

interface CSResponse {
  found: boolean,
  tier: number,
  totalReferrals?: number,
  createdAt?: Date,
  warns?: Date[],
  locks?: Date[],
  deletes?: Date[],
}

let interval: NodeJS.Timeout;

export default async function calculateScore(client: Client): Promise<NodeJS.Timeout> {
  const start = async () => {
    const { members } = client.guilds.get(client.config.guildID);

    const general = await (<TextChannel> client.guilds.get(client.config.guildID).channels.get('485680288123584525')).getMessages(5000);
    const media = await (<TextChannel> client.guilds.get(client.config.guildID).channels.get('508006539768889354')).getMessages(100);
    const programmingSupport = await (<TextChannel> client.guilds.get(client.config.guildID).channels.get('506970598631538708')).getMessages(300);
    const cloudSupport = await (<TextChannel> client.guilds.get(client.config.guildID).channels.get('546457788184789013')).getMessages(200);
    for (const member of members.values()) {
      if (member.bot) continue;
      let score = await client.db.Score.findOne({ userID: member.user.id });
      if (!score) {
        const data: {
          userID: string,
          total: number,
          activity: number,
          roles: number,
          moderation: number,
          cloudServices: number,
          other: number,
          staff: boolean,
          inquiries: [{ name: string, reason: string}?],
        } = {
          userID: member.user.id,
          total: 0,
          activity: 0,
          roles: 0,
          moderation: 0,
          cloudServices: 0,
          other: 0,
          staff: false,
          inquiries: [],
        };
        score = await (new client.db.Score(data)).save();
        client.util.signale.debug(`SCORE INIT - ${member.username}`);
      }

      // eslint-disable-next-line prefer-const
      // eslint-disable-next-line one-var-declaration-per-line
      // eslint-disable-next-line one-var
      let total = 0, activity = 0, roles = 0, moderation = 0, cloudServices = 0, other = 0, staff = 0;
      cloudServices = 0;

      roles = Math.floor(member.roles.length * 0.50);
      if (roles > 54) roles = 54;

      const moderations = await client.db.Moderation.find({ userID: member.user.id });
      if (moderations?.length > 0) moderation = -moderations.length * 8;
      else moderation = 2;

      const activityTotal = (general.filter((m) => m.member?.id === member.id).length + media.filter((m) => m.member?.id === member.id).length + programmingSupport.filter((m) => m.member?.id === member.id).length + cloudSupport.filter((m) => m.member?.id === member.id).length);
      activity = Math.floor(Math.log1p(activityTotal) * 12);
      if (activity > (Math.log1p(5000 + 300 + 200) * 12 + 100)) activity = Math.floor((Math.log1p(5000 + 300 + 200 + 100) * 12));
      if (member.roles.includes('446104438969466890') || member.roles.includes('701481967149121627')) staff = 20;

      const response = <CSResponse> (await axios.get(`https://api.cloud.libraryofcode.org/wh/score?id=${member.user.id}&authorization=${client.config.internalKey}`)).data;
      if (response.found === true) {
        let negatives = 0;
        let positives = 0;
        const csCreatedTestDate = (new Date(new Date(response.createdAt).setHours(730)));
        if (csCreatedTestDate > new Date()) {
          negatives -= 10;
        }
        if (response.warns.length === 0) positives += 5;
        else {
          for (const warn of response.warns) {
            const date = (new Date(new Date(warn).setHours(730)));
            if (date > new Date()) negatives -= 2;
          }
        }
        if (response.locks.length === 0) positives += 10;
        else {
          for (const lock of response.locks) {
            const date = (new Date(new Date(lock).setHours(1460)));
            if (date > new Date()) negatives -= 5;
          }
        }
        if (response.deletes.length === 0) {
          for (const del of response.deletes) {
            const date = (new Date(new Date(del).setHours(3650)));
            if (date > new Date()) negatives -= 20;
          }
        }
        if (response.tier === 2) positives += 2;
        else if (response.tier === 3) positives += 3;
        if (negatives < 0) cloudServices = Math.floor((negatives * 1.2) + (positives * 0.06));
        else cloudServices = Math.floor(positives * 0.61);
      }

      if (score.inquiries?.length > 0) {
        for (const inq of score.inquiries) {
          const testDate = (new Date(new Date(inq.date).setHours(2190)));
          if (testDate > new Date()) other -= 1.5;
        }
        other = Math.floor(other * 1.15);
      }

      total = Math.floor(((total + activity + roles + moderation + cloudServices + staff + other) * 5.13) * 1.87);

      await score.updateOne({ $set: { total, activity, roles, moderation, cloudServices, other, staff, lastUpdate: new Date() } });
      // client.util.signale.debug(`SCORE SET - ${member.username}\nTotal: ${total}\nActivity: ${activity}\nRoles: ${roles}\nModeration: ${moderation}\nCloud Services: ${cloudServices}\nStaff: ${staff}`);
    }
  };
  await start();
  interval = setInterval(async () => {
    await start();
  }, 1800000);
  return interval;
}