content.js

let isEnabled = true;

const defaultSettings = {
  highlightEnabled: true,
  positiveColor: '#d4edda',
  negativeColor: '#f8d7da',
  neutralColor: '#e2e3e5',
  intensity: 0.5
};

chrome.runtime.sendMessage({ action: "getSettings" }, (settings) => {
  isEnabled = settings.highlightEnabled !== false;
  if (isEnabled) {
    analyzeAndHighlightPage(settings || defaultSettings);
  }
});

chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
  if (request.action === "updateHighlights") {
    isEnabled = request.settings.highlightEnabled !== false;
    if (isEnabled) {
      analyzeAndHighlightPage(request.settings);
    } else {
      removeHighlights();
    }
  }
});

function analyzeAndHighlightPage(settings) {
  removeHighlights();

  const walker = document.createTreeWalker(
    document.body,
    NodeFilter.SHOW_TEXT,
    {
      acceptNode: function (node) {
        return node.nodeValue.trim().length > 0 &&
          !isInsideIgnoredElement(node) ?
          NodeFilter.FILTER_ACCEPT :
          NodeFilter.FILTER_REJECT;
      }
    },
    false
  );

  const textNodes = [];
  while (walker.nextNode()) {
    textNodes.push(walker.currentNode);
  }

  processNodesInChunks(textNodes, settings, 0, 5); // smaller chunk to avoid rate limit
}

function isInsideIgnoredElement(node) {
  const ignoredTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'CODE', 'PRE'];
  let parent = node.parentNode;

  while (parent && parent !== document.body) {
    if (ignoredTags.includes(parent.tagName) ||
      parent.classList.contains('code') ||
      parent.classList.contains('no-highlight')) {
      return true;
    }
    parent = parent.parentNode;
  }
  return false;
}

async function analyzeSentiment(text) {
  try {
    const response = await fetch('huggingface link here', {
      method: 'POST',
      headers: {
        'Authorization': 'add proper thing here',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ inputs: text })
    });

    const result = await response.json();
    if (!Array.isArray(result) || !result[0]) return 0;

    const label = result[0][0]?.label;
    switch (label) {
      case 'LABEL_2': return 1;   // positive
      case 'LABEL_0': return -1;  // negative
      case 'LABEL_1': return 0;   // neutral
      default: return 0;
    }
  } catch (e) {
    console.error("Sentiment API error:", e);
    return 0;
  }
}

async function processNodesInChunks(nodes, settings, start, chunkSize) {
  const end = Math.min(start + chunkSize, nodes.length);

  for (let i = start; i < end; i++) {
    const node = nodes[i];
    const text = node.nodeValue.trim();

    if (text.length > 0) {
      const sentiment = await analyzeSentiment(text);
      highlightNode(node, sentiment, settings);
    }
  }

  if (end < nodes.length) {
    setTimeout(() => {
      processNodesInChunks(nodes, settings, end, chunkSize);
    }, 200); // Delay to respect API rate limits
  }
}

function highlightNode(node, score, settings) {
  const parent = node.parentNode;
  if (!parent || parent.tagName === 'SCRIPT' || parent.tagName === 'STYLE') {
    return;
  }

  let color;
  const intensity = settings.intensity || 0.5;

  if (score > 0.1) {
    color = settings.positiveColor || '#d4edda';
  } else if (score < -0.1) {
    color = settings.negativeColor || '#f8d7da';
  } else {
    color = settings.neutralColor || '#e2e3e5';
  }

  const span = document.createElement('span');
  span.className = 'sentiment-highlight';
  span.style.backgroundColor = color;
  span.style.opacity = intensity;

  parent.replaceChild(span, node);
  span.appendChild(node);
}

function removeHighlights() {
  const highlights = document.querySelectorAll('.sentiment-highlight');
  highlights.forEach(highlight => {
    const parent = highlight.parentNode;
    if (parent) {
      parent.replaceChild(highlight.firstChild, highlight);
      parent.normalize();
    }
  });
}