import { sendToContentScript } from '@plasmohq/messaging';

import {
  DEFAULT_DOMAIN_CONFIG,
  DEFAULT_EXTENSION_DATA,
  EXTENSION_MENU_ITEM_ID,
  REPORT_MENU_ITEM_ID,
  SETTINGS_MENU_ITEM_ID,
} from '~utils/constants';
import { formatDomainFromURL, validateSupport } from '~utils/domain';
import { noop, suppressLastError } from '~utils/error';
import { storage } from '~utils/storage';
import type { DomainConfig, ExtensionData } from '~utils/types';

import databaseRefreshHandler from './messages/database/refresh';
import extensionUpdateAvailableHandler from './messages/extension/updateAvailable';

chrome.contextMenus.onClicked.addListener((info) => {
  switch (info.menuItemId) {
    case REPORT_MENU_ITEM_ID:
      chrome.action.openPopup();
      break;
    case SETTINGS_MENU_ITEM_ID:
      chrome.runtime.openOptionsPage();
      break;
    default:
      break;
  }
});

chrome.runtime.onInstalled.addListener(async () => {
  chrome.contextMenus.removeAll(() => {
    const documentUrlPatterns = chrome.runtime.getManifest().content_scripts?.[0].matches;

    chrome.contextMenus.create(
      {
        contexts: ['all'],
        documentUrlPatterns,
        id: EXTENSION_MENU_ITEM_ID,
        title: 'Cookie Dialog Monster',
      },
      suppressLastError
    );
    chrome.contextMenus.create(
      {
        contexts: ['all'],
        documentUrlPatterns,
        id: SETTINGS_MENU_ITEM_ID,
        parentId: EXTENSION_MENU_ITEM_ID,
        title: chrome.i18n.getMessage('contextMenu_settingsOption'),
      },
      suppressLastError
    );
    chrome.contextMenus.create(
      {
        contexts: ['all'],
        documentUrlPatterns,
        id: REPORT_MENU_ITEM_ID,
        parentId: EXTENSION_MENU_ITEM_ID,
        title: chrome.i18n.getMessage('contextMenu_reportOption'),
      },
      suppressLastError
    );
  });

  await storage.remove('updateAvailable');
  await databaseRefreshHandler({ name: 'database/refresh' }, { send: noop });
});

chrome.runtime.onStartup.addListener(async () => {
  await storage.remove('updateAvailable');
  await databaseRefreshHandler({ name: 'database/refresh' }, { send: noop });
  await extensionUpdateAvailableHandler({ name: 'extension/updateAvailable' }, { send: noop });
});

/**
 * @description Listen to the moment before a request is made to apply the rules
 * @returns {Promise<void>}
 */
chrome.webRequest.onBeforeRequest.addListener(
  (details) => {
    const { tabId, type, url } = details;
    const location = new URL(url);
    const domain = formatDomainFromURL(location);

    if (tabId > -1 && type === 'main_frame') {
      storage.get<ExtensionData>('data').then(({ exclusions, rules } = DEFAULT_EXTENSION_DATA) => {
        if (!validateSupport(location.hostname, exclusions.domains)) {
          return;
        }

        storage.get<DomainConfig>(domain).then((config = DEFAULT_DOMAIN_CONFIG) => {
          if (rules.length) {
            const rulesWithTabId = rules.map((rule) => ({
              ...rule,
              condition: { ...rule.condition, tabIds: [tabId] },
            }));

            chrome.declarativeNetRequest.updateSessionRules({
              addRules: config.on ? rulesWithTabId : undefined,
              removeRuleIds: rules.map((rule) => rule.id),
            });
          }
        });
      });
    }
  },
  { urls: ['<all_urls>'] }
);

/**
 * @description Listen for errors on network requests
 */
chrome.webRequest.onErrorOccurred.addListener(
  async (details) => {
    const { error, tabId } = details;

    if (error === 'net::ERR_BLOCKED_BY_CLIENT' && tabId > -1) {
      await sendToContentScript({
        body: {
          value: error,
        },
        name: 'INCREASE_LOG_COUNT',
        tabId,
      });
    }
  },
  { urls: ['<all_urls>'] }
);