import { AxiosInstance, AxiosRequestConfig, CreateAxiosDefaults } from 'axios';
import { getRandomOne, Lock, md5, randomStr, sleep } from './index';
import { CreateAxiosProxy, CreateNewPage } from './proxyAgent';
import { Page } from 'puppeteer';
import Mailjs from '@cemalgnlts/mailjs';
// @ts-ignore
import * as cheerio from 'cheerio';

export enum TempEmailType {
  // need credit card https://rapidapi.com/Privatix/api/temp-mail
  TempEmail = 'temp-email',
  // not need credit card , hard limit 100/day https://rapidapi.com/calvinloveland335703-0p6BxLYIH8f/api/temp-mail44
  TempEmail44 = 'temp-email44',
  // not need credit card and not need credit rapid_api_key
  TempMailLOL = 'tempmail-lol',
  Inbox = 'inbox',
  Internal = 'internal',
  SmailPro = 'smail-pro',
  SmailProGmail = 'smail-pro-gmail',
  SmailProGoogleMail = 'smail-pro-googlemail',
  SmailProOutlook = 'smail-pro-outlook',
  SmailProRandom = 'smail-pro-random',
  SmailProStoreGmail = 'smail-pro-storegmail',
  Gmail = 'gmail',
  EmailNator = 'emailnator',
  MailTM = 'mailtm',
  YopMail = 'yopmail',
}

const gmailLock = new Lock();
const smailProLock = new Lock();

export function CreateEmail(
  tempMailType: TempEmailType,
  options?: BaseOptions,
): BaseEmail {
  switch (tempMailType) {
    case TempEmailType.TempEmail44:
      return new TempMail44(options);
    case TempEmailType.TempEmail:
      return new TempMail(options);
    case TempEmailType.TempMailLOL:
      return new TempMailLOL(options);
    case TempEmailType.Inbox:
      return new Inbox(options);
    case TempEmailType.Internal:
      return new Internal(options);
    case TempEmailType.SmailPro:
      return new SmailPro({
        ...options,
        lock: smailProLock,
        mail: 'gmail.com',
      });
    case TempEmailType.SmailProGmail:
      return new SmailPro({
        ...options,
        lock: smailProLock,
        mail: 'gmail.com',
      });
    case TempEmailType.SmailProGoogleMail:
      return new SmailPro({
        ...options,
        lock: smailProLock,
        mail: 'googlemail.com',
      });
    case TempEmailType.SmailProOutlook:
      return new SmailPro({
        ...options,
        lock: smailProLock,
        mail: 'outlook.com',
      });
    case TempEmailType.SmailProRandom:
      return new SmailPro({
        ...options,
        lock: smailProLock,
        mail: 'random',
      });
    case TempEmailType.SmailProStoreGmail:
      return new SmailPro({
        ...options,
        lock: smailProLock,
        mail: 'storegmail.net',
      });
    case TempEmailType.Gmail:
      return new Gmail({ ...options, lock: gmailLock });
    case TempEmailType.EmailNator:
      return new EmailNator(options);
    case TempEmailType.MailTM:
      return new MailTM();
    case TempEmailType.YopMail:
      return new YopMail();
    default:
      throw new Error('not support TempEmailType');
  }
}

export interface BaseMailMessage {
  // main content of email
  content: string;
}

export interface TempMailMessage extends BaseMailMessage {
  _id: {
    oid: string;
  };
  createdAt: {
    milliseconds: number;
  };
  mail_id: string;
  mail_address_id: string;
  mail_from: string;
  mail_subject: string;
  mail_preview: string;
  mail_text_only: string;
  mail_text: string;
  mail_html: string;
  mail_timestamp: number;
  mail_attachments_count: number;
  mail_attachments: {
    attachment: any[];
  };
}

interface BaseOptions {}

abstract class BaseEmail {
  public constructor(options?: BaseOptions) {}

  public abstract getMailAddress(): Promise<string>;

  public abstract waitMails(): Promise<BaseMailMessage[]>;
}

export interface TempMailOptions extends BaseOptions {
  apikey?: string;
}

class Inbox extends BaseEmail {
  private readonly client: AxiosInstance;
  private address: string | undefined;

  constructor(options?: TempMailOptions) {
    super(options);
    const apikey = options?.apikey || process.env.rapid_api_key;
    if (!apikey) {
      throw new Error('Need apikey for TempMail');
    }
    this.client = CreateAxiosProxy(
      {
        baseURL: 'https://inboxes-com.p.rapidapi.com',
        headers: {
          'X-RapidAPI-Key': apikey,
          'X-RapidAPI-Host': 'inboxes-com.p.rapidapi.com',
        },
      } as CreateAxiosDefaults,
      false,
    );
  }

  public async getMailAddress(): Promise<string> {
    this.address = `${randomStr()}@${await this.randomDomain()}`;
    const res = await this.client.post(`inboxes/${this.address}`);
    console.log(res.data);
    return this.address;
  }

  public async waitMails(): Promise<TempMailMessage[]> {
    return new Promise((resolve) => {
      let time = 0;
      const itl = setInterval(async () => {
        const response = await this.client.get(`inboxes/${this.address}`);
        if (response.data && response.data.length > 0) {
          resolve(
            response.data.map((item: any) => ({
              ...item,
              content: item.mail_html,
            })),
          );
          clearInterval(itl);
          return;
        }
        if (time > 5) {
          resolve([]);
          clearInterval(itl);
          return;
        }
        time++;
      }, 10000);
    });
  }

  async getDomainsList(): Promise<string[]> {
    const res = await this.client.get(`/domains`);
    return res.data.map((item: any) => item.qdn);
  }

  async randomDomain(): Promise<string> {
    const domainList = await this.getDomainsList();
    return domainList[Math.floor(Math.random() * domainList.length)];
  }
}

class TempMail extends BaseEmail {
  private readonly client: AxiosInstance;
  private address: string | undefined;
  private mailID: string = '';

  constructor(options?: TempMailOptions) {
    super(options);
    const apikey = options?.apikey || process.env.rapid_api_key;
    if (!apikey) {
      throw new Error('Need apikey for TempMail');
    }
    this.client = CreateAxiosProxy({
      baseURL: 'https://privatix-temp-mail-v1.p.rapidapi.com/request/',
      headers: {
        'X-RapidAPI-Key': apikey,
        'X-RapidAPI-Host': 'privatix-temp-mail-v1.p.rapidapi.com',
      },
    } as CreateAxiosDefaults);
  }

  public async getMailAddress(): Promise<string> {
    this.address = `${randomStr()}${await this.randomDomain()}`;
    this.mailID = md5(this.address);
    return this.address;
  }

  public async waitMails(): Promise<TempMailMessage[]> {
    const mailID = this.mailID;
    return new Promise((resolve) => {
      let time = 0;
      const itl = setInterval(async () => {
        const response = await this.client.get(`/mail/id/${mailID}`);
        if (response.data && response.data.length > 0) {
          resolve(
            response.data.map((item: any) => ({
              ...item,
              content: item.mail_html,
            })),
          );
          clearInterval(itl);
          return;
        }
        if (time > 5) {
          resolve([]);
          clearInterval(itl);
          return;
        }
        time++;
      }, 10000);
    });
  }

  async getDomainsList(): Promise<string[]> {
    const res = await this.client.get(`/domains/`);
    return res.data;
  }

  async randomDomain(): Promise<string> {
    const domainList = await this.getDomainsList();
    return domainList[Math.floor(Math.random() * domainList.length)];
  }
}

class TempMail44 extends BaseEmail {
  private readonly client: AxiosInstance;
  private address: string = '';

  constructor(options?: TempMailOptions) {
    super(options);
    const apikey = options?.apikey || process.env.rapid_api_key;
    if (!apikey) {
      throw new Error('Need apikey for TempMail');
    }
    this.client = CreateAxiosProxy(
      {
        baseURL: 'https://temp-mail44.p.rapidapi.com/api/v3/email/',
        headers: {
          'X-RapidAPI-Key': apikey,
          'X-RapidAPI-Host': 'temp-mail44.p.rapidapi.com',
        },
      } as CreateAxiosDefaults,
      false,
    );
  }

  public async getMailAddress(): Promise<string> {
    const response = await this.client.post('/new', {}, {
      headers: {
        'content-type': 'application/json',
      },
    } as AxiosRequestConfig);
    this.address = response.data.email;
    return this.address;
  }

  public async waitMails(): Promise<TempMailMessage[]> {
    return new Promise((resolve) => {
      let time = 0;
      const itl = setInterval(async () => {
        try {
          const response = await this.client.get(`/${this.address}/messages`);
          if (response.data && response.data.length > 0) {
            resolve(
              response.data.map((item: any) => ({
                ...item,
                content: item.body_html,
              })),
            );
            clearInterval(itl);
            return;
          }
          if (time > 5) {
            resolve([]);
            clearInterval(itl);
            return;
          }
          time++;
        } catch (e: any) {
          console.error('tempmail lol error', e.message);
        }
      }, 10000);
    });
  }
}

class TempMailLOL extends BaseEmail {
  private readonly client: AxiosInstance;
  private address: string = '';
  private token: string = '';

  constructor(options?: TempMailOptions) {
    super(options);
    this.client = CreateAxiosProxy({
      baseURL: 'https://api.tempmail.lol',
    } as CreateAxiosDefaults);
  }

  public async getMailAddress(): Promise<string> {
    const response = await this.client.get('/generate');
    this.address = response.data.address;
    this.token = response.data.token;
    return this.address;
  }

  public async waitMails(): Promise<TempMailMessage[]> {
    return new Promise((resolve) => {
      let time = 0;
      const itl = setInterval(async () => {
        const response = await this.client.get(`/auth/${this.token}`);

        if (response.data && response.data.email.length > 0) {
          resolve(
            response.data.email.map((item: any) => ({
              ...item,
              content: item.html,
            })),
          );
          clearInterval(itl);
          return;
        }
        if (time > 5) {
          resolve([]);
          clearInterval(itl);
          return;
        }
        time++;
      }, 10000);
    });
  }
}

class Internal extends BaseEmail {
  private apiUrl: string;
  private client: AxiosInstance;

  constructor(options?: BaseOptions) {
    super(options);
    this.apiUrl = 'https://api.internal.temp-mail.io/api/v3';
    this.client = CreateAxiosProxy({
      baseURL: 'https://api.internal.temp-mail.io/api/v3',
    });
  }

  public async getMailAddress(): Promise<string> {
    const length = Math.floor(Math.random() * (15 - 8 + 1)) + 8;
    const characters =
      'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
    let address = '';
    for (let i = 0; i < length; i++) {
      address += characters.charAt(
        Math.floor(Math.random() * characters.length),
      );
    }
    const data = {
      name: address,
      domain: 'gixenmixen.com',
    };
    const response = await this.client.post('/email/new', data);
    const result = response.data;
    console.log(data);
    console.log(result);
    return result.email;
  }

  public async waitMails(): Promise<BaseMailMessage[]> {
    const mailAddress = await this.getMailAddress();
    let times = 0;
    while (true) {
      const response = await this.client.get(`/email/${mailAddress}/messages`);
      console.log(`正在获取邮件：${times}`);
      if (response.status === 200) {
        const data = response.data;
        if (data.length > 0) {
          try {
            const mail = data[0];
            const content = mail.body_html;
            const parser = new DOMParser();
            const htmlDoc = parser.parseFromString(content, 'text/html');
            const codeDiv = htmlDoc.querySelector(
              "div[style='font-family:system-ui, Segoe UI, sans-serif;font-size:19px;font-weight:700;line-height:1.6;text-align:center;color:#333333;']",
            );
            const code = codeDiv?.textContent || '';
            return [{ content: code }];
          } catch (error) {
            console.log('error');
          }
          break;
        }
      }
      await new Promise((resolve) => setTimeout(resolve, 200));
      times++;
    }
    return [];
  }
}

export class SmailPro extends BaseEmail {
  private page!: Page;
  private mail: string;

  constructor(options: SmailProOptions) {
    super(options);
    this.mail = options.mail || 'gmail';
  }

  async getMailAddress() {
    try {
      if (!this.page) {
        this.page = await CreateNewPage('http://smailpro.com/advanced', {
          simplify: true,
        });
        setTimeout(() => {
          this.page
            ?.browser()
            .close()
            .catch((e) => console.error(e.message));
        }, 360 * 1000);
      }
      const page = this.page;
      await sleep(5000);
      await page.waitForSelector('.grid > div > div > button:nth-child(2)');
      await page.click('.grid > div > div > button:nth-child(2)');

      await page.waitForSelector(
        '.relative > .absolute > .text-gray-500 > .h-6 > path',
      );
      await page.click('.relative > .absolute > .text-gray-500 > .h-6 > path');
      await sleep(1000);
      await page.waitForSelector('#autosuggest__input', { visible: true });
      await page.click('#autosuggest__input');
      await page.keyboard.type(`random@${this.mail}`);
      await page.keyboard.press('Enter');
      console.log('generating email');
      await sleep(5000);
      let times = 0;
      while (true) {
        times += 1;
        await page.waitForSelector('div > h1');
        const [email, domain] = await page.evaluate(() =>
          // @ts-ignore
          document.querySelector('div > h1').textContent.split(' '),
        );
        if (email === '...') {
          if (times > 5) {
            throw new Error('get mail failed, max retry times!');
          }
          await sleep(5 * 1000);
          continue;
        }
        return email + domain;
      }
    } catch (e) {
      console.log('get mail failed, err:', e);
      await this.page?.screenshot({
        path: `./run/smailpro_${randomStr(10)}.png`,
      });
      this.page?.browser?.().close();
      throw e;
    }
  }

  async waitMails(): Promise<BaseMailMessage[]> {
    const page = this.page;
    if (!page) {
      return [];
    }
    let times = 0;
    while (true) {
      try {
        await page.waitForSelector(
          '.flex-auto > .flex > .inline-flex > .order-last > .h-6',
          { timeout: 5 * 1000 },
        );
        await page.click(
          '.flex-auto > .flex > .inline-flex > .order-last > .h-6',
        );

        await page.waitForSelector(
          '.flex-auto > .flex > .py-2 > .scrollbar > .px-2',
          { timeout: 5 * 1000 },
        );
        await page.click('.flex-auto > .flex > .py-2 > .scrollbar > .px-2');

        await page.waitForSelector('.flex > div > div > .mt-2 > .w-full', {
          timeout: 5 * 1000,
        });
        // 获取 srcdoc 属性
        const content = await page.evaluate(() => {
          return (
            //@ts-ignore
            // prettier-ignore
            document.querySelector('.flex > div > div > .mt-2 > .w-full')?.contentDocument.documentElement.outerHTML || ''
          );
        });
        if (content) {
          await this.page?.browser().close();
          return [{ content }];
        }
        await sleep(10 * 1000);
      } catch (e: any) {
        if (times >= 6) {
          await this.page?.screenshot({
            path: `./run/smailpro_${randomStr(10)}.png`,
          });
          await this.page?.browser().close();
          throw new Error('got mails failed');
        }
      } finally {
        times += 1;
      }
    }

    return [];
  }
}

export interface GmailOptions extends BaseOptions {
  lock: Lock;
}

export interface SmailProOptions extends GmailOptions {
  lock: Lock;
  mail: string;
}

class Gmail extends BaseEmail {
  private readonly client: AxiosInstance;
  private address: string = '';
  private timestamp?: number = 0;
  private lock: Lock;

  constructor(options: GmailOptions) {
    super(options);
    const apikey = process.env.rapid_api_key || '';
    this.lock = options.lock;
    if (!apikey) {
      throw new Error('Need apikey for TempMail');
    }
    this.client = CreateAxiosProxy(
      {
        baseURL: 'https://temp-gmail.p.rapidapi.com',
        headers: {
          'X-RapidAPI-Key': apikey,
          'X-RapidAPI-Host': 'temp-gmail.p.rapidapi.com',
        },
      } as CreateAxiosDefaults,
      false,
    );
  }

  public async getMailAddress(): Promise<string> {
    await this.lock.lock(60 * 1000);
    const response: any = await this.client.get('/get', {
      params: {
        domain: 'googlemail.com',
        username: 'random',
        server: 'server-2',
        type: 'real',
      },
    } as AxiosRequestConfig);
    this.address = response.data.items.email;
    this.timestamp = response.data.items.timestamp;
    return this.address;
  }

  public async check(): Promise<[boolean, string]> {
    try {
      const checkres = await this.client.get(`/check`, {
        params: {
          email: this.address,
          timestamp: `${this.timestamp}`,
        },
      });
      const mid = checkres.data.items[0]?.mid;
      return [checkres.data.msg === 'ok', mid || ''];
    } catch (e: any) {
      console.log('check email failed, err = ', e.message);
      return [false, ''];
    }
  }

  public async waitMails(): Promise<TempMailMessage[]> {
    return new Promise((resolve) => {
      let time = 0;
      const itl = setInterval(async () => {
        try {
          const [ok, mid] = await this.check();
          if (!mid) {
            return;
          }
          const response = await this.client.get(`/read`, {
            params: { email: this.address, message_id: mid },
          });
          if (response.data && response.data.items) {
            const item = response.data.items;
            resolve([{ ...item, content: item.body }]);
            this.lock.unlock();
            clearInterval(itl);
            return;
          }
          if (time > 5) {
            resolve([]);
            this.lock.unlock();
            clearInterval(itl);
            return;
          }
        } catch (e: any) {
          console.error(e.message);
        }

        time++;
      }, 20 * 1000);
    });
  }
}

export class EmailNator extends BaseEmail {
  page!: Page;
  private clear?: NodeJS.Timeout;
  private email?: string;

  constructor(options?: BaseOptions) {
    super(options);
  }

  async getMailAddress(): Promise<string> {
    try {
      if (!this.page) {
        this.page = await CreateNewPage('https://emailnator.com/');
        await this.page.waitForSelector('#custom-switch-domain');
        await this.page.click('#custom-switch-domain');
        await this.page.waitForSelector(
          '.mb-3 > .card-body > .justify-content-md-center > .mx-auto > .btn-lg',
        );
        await this.page.click(
          '.mb-3 > .card-body > .justify-content-md-center > .mx-auto > .btn-lg',
        );
        this.clear = setTimeout(() => {
          this.page.browser().close();
        }, 360 * 1000);
      }
      await this.page.waitForSelector(
        '.col-lg-7 > .mb-3 > .card-body > .mb-3 > .form-control-lg',
      );
      const emailInput = await this.page.$(
        '.col-lg-7 > .mb-3 > .card-body > .mb-3 > .form-control-lg',
      );
      await sleep(5000);
      // @ts-ignore
      const email = await emailInput.evaluate((el) => el.value);
      // await sleep(10 * 60 * 1000);
      if (!email) {
        throw new Error('get email failed');
      }
      this.email = email;

      await sleep(3000);
      await this.page.waitForSelector(
        '.col-lg-7 > .mb-3 > .card-body > .text-center > .btn-lg',
      );
      await this.page.click(
        '.col-lg-7 > .mb-3 > .card-body > .text-center > .btn-lg',
      );
      return email;
    } catch (e) {
      throw e;
    }
  }

  private async getMails() {
    try {
      await this.page.waitForSelector(
        '.card > .card-body > .mb-3 > .col-md-6 > .float-md-end',
      );
      setImmediate(() => {
        this.page.click(
          '.card > .card-body > .mb-3 > .col-md-6 > .float-md-end',
        );
      });
      const res = await this.page.waitForResponse(
        (res) =>
          res.url() === 'https://www.emailnator.com/message-list' &&
          res.headers()['content-type'].indexOf('application/json') > -1,
      );
      let mails: any[] = (await res.json()).messageData;
      mails = mails.filter((v) => v.messageID !== 'ADSVPN');
      return mails || [];
    } catch (e: any) {
      console.log('get mails failed, err = ', e.message);
      return [];
    }
  }

  async getMailDetail(mail: string, messageID: string) {
    try {
      this.page
        .goto(`https://www.emailnator.com/inbox/${mail}/${messageID}`)
        .catch(console.error);
      const res = await this.page.waitForResponse(
        (res) => res.url() === 'https://www.emailnator.com/message-list',
      );
      return await res.text();
    } catch (e) {
      throw e;
    }
  }

  async waitMails(): Promise<BaseMailMessage[]> {
    let tryTimes = 0;

    return new Promise(async (resolve, reject) => {
      try {
        for (let i = 0; i < 3; i++) {
          const mails = await this.getMails();
          const v = mails.find(
            (v) =>
              v.time.indexOf('Just Now') > -1 ||
              v.time.indexOf('one minute ago') > -1,
          );
          if (!v) {
            if (tryTimes >= 3) {
              reject(new Error('get mail failed'));
              await this.page.browser().close();
              return;
            }
            await sleep(5000);
            continue;
          }
          const content =
            (await this.getMailDetail(this.email || '', v.messageID)) || '';
          resolve([{ content } as BaseMailMessage]);
          setTimeout(() => this.page.browser().close(), 5000);
          return;
        }
        reject(new Error('get mail failed'));
      } catch (e) {
        reject(e);
      }
    });
  }
}

export class MailTM extends BaseEmail {
  private readonly mailjs: Mailjs;
  private password?: string;
  private account?: string;

  constructor() {
    super();
    this.mailjs = new Mailjs();
  }

  async getMailAddress(): Promise<string> {
    const account = await this.mailjs.createOneAccount();

    this.mailjs.on('ready', () => console.log('Ready To Listen!'));
    // @ts-ignore
    return account.data.username;
  }

  async waitMails(): Promise<BaseMailMessage[]> {
    for (let i = 0; i < 3; i++) {
      const messages = await this.mailjs.getMessages(1);
      if (messages.data.length === 0) {
        await sleep(3000);
        continue;
      }
      const one = messages.data[0];
      const message = await this.mailjs.getMessage(one.id);
      return [{ content: message.data.html.join('\n') }];
    }
    return [];
  }
}

export class YopMail extends BaseEmail {
  client = CreateAxiosProxy({ baseURL: 'https://yopmail.com/' }, false, true);
  private realMail!: string;
  private randomMail!: string;
  private mailName!: string;

  async getMailAddress(): Promise<string> {
    this.realMail = await this.getMail();
    this.mailName = this.realMail.split('@')[0];
    const mailSfx = getRandomOne(await this.getMailSuffix());
    this.randomMail = this.realMail.replace('yopmail.com', mailSfx);
    return this.randomMail;
  }

  async waitMails(): Promise<BaseMailMessage[]> {
    let msgs: BaseMailMessage[] = [];
    for (let i = 0; i <= 3; i++) {
      const inbox: { inbox: { id: string; subject: string }[] } =
        await this.getInbox(this.realMail);
      inbox.inbox = inbox.inbox.filter(
        (v) => v.subject.indexOf('Progress report') === -1,
      );
      if (inbox.inbox.length === 0) {
        await sleep(10 * 1000);
        continue;
      }
      for (const v of inbox.inbox) {
        const msg: { data: string } = await this.readMessage(
          this.mailName,
          v.id,
          'html',
        );
        msgs.push({ content: msg.data });
      }
      return msgs;
    }
    throw new Error('wait mail failed');
  }

  async getMailSuffix(): Promise<string[]> {
    const res = await this.client.get('/zh/domain?d=list');
    const regex = /<option>@(.+?)<\/option>/g;
    return [...res.data.matchAll(regex)]
      .map((m) => m[1])
      .filter((v) => typeof v === 'string')
      .filter((v: string) => v.toLowerCase().indexOf('yopmail') === -1);
  }

  async getMail() {
    const response = await this.client.get('/es/email-generator');
    const $ = cheerio.load(response.data);
    const genEmail = $('#geny').text();
    return genEmail.split(';')[1] || genEmail;
  }

  async getInbox(
    mailAddress: string,
    search: any = {},
    settings: any = {},
  ): Promise<any> {
    const mail = (mailAddress.split('@')[0] || '').toLowerCase() || mailAddress;
    const { cookie: cookie, yp: yp } = await this.getCookiesAndYP();
    const yj = await this.getYJ(cookie);
    return await this.detailInbox(mail, yp, yj, cookie, search, settings);
  }

  async getCookiesAndYP() {
    const response = await this.client.get('/');
    const $ = cheerio.load(response.data);
    const yp = $('input#yp').val();
    const cookie = response.headers['set-cookie']
      ?.map((x) => x.split(';')[0])
      .join('; ');
    if (!cookie) {
      throw new Error('cookie is null');
    }
    const location = response.data.match(/lang=\"(.*?)\"/)[1];
    return { cookie: cookie, yp: yp };
  }

  async getYJ(cookie: string) {
    const response = await this.client.get('/ver/8.4/webmail.js', {
      headers: { Cookie: cookie },
    });
    const match = response.data.match(/&yj=([^&]+)&v=/s);
    return match ? match[1] : null;
  }

  shouldIncludeEmail(email: any, filteredSearch: string) {
    return Object.entries(filteredSearch).every(([key, value]) => {
      switch (key) {
        case 'id':
          return email.id === value;
        case 'from':
          return email.from === value;
        case 'subject':
          return email.subject === value;
        case 'timestamp':
          return email.timestamp === value;
        default:
          return false;
      }
    });
  }

  getDetailInboxFromPage(html: string, filteredSearch: any) {
    const $ = cheerio.load(html);
    const elements = $('.m');
    return elements
      .map((index, element) => this.parseEmail(element))
      .toArray()
      .filter((email) => this.shouldIncludeEmail(email, filteredSearch));
  }

  async fetchInboxPage(
    mail: string,
    yp: string,
    yj: string,
    pageNumber: number,
    cookie: string,
  ) {
    return await this.client.get(
      `/es/inbox?login=${mail}&p=${pageNumber}&d=&ctrl=&yp=${yp}&yj=${yj}&v=8.4&r_c=&id=`,
      {
        headers: {
          accept:
            'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
          cookie: `${cookie}; compte=${mail}; ywm=${mail}; _ga=GA1.2.490358059.1683208319; _gid=GA1.2.1148489241.1683208319; __gads=ID=8e03875306c449c6-22790dab88df0074:T=1683208320:RT=1683208320:S=ALNI_MasidzVb7xQcb0qS7Hrb-gTpCYFkQ; __gpi=UID=0000057b04df1c7f:T=1683208320:RT=1696576052:S=ALNI_MYMeBMqh92Qfh-oIx02VDmWeqsdAA; compte=${mail}; ywm=${mail}; ytime=15:7;`,
          'accept-encoding': 'gzip, deflate, br',
          'accept-language': 'es-ES,es;q=0.9',
          connection: 'keep-alive',
          host: 'yopmail.com',
          referer: 'https://yopmail.com/es/wm',
          'sec-ch-ua':
            '"Chromium";v="112", "Google Chrome";v="112", "Not:A-Brand";v="99"',
          'sec-ch-ua-mobile': '?0',
          'sec-ch-ua-platform': 'Windows',
          'sec-fetch-dest': 'iframe',
          'sec-fetch-mode': 'navigate',
          'sec-fetch-site': 'same-origin',
          'upgrade-insecure-requests': '1',
          'user-agent':
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36',
        },
      },
    );
  }

  async getTotalMails(html: string) {
    const match = html.match(/w\.finrmail\((.*?)\)/);
    let totalMails = 0;
    if (match) {
      totalMails = Number(match[1].split(',')[0]);
    }
    return totalMails;
  }

  private possibleKeys = ['id', 'from', 'subject', 'timestamp'];

  async validateSearch(search: any) {
    const result = this.possibleKeys.some(
      (key) => Object.keys(search).includes(key) || null,
    );
    if (!result) {
      throw new Error('Invalid search');
    }
    return Object.keys(search).reduce((acc: any, key) => {
      if (this.possibleKeys.includes(key)) {
        acc[key] = search[key];
      }
      return acc;
    }, {});
  }

  parseEmail(element: any) {
    const $ = cheerio.load(element);
    const id = $(element).attr('id');
    const timestamp = $(element).find('.lmh').text();
    const from = $(element).find('.lmf').text();
    const subject = $(element).find('.lms').text();
    return { id: id, from: from, subject: subject, timestamp: timestamp };
  }

  async detailInbox(
    mail: string,
    yp: any,
    yj: string,
    cookie: string,
    search = {},
    settings: { GET_ALL_MAILS?: boolean } = {},
  ) {
    const pageNumber = 1;
    const response = await this.fetchInboxPage(
      mail,
      yp,
      yj,
      pageNumber,
      cookie,
    );
    const inboxHtml = response.data;
    const totalMails = await this.getTotalMails(inboxHtml);
    let filteredSearch = {};
    if (search && Object.keys(search).length > 0) {
      filteredSearch = await this.validateSearch(search);
    }
    let currentPage = 1;
    let hasNextPage = true;
    let mailFromPage: any = {};
    const mailsPerPage = 15;
    const emails = [];
    while (
      hasNextPage &&
      (settings.GET_ALL_MAILS === true || currentPage === 1)
    ) {
      const currentPageHtml =
        currentPage === 1
          ? inboxHtml
          : (await this.fetchInboxPage(mail, yp, yj, currentPage, cookie)).data;
      const currentPageEmails = this.getDetailInboxFromPage(
        currentPageHtml,
        filteredSearch,
      );
      mailFromPage[`page_${currentPage}`] = currentPageEmails.length;
      emails.push(...currentPageEmails);
      if (currentPage * mailsPerPage >= totalMails) {
        hasNextPage = false;
      } else {
        currentPage += 1;
      }
    }
    return {
      settings: settings,
      search: filteredSearch,
      totalInbox: totalMails,
      totalPages: Math.ceil(totalMails / mailsPerPage),
      mailFromPage: mailFromPage,
      totalGetMails: emails.length,
      inbox: emails,
    };
  }

  async readMessage(
    mail: string,
    id: string,
    format: string,
    selector = '',
  ): Promise<any> {
    try {
      const { cookie: cookie } = await this.getCookiesAndYP();
      const response = await this.client.get(`/es/mail?b=${mail}&id=m${id}`, {
        headers: {
          accept:
            'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
          cookie: `${cookie}; compte=${mail}; ywm=${mail}; _ga=GA1.2.490358059.1683208319; _gid=GA1.2.1148489241.1683208319; __gads=ID=8e03875306c449c6-22790dab88df0074:T=1683208320:RT=1683208320:S=ALNI_MasidzVb7xQcb0qS7Hrb-gTpCYFkQ; __gpi=UID=0000057b04df1c7f:T=1683208320:RT=1696576052:S=ALNI_MYMeBMqh92Qfh-oIx02VDmWeqsdAA; compte=${mail}; ywm=${mail}; ytime=15:7;`,
          'accept-encoding': 'gzip, deflate, br',
          'accept-language': 'es-ES,es;q=0.9',
          connection: 'keep-alive',
          host: 'yopmail.com',
          referer: 'https://yopmail.com/es/wm',
          'sec-ch-ua':
            '"Chromium";v="112", "Google Chrome";v="112", "Not:A-Brand";v="99"',
          'sec-ch-ua-mobile': '?0',
          'sec-ch-ua-platform': 'Windows',
          'sec-fetch-dest': 'iframe',
          'sec-fetch-mode': 'navigate',
          'sec-fetch-site': 'same-origin',
          'upgrade-insecure-requests': '1',
          'user-agent':
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36',
        },
      });
      const $ = cheerio.load(response.data);
      const submit = $('div.fl\x20>\x20div.ellipsis.nw.b.f18').text();
      const fromSelector = $(
        'div.fl > div.md.text.zoom.nw.f24 > span.ellipsis.b\n',
      );
      const dateSelector = $(
        'div.fl > div.md.text.zoom.nw.f24 > span.ellipsis:last-child',
      );
      const from = fromSelector.length
        ? fromSelector.text()
        : $('div.fl > div.md.text.zoom.nw.f18 > span.ellipsis.b').text();
      const date = dateSelector.length
        ? dateSelector.text().replace(from, '')
        : $(
            'div.fl\x20>\x20div.md.text.zoom.nw.f18\x20>\x20span.ellipsis:last-child',
          ).text();
      let message;
      if (selector) {
        selector = `${'#mail'} ${selector}`;
        message =
          format.toLowerCase() === 'html'
            ? $(selector).html()
            : $(selector).text().trim();
      } else {
        selector = '#mail';
        message =
          format.toLowerCase() === 'html'
            ? $(selector).html()
            : $(selector).text().trim();
      }
      return {
        id: id,
        submit: submit,
        from: from,
        date: date,
        selector: selector,
        format: format,
        data: message,
      };
    } catch (e) {
      console.error(e);
    }
  }
}