// Function to extract comments from the page
function extractComments() {
  const comments = [];
  let platform = detectPlatform();
  
  // Different extraction strategies based on the platform
  if (platform === 'facebook') {
    extractFacebookComments(comments);
  } else if (platform === 'youtube') {
    extractYoutubeComments(comments);
  } else if (platform === 'twitter') {
    extractTwitterComments(comments);
  } else if (platform === 'instagram') {
    extractInstagramComments(comments);
  } else if (platform === 'linkedin') {
    extractLinkedinComments(comments);
  } else {
    // Generic extraction for other platforms
    extractGenericComments(comments);
  }
  
  return comments;
}

// Detect the current platform
function detectPlatform() {
  const url = window.location.hostname;
  
  if (url.includes('facebook.com')) return 'facebook';
  if (url.includes('youtube.com')) return 'youtube';
  if (url.includes('twitter.com') || url.includes('x.com')) return 'twitter';
  if (url.includes('instagram.com')) return 'instagram';
  if (url.includes('linkedin.com')) return 'linkedin';
  
  return 'other';
}

// Platform-specific extraction functions
function extractFacebookComments(comments) {
  // Facebook comment selectors
  const commentElements = document.querySelectorAll('[aria-label="Comment"]');
  
  commentElements.forEach((element, index) => {
    try {
      const authorElement = element.querySelector('a');
      const contentElement = element.querySelector('[data-ad-comet-preview="message"]');
      const timestampElement = element.querySelector('a[href*="comment_id"]');
      const likesElement = element.querySelector('[aria-label*="reactions"]');
      
      if (contentElement) {
        comments.push({
          id: `fb-comment-${index}`,
          author: authorElement ? authorElement.textContent : 'Facebook User',
          content: contentElement.textContent,
          timestamp: timestampElement ? timestampElement.textContent : 'Recently',
          likes: likesElement ? parseInt(likesElement.textContent) || 0 : 0,
          platform: 'facebook'
        });
      }
    } catch (error) {
      console.error('Error extracting Facebook comment:', error);
    }
  });
}

function extractYoutubeComments(comments) {
  // YouTube comment selectors
  const commentElements = document.querySelectorAll('ytd-comment-thread-renderer');
  
  commentElements.forEach((element, index) => {
    try {
      const authorElement = element.querySelector('#author-text');
      const contentElement = element.querySelector('#content-text');
      const timestampElement = element.querySelector('.published-time-text');
      const likesElement = element.querySelector('#vote-count-middle');
      
      if (contentElement) {
        comments.push({
          id: `yt-comment-${index}`,
          author: authorElement ? authorElement.textContent.trim() : 'YouTube User',
          content: contentElement.textContent.trim(),
          timestamp: timestampElement ? timestampElement.textContent.trim() : 'Recently',
          likes: likesElement ? parseInt(likesElement.textContent) || 0 : 0,
          platform: 'youtube'
        });
      }
    } catch (error) {
      console.error('Error extracting YouTube comment:', error);
    }
  });
}

function extractTwitterComments(comments) {
  // Twitter/X comment selectors
  const commentElements = document.querySelectorAll('[data-testid="tweet"]');
  
  commentElements.forEach((element, index) => {
    try {
      const authorElement = element.querySelector('[data-testid="User-Name"]');
      const contentElement = element.querySelector('[data-testid="tweetText"]');
      const timestampElement = element.querySelector('time');
      const likesElement = element.querySelector('[data-testid="like"]');
      
      if (contentElement) {
        comments.push({
          id: `twitter-comment-${index}`,
          author: authorElement ? authorElement.textContent.split('·')[0].trim() : 'Twitter User',
          content: contentElement.textContent.trim(),
          timestamp: timestampElement ? timestampElement.getAttribute('datetime') : 'Recently',
          likes: likesElement ? parseInt(likesElement.textContent) || 0 : 0,
          platform: 'twitter'
        });
      }
    } catch (error) {
      console.error('Error extracting Twitter comment:', error);
    }
  });
}

function extractInstagramComments(comments) {
  // Instagram comment selectors
  const commentElements = document.querySelectorAll('ul > li > div > div > div:nth-child(2)');
  
  commentElements.forEach((element, index) => {
    try {
      const authorElement = element.querySelector('h3');
      const contentElement = element.querySelector('span');
      
      if (contentElement && authorElement) {
        comments.push({
          id: `ig-comment-${index}`,
          author: authorElement.textContent.trim(),
          content: contentElement.textContent.trim(),
          timestamp: 'Recently', // Instagram doesn't easily show timestamps
          likes: 0, // Instagram doesn't easily show like counts
          platform: 'instagram'
        });
      }
    } catch (error) {
      console.error('Error extracting Instagram comment:', error);
    }
  });
}

function extractLinkedinComments(comments) {
  // LinkedIn comment selectors
  const commentElements = document.querySelectorAll('.comments-comment-item');
  
  commentElements.forEach((element, index) => {
    try {
      const authorElement = element.querySelector('.comments-post-meta__name-text');
      const contentElement = element.querySelector('.comments-comment-item__main-content');
      const timestampElement = element.querySelector('.comments-comment-item__timestamp');
      
      if (contentElement) {
        comments.push({
          id: `linkedin-comment-${index}`,
          author: authorElement ? authorElement.textContent.trim() : 'LinkedIn User',
          content: contentElement.textContent.trim(),
          timestamp: timestampElement ? timestampElement.textContent.trim() : 'Recently',
          likes: 0, // LinkedIn doesn't easily show like counts
          platform: 'linkedin'
        });
      }
    } catch (error) {
      console.error('Error extracting LinkedIn comment:', error);
    }
  });
}

function extractGenericComments(comments) {
  // Generic comment selectors that might work across different platforms
  const possibleCommentSelectors = [
    '.comment',
    '[class*="comment"]',
    '[id*="comment"]',
    '.review',
    '[class*="review"]',
    '[class*="post"]',
    '[class*="message"]'
  ];
  
  for (const selector of possibleCommentSelectors) {
    const elements = document.querySelectorAll(selector);
    
    if (elements.length > 0) {
      elements.forEach((element, index) => {
        // Try to find text content that looks like a comment
        const textContent = element.textContent.trim();
        
        if (textContent.length > 10 && textContent.length < 1000) {
          comments.push({
            id: `generic-comment-${index}`,
            author: 'User',
            content: textContent,
            timestamp: 'Recently',
            likes: 0,
            platform: 'other'
          });
        }
      });
      
      // If we found comments with this selector, no need to try others
      if (comments.length > 0) break;
    }
  }
}

// Listen for messages from the sidebar
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
  if (message.type === 'GET_COMMENTS') {
    const comments = extractComments();
    
    // Limit the number of comments based on settings
    chrome.storage.sync.get(['maxComments'], (result) => {
      const maxComments = result.maxComments || 50;
      const limitedComments = comments.slice(0, maxComments);
      
      // Send the comments back to the sidebar
      chrome.runtime.sendMessage({
        type: 'COMMENTS_CAPTURED',
        comments: limitedComments
      });
    });
  }
  
  return true;
});

// Initial extraction when the content script loads
setTimeout(() => {
  const comments = extractComments();
  
  chrome.storage.sync.get(['maxComments'], (result) => {
    const maxComments = result.maxComments || 50;
    const limitedComments = comments.slice(0, maxComments);
    
    chrome.runtime.sendMessage({
      type: 'COMMENTS_CAPTURED',
      comments: limitedComments
    });
  });
}, 1000);