import { BrowserApi } from "../browser/browserApi";

import MainBackground from "./main.background";

import { CipherService } from "jslib-common/abstractions/cipher.service";
import { EventService } from "jslib-common/abstractions/event.service";
import { PasswordGenerationService } from "jslib-common/abstractions/passwordGeneration.service";
import { PlatformUtilsService } from "jslib-common/abstractions/platformUtils.service";
import { TotpService } from "jslib-common/abstractions/totp.service";
import { VaultTimeoutService } from "jslib-common/abstractions/vaultTimeout.service";

import { CipherRepromptType } from "jslib-common/enums/cipherRepromptType";
import { EventType } from "jslib-common/enums/eventType";
import { CipherView } from "jslib-common/models/view/cipherView";
import LockedVaultPendingNotificationsItem from "./models/lockedVaultPendingNotificationsItem";

export default class ContextMenusBackground {
  private readonly noopCommandSuffix = "noop";
  private contextMenus: any;

  constructor(
    private main: MainBackground,
    private cipherService: CipherService,
    private passwordGenerationService: PasswordGenerationService,
    private platformUtilsService: PlatformUtilsService,
    private vaultTimeoutService: VaultTimeoutService,
    private eventService: EventService,
    private totpService: TotpService
  ) {
    this.contextMenus = chrome.contextMenus;
  }

  async init() {
    if (!this.contextMenus) {
      return;
    }

    this.contextMenus.onClicked.addListener(
      async (info: chrome.contextMenus.OnClickData, tab: chrome.tabs.Tab) => {
        if (info.menuItemId === "generate-password") {
          await this.generatePasswordToClipboard();
        } else if (info.menuItemId === "copy-identifier") {
          await this.getClickedElement(tab, info.frameId);
        } else if (
          info.parentMenuItemId === "autofill" ||
          info.parentMenuItemId === "copy-username" ||
          info.parentMenuItemId === "copy-password" ||
          info.parentMenuItemId === "copy-totp"
        ) {
          await this.cipherAction(tab, info);
        }
      }
    );

    BrowserApi.messageListener(
      "contextmenus.background",
      async (msg: any, sender: chrome.runtime.MessageSender, sendResponse: any) => {
        if (msg.command === "unlockCompleted" && msg.data.target === "contextmenus.background") {
          await this.cipherAction(
            msg.data.commandToRetry.sender.tab,
            msg.data.commandToRetry.msg.data
          );
        }
      }
    );
  }

  private async generatePasswordToClipboard() {
    const options = (await this.passwordGenerationService.getOptions())[0];
    const password = await this.passwordGenerationService.generatePassword(options);
    this.platformUtilsService.copyToClipboard(password, { window: window });
    this.passwordGenerationService.addHistory(password);
  }

  private async getClickedElement(tab: chrome.tabs.Tab, frameId: number) {
    if (tab == null) {
      return;
    }

    BrowserApi.tabSendMessage(tab, { command: "getClickedElement" }, { frameId: frameId });
  }

  private async cipherAction(tab: chrome.tabs.Tab, info: chrome.contextMenus.OnClickData) {
    const id = info.menuItemId.split("_")[1];

    if (await this.vaultTimeoutService.isLocked()) {
      const retryMessage: LockedVaultPendingNotificationsItem = {
        commandToRetry: {
          msg: { command: this.noopCommandSuffix, data: info },
          sender: { tab: tab },
        },
        target: "contextmenus.background",
      };
      await BrowserApi.tabSendMessageData(
        tab,
        "addToLockedVaultPendingNotifications",
        retryMessage
      );

      BrowserApi.tabSendMessageData(tab, "promptForLogin");
      return;
    }

    let cipher: CipherView;
    if (id === this.noopCommandSuffix) {
      const ciphers = await this.cipherService.getAllDecryptedForUrl(tab.url);
      cipher = ciphers.find((c) => c.reprompt === CipherRepromptType.None);
    } else {
      const ciphers = await this.cipherService.getAllDecrypted();
      cipher = ciphers.find((c) => c.id === id);
    }

    if (cipher == null) {
      return;
    }

    if (info.parentMenuItemId === "autofill") {
      await this.startAutofillPage(tab, cipher);
    } else if (info.parentMenuItemId === "copy-username") {
      this.platformUtilsService.copyToClipboard(cipher.login.username, { window: window });
    } else if (info.parentMenuItemId === "copy-password") {
      this.platformUtilsService.copyToClipboard(cipher.login.password, { window: window });
      this.eventService.collect(EventType.Cipher_ClientCopiedPassword, cipher.id);
    } else if (info.parentMenuItemId === "copy-totp") {
      const totpValue = await this.totpService.getCode(cipher.login.totp);
      this.platformUtilsService.copyToClipboard(totpValue, { window: window });
    }
  }

  private async startAutofillPage(tab: chrome.tabs.Tab, cipher: CipherView) {
    this.main.loginToAutoFill = cipher;
    if (tab == null) {
      return;
    }

    BrowserApi.tabSendMessage(tab, {
      command: "collectPageDetails",
      tab: tab,
      sender: "contextMenu",
    });
  }
}