background.js

// ILoveWaves Background Service Worker
class ILoveWavesBackground {
  constructor() {
    this.init();
  }

  init() {
    // Handle extension installation
    chrome.runtime.onInstalled.addListener((details) => {
      if (details.reason === "install") {
        this.handleInstall();
      } else if (details.reason === "update") {
        this.handleUpdate(details.previousVersion);
      }
    });

    // Handle tab updates to manage wave state
    chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
      if (changeInfo.status === "complete" && tab.url) {
        this.handleTabUpdate(tabId, tab);
      }
    });

    // Handle tab activation for performance optimization
    chrome.tabs.onActivated.addListener((activeInfo) => {
      this.handleTabActivation(activeInfo.tabId);
    });

    // Handle storage changes
    chrome.storage.onChanged.addListener((changes, namespace) => {
      if (namespace === "local") {
        this.handleStorageChange(changes);
      }
    });

    // Handle messages from content scripts and popup
    chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
      this.handleMessage(message, sender, sendResponse);
      return true; // Keep message channel open for async response
    });
  }

  handleInstall() {
    console.log("ILoveWaves: Extension installed");

    // Set default settings
    this.setDefaultSettings();

    // Show welcome notification
    chrome.notifications?.create("welcome", {
      type: "basic",
      iconUrl: "icons/icon48.png",
      title: "ILoveWaves Installed! 🌊",
      message:
        "Click the extension icon to start transforming website backgrounds with beautiful waves!",
    });
  }

  handleUpdate(previousVersion) {
    console.log(
      `ILoveWaves: Updated from ${previousVersion} to ${
        chrome.runtime.getManifest().version
      }`
    );

    // Handle migration if needed
    this.migrateSettings(previousVersion);
  }

  async handleTabUpdate(tabId, tab) {
    try {
      const url = new URL(tab.url);
      const domain = url.hostname;

      // Check if waves are enabled for this domain
      const result = await chrome.storage.local.get([domain]);
      const settings = result[domain];

      if (settings?.enabled) {
        // Inject content script if not already injected
        await this.ensureContentScriptInjected(tabId);
      }
    } catch (error) {
      console.error("ILoveWaves: Error handling tab update:", error);
    }
  }

  async handleTabActivation(tabId) {
    try {
      const tab = await chrome.tabs.get(tabId);
      if (tab.url) {
        // Optimize performance for active tab
        await chrome.tabs
          .sendMessage(tabId, {
            action: "optimizeForActiveTab",
            isActive: true,
          })
          .catch(() => {
            // Content script might not be injected yet
          });
      }
    } catch (error) {
      // Tab might be closed or invalid
    }
  }

  handleStorageChange(changes) {
    // Notify all tabs about settings changes
    Object.keys(changes).forEach(async (domain) => {
      if (domain.includes(".")) {
        // It's a domain
        const tabs = await chrome.tabs.query({ url: `*://${domain}/*` });
        tabs.forEach((tab) => {
          chrome.tabs
            .sendMessage(tab.id, {
              action: "settingsChanged",
              domain: domain,
              settings: changes[domain].newValue,
            })
            .catch(() => {
              // Content script might not be ready
            });
        });
      }
    });
  }

  async handleMessage(message, sender, sendResponse) {
    try {
      switch (message.action) {
        case "getTabInfo":
          const tabInfo = await this.getTabInfo(sender.tab?.id);
          sendResponse({ success: true, data: tabInfo });
          break;

        case "optimizePerformance":
          await this.optimizePerformance(message.tabId, message.enable);
          sendResponse({ success: true });
          break;

        case "exportSettings":
          const settings = await this.exportSettings();
          sendResponse({ success: true, data: settings });
          break;

        case "importSettings":
          await this.importSettings(message.settings);
          sendResponse({ success: true });
          break;

        default:
          sendResponse({ success: false, error: "Unknown action" });
      }
    } catch (error) {
      console.error("ILoveWaves: Error handling message:", error);
      sendResponse({ success: false, error: error.message });
    }
  }

  async ensureContentScriptInjected(tabId) {
    try {
      // Try to send a ping message to check if content script is loaded
      await chrome.tabs.sendMessage(tabId, { action: "ping" });
    } catch (error) {
      // Content script not loaded, inject it
      try {
        await chrome.scripting.executeScript({
          target: { tabId: tabId },
          files: ["content.js"],
        });

        await chrome.scripting.insertCSS({
          target: { tabId: tabId },
          files: ["disco.css"],
        });
      } catch (injectionError) {
        console.error(
          "ILoveWaves: Failed to inject content script:",
          injectionError
        );
      }
    }
  }

  async getTabInfo(tabId) {
    if (!tabId) return null;

    try {
      const tab = await chrome.tabs.get(tabId);
      const url = new URL(tab.url);
      return {
        domain: url.hostname,
        url: tab.url,
        title: tab.title,
      };
    } catch (error) {
      return null;
    }
  }

  async optimizePerformance(tabId, enable) {
    try {
      await chrome.tabs.sendMessage(tabId, {
        action: "optimizePerformance",
        enable: enable,
      });
    } catch (error) {
      console.error("ILoveWaves: Error optimizing performance:", error);
    }
  }

  async setDefaultSettings() {
    const defaultGlobalSettings = {
      version: chrome.runtime.getManifest().version,
      installDate: Date.now(),
      totalSitesWithWaves: 0,
      isPremium: false,
    };

    await chrome.storage.local.set({
      "ilove-waves-global": defaultGlobalSettings,
    });
  }

  async migrateSettings(previousVersion) {
    // Handle settings migration between versions
    console.log("ILoveWaves: Migrating settings from", previousVersion);

    // Add migration logic here if needed in future versions
  }

  async exportSettings() {
    const allSettings = await chrome.storage.local.get(null);

    // Filter out only ILoveWaves related settings
    const exportData = {};
    Object.keys(allSettings).forEach((key) => {
      if (key.includes(".") || key.startsWith("ilove-waves-")) {
        exportData[key] = allSettings[key];
      }
    });

    return {
      version: chrome.runtime.getManifest().version,
      exportDate: Date.now(),
      settings: exportData,
    };
  }

  async importSettings(importData) {
    if (!importData.settings) {
      throw new Error("Invalid import data");
    }

    // Validate and import settings
    await chrome.storage.local.set(importData.settings);

    console.log("ILoveWaves: Settings imported successfully");
  }
}

// Initialize background script
const iLoveWavesBackground = new ILoveWavesBackground();

// Handle service worker lifecycle
self.addEventListener("activate", () => {
  console.log("ILoveWaves: Service worker activated");
});

self.addEventListener("install", () => {
  console.log("ILoveWaves: Service worker installed");
});