// content-script.js
function extractProductData() {
  const selectors = {
    title: [
      '[data-testid="product-title"]',
      '.product-title h1',
      'h1[itemprop="name"]',
      '#productTitle'
    ],
    price: [
      '[data-testid="product-price"]',
      '.price-current',
      '[itemprop="price"]',
      '.a-price-whole'
    ],
    originalPrice: [
      '.price-was',
      '[itemprop="priceValidFor"]',
      '.a-text-price'
    ],
    discount: [
      '.discount-percentage',
      '.savings-percentage'
    ],
    image: [
      '[data-testid="product-image"] img',
      '#landingImage',
      '[itemprop="image"]'
    ]
  };

  function queryElement(selectors) {
    for (const selector of selectors) {
      const element = document.querySelector(selector);
      if (element) return element.textContent.trim() || element.src;
    }
    return null;
  }

  return {
    url: window.location.href,
    title: queryElement(selectors.title),
    price: queryElement(selectors.price),
    originalPrice: queryElement(selectors.originalPrice),
    discount: queryElement(selectors.discount),
    image: queryElement(selectors.image),
    timestamp: Date.now()
  };
}

// Listen for messages from popup or background
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
  if (request.action === 'extractProduct') {
    const productData = extractProductData();
    sendResponse(productData);
  }
});

// background.js
const DB_NAME = 'DealFinderDB';
const DB_VERSION = 1;

function openDatabase() {
  return new Promise((resolve, reject) => {
    const request = indexedDB.open(DB_NAME, DB_VERSION);
    
    request.onerror = () => reject(request.error);
    request.onsuccess = () => resolve(request.result);
    
    request.onupgradeneeded = (event) => {
      const db = event.target.result;
      if (!db.objectStoreNames.contains('products')) {
        const store = db.createObjectStore('products', { keyPath: 'url' });
        store.createIndex('price', 'currentPrice', { unique: false });
        store.createIndex('lastChecked', 'timestamp', { unique: false });
      }
      if (!db.objectStoreNames.contains('deals')) {
        db.createObjectStore('deals', { keyPath: 'id', autoIncrement: true });
      }
    };
  });
}

async function addProduct(product) {
  const db = await openDatabase();
  return new Promise((resolve, reject) => {
    const transaction = db.transaction(['products'], 'readwrite');
    const store = transaction.objectStore('products');
    const request = store.put(product);
    request.onsuccess = () => resolve(request.result);
    request.onerror = () => reject(request.error);
  });
}

async function checkPrices() {
  const db = await openDatabase();
  return new Promise((resolve, reject) => {
    const transaction = db.transaction(['products'], 'readonly');
    const store = transaction.objectStore('products');
    const request = store.getAll();
    
    request.onsuccess = async () => {
      const products = request.result;
      for (const product of products) {
        try {
          const newPrice = await fetchCurrentPrice(product.url);
          if (newPrice !== product.currentPrice) {
            const priceDrop = product.currentPrice - newPrice;
            if (priceDrop > 0) {
              await notifyPriceDrop(product, newPrice, priceDrop);
            }
            await addProduct({ ...product, currentPrice: newPrice, timestamp: Date.now() });
          }
        } catch (error) {
          console.error(`Failed to check price for ${product.url}:`, error);
        }
      }
      resolve();
    };
    request.onerror = () => reject(request.error);
  });
}

async function fetchCurrentPrice(url) {
  // In production, you would use declarativeNetRequest for cross-origin requests
  // or a backend proxy service to fetch page content
  const response = await fetch(url, { mode: 'cors' });
  const html = await response.text();
  // Extract price using your parsing logic
  return parsePriceFromHtml(html);
}

async function notifyPriceDrop(product, newPrice, savings) {
  chrome.notifications.create({
    type: 'basic',
    iconUrl: 'icons/icon48.png',
    title: 'Price Drop Alert!',
    message: `${product.title} dropped from $${product.currentPrice} to $${newPrice}. Save $${savings}!`
  });
}

// Schedule price checks using chrome.alarms
chrome.alarms.create('priceCheck', { periodInMinutes: 60 });

chrome.alarms.onAlarm.addListener((alarm) => {
  if (alarm.name === 'priceCheck') {
    checkPrices();
  }
});

// popup.js
document.addEventListener('DOMContentLoaded', async () => {
  const trackedList = document.getElementById('tracked-products');
  const addButton = document.getElementById('add-current');
  
  // Load tracked products from storage
  const products = await chrome.storage.local.get('trackedProducts');
  renderProducts(products.trackedProducts || []);
  
  addButton.addEventListener('click', async () => {
    const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
    
    chrome.tabs.sendMessage(tab.id, { action: 'extractProduct' }, async (product) => {
      if (product && product.price) {
        const existing = await chrome.storage.local.get('trackedProducts');
        const tracked = existing.trackedProducts || [];
        tracked.push({ ...product, currentPrice: product.price });
        await chrome.storage.local.set({ trackedProducts: tracked });
        renderProducts(tracked);
      }
    });
  });
  
  function renderProducts(products) {
    trackedList.innerHTML = products.map(p => `
      <div class="product-card">
        <img src="${p.image || ''}" alt="${p.title || 'Product'}" class="product-image">
        <div class="product-info">
          <h3>${p.title || 'Unknown Product'}</h3>
          <p class="price">$${p.currentPrice}</p>
          <a href="${p.url}" target="_blank">View Deal</a>
        </div>
      </div>
    `).join('');
  }
});