content.js

/**
 * Kick AutoSend - Content Script
 * Copyright (c) 2025 Kick AutoSend
 * 
 * This script provides chat automation features for Kick.com
 * Including auto-reply, message repeater, and voice rotation
 */

// Content script ready flag
let contentScriptReady = false;

// Set content script as ready immediately
contentScriptReady = true;

// Current state cached in the page
let STATE = { 
    enabled: false,
    whitelist: [],
    blacklistedWords: [],
    customMessage: '',
    includeSubscribers: false,
    voiceRotationEnabled: false,
    voiceRotationRepeater: false,
    voiceRotationResponder: false,
    voiceMode: 'random',
    selectedVoices: ['duke', 'trump', 'spongebob'],
    customVoices: [],
    channelRestriction: '',
    responderInterval: 30, // Default responder interval
    showStatusPill: true
};

// Simple message tracking (no complex storage)
let processedMessages = new Set();
const MAX_PROCESSED_MESSAGES = 500;
let observerStarted = false;
let currentObserver = null; // Store reference to current observer
let pageLoadTime = Date.now(); // Track when page was loaded
let lastResponseTime = 0; // Track last response time for cooldown

// Rate limiting
let lastMessageTime = 0;
let messageCount = 0;
const RATE_LIMIT_WINDOW = 60000; // 1 minute
const MAX_MESSAGES_PER_WINDOW = 60;

// Available TTS voices
const VOICES = [
  'anthony', 'trump', 'spongebob', 'drphil', 'tate', 'petergriffin', 'biden', 'arnold', 
  'train', 'joerogan', 'alexjones', 'samueljackson', 'kermit', 'eddie', 'goku', 'ice', 
  'herbert', 'unc', 'icespice', 'snoop', 'rock', 'morgan', 'sketch', 'kevinhart', 
  '50cent', 'kanye', 'mcgregor', 'willsmith', 'elon', 'kamala', 'jordan', 'shapiro', 
  'djkhaled', 'jayz', 'princeharry', 'robertdowneyjr', 'billgates', 'lex', 'duke', 
  'ebz', 'ariana', 'kim', 'cardi', 'rainbow', 'swift', 'watson', 'hillary', 'thrall', 'steve', 'rfk'
];

// Voice rotation functionality
let voiceIndex = 0;

function getRandomVoice() {
  const allVoices = [...(STATE.selectedVoices || ['duke']), ...(STATE.customVoices || [])];
  return allVoices[Math.floor(Math.random() * allVoices.length)];
}

function getSequentialVoice() {
  const allVoices = [...(STATE.selectedVoices || ['duke']), ...(STATE.customVoices || [])];
  const voice = allVoices[voiceIndex % allVoices.length];
  voiceIndex++;
  return voice;
}

function getNextVoice(context = 'responder') {
  const isEnabled = context === 'repeater' ? 
    STATE.voiceRotationRepeater : 
    STATE.voiceRotationResponder;
    
  if (!isEnabled) return null;
  return STATE.voiceMode === 'random' ? getRandomVoice() : getSequentialVoice();
}

// Message processing with voice replacement
function processMessage(template, context = 'responder') {
  const isEnabled = context === 'repeater' ? 
    STATE.voiceRotationRepeater : 
    STATE.voiceRotationResponder;
    
  if (!isEnabled) return template;
  
  const voicePattern = /![a-zA-Z0-9]+/g;
  const matches = template.match(voicePattern);
  
  if (!matches || matches.length === 0) return template;
  
  const currentVoice = matches[0];
  const nextVoice = getNextVoice(context);
  
  if (nextVoice) {
    const processedMessage = template.replace(currentVoice, `!${nextVoice}`);
    return processedMessage;
  }
  
  return template;
}

// Blacklist check function
function containsBlacklistedWords(text) {
  if (!STATE.blacklistedWords || STATE.blacklistedWords.length === 0) {
    return false;
  }
  
  const lowerText = text.toLowerCase();
  return STATE.blacklistedWords.some(word => {
    if (word.trim()) {
      return lowerText.includes(word.toLowerCase());
    }
    return false;
  });
}

// Statistics tracking
function updateStats(stat, value = 1) {
  try {
    chrome.runtime.sendMessage({
      type: 'UPDATE_STATS',
      stat: stat,
      value: value
    });
  } catch (error) {
    // Silent error handling for production
  }
}

// Helper functions to find chat elements
// Kick exposes stable IDs — prefer them. Avoid broad fallbacks like
// button[type="submit"] which could match buttons injected by other
// Kick-related browser extensions.
function getChatInput() {
  return document.getElementById('chat-input') ||
         document.querySelector('[data-testid="chat-input"]');
}

function getSendButton() {
  return document.getElementById('send-message-button');
}

// Send message function
async function sendMessage(text) {
  const input = getChatInput();
  if (!input) {
    return false;
  }

  input.focus();

  // Clear content
  document.execCommand('selectAll', false, null);
  document.execCommand('delete', false, null);

  // Insert text
  const ev = new InputEvent('beforeinput', {
    inputType: 'insertText',
    data: text,
    bubbles: true,
    cancelable: true,
    composed: true,
  });
  input.dispatchEvent(ev);

  await new Promise(r => setTimeout(r, 100));

  // Safety net if text did not appear
  if (!input.textContent || input.textContent.trim() === '') {
    document.execCommand('insertText', false, text);
  }

  await new Promise(r => setTimeout(r, 50));

  const btn = getSendButton();
  if (btn) {
    btn.click();
    return true;
  }

  // Fallback to Enter key
  const kd = new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, which: 13, bubbles: true });
  const ku = new KeyboardEvent('keyup', { key: 'Enter', code: 'Enter', keyCode: 13, which: 13, bubbles: true });
  input.dispatchEvent(kd);
  input.dispatchEvent(ku);
  return true;
}

// Check if user is timed out
function isUserTimedOut() {
  const timeoutIndicator = document.querySelector('[data-testid="chat-input"]');
  if (timeoutIndicator && timeoutIndicator.getAttribute('contenteditable') === 'false') {
    const parentDiv = timeoutIndicator.closest('.relative');
    if (parentDiv) {
      const timeoutText = parentDiv.querySelector('div[class*="pointer-events-none"]');
      if (timeoutText && timeoutText.textContent.includes('timed out')) {
        return true;
      }
    }
  }
  return false;
}

// Check if user is banned
function isUserBanned() {
  const chatInput = document.querySelector('[data-testid="chat-input"]');
  if (chatInput && chatInput.getAttribute('contenteditable') === 'false') {
    const parentContainer = chatInput.closest('.flex.grow.flex-col.gap-2');
    if (parentContainer) {
      const banText = parentContainer.querySelector('div[class*="pointer-events-none"]');
      if (banText && banText.textContent.includes('banned from chat')) {
        return true;
      }
    }
  }
  return false;
}

// Badge check - look for subscriber badge images
function hasSubscriberBadge(msgEl) {
  const badgeImg = msgEl.querySelector('img[src*="channel_subscriber_badges"]');
  return !!badgeImg;
}

// Parse message with emotes
function parseMessageWithEmotes(element) {
  const clone = element.cloneNode(true);
  
  const emoteSpans = clone.querySelectorAll('span[data-emote-name]');
  emoteSpans.forEach(emoteSpan => {
    const emoteName = emoteSpan.getAttribute('data-emote-name');
    if (emoteName) {
      const textNode = document.createTextNode(emoteName);
      emoteSpan.parentNode.replaceChild(textNode, emoteSpan);
    }
  });
  
  return clone.textContent || '';
}

// Get message ID for duplicate prevention
function getMessageId(node) {
  const holder = node.closest('div[data-index]');
  if (holder && holder.getAttribute('data-index')) {
    return 'idx:' + String(holder.getAttribute('data-index'));
  }
  
  const userBtn = node.querySelector('button[title]');
  const username = userBtn ? userBtn.textContent.trim() : 'unknown';
  const contentSpan = node.querySelector('span.font-normal');
  const text = contentSpan ? (contentSpan.textContent || '').trim() : '';
  
  // Create a unique ID based on content and username
  const content = `${username}:${text}`;
  const hash = content.split('').reduce((a, b) => {
    a = ((a << 5) - a) + b.charCodeAt(0);
    return a & a;
  }, 0);
  
  return `msg:${username}:${Math.abs(hash)}`;
}

// Check if message is truly new (sent after observer started)
function isNewMessage(node) {
  // Prefer explicit timestamps when available
  const messageTime = node.getAttribute('data-timestamp') ||
                     node.getAttribute('data-time') ||
                     node.querySelector('[data-time]')?.getAttribute('data-time');

  if (messageTime) {
    const messageTimestamp = parseInt(messageTime);
    if (!isNaN(messageTimestamp)) {
      return messageTimestamp > pageLoadTime;
    }
  }

  // Otherwise: the node is new if it wasn't pre-seeded during startObserver()
  // (the observer only fires for newly-added DOM nodes after it starts)
  return true;
}

// Check cooldown
function checkCooldown() {
  const now = Date.now();
  const cooldownMs = (STATE.responderInterval || 30) * 1000; // Convert seconds to milliseconds
  
  if (now - lastResponseTime < cooldownMs) {
    return false;
  }
  
  return true;
}

// Get current channel name from the page
function getCurrentChannel() {
  const el = document.getElementById('channel-username');
  const text = el?.textContent?.trim();
  if (text) return text.toLowerCase();

  // Fallback: extract from URL
  const match = window.location.href.match(/kick\.com\/([^\/\?]+)/);
  return match ? match[1].toLowerCase() : null;
}

// Check if current channel is allowed
function isChannelAllowed() {
  if (!STATE.channelRestriction || STATE.channelRestriction.trim() === '') {
    return true; // No restriction set
  }
  
  const currentChannel = getCurrentChannel();
  if (!currentChannel) {
    return true; // Allow if we can't determine channel
  }
  
  const restrictedChannel = STATE.channelRestriction.toLowerCase().trim();
  return currentChannel === restrictedChannel;
}

// Main message processing function
function handleMessageNode(node) {
  // 1. Extension enabled check
  if (!STATE.enabled || !observerStarted) {
    return;
  }

  // 2. Channel restriction check
  if (!isChannelAllowed()) {
    return;
  }

  // 3. Valid HTML element check
  if (!(node instanceof HTMLElement)) {
    return;
  }

  // 4. Find message wrapper
  const wrapper = node.matches('.group.relative') ? node : node.querySelector('.group.relative');
  if (!wrapper) {
    return;
  }

  // 5. Parse username
  const userBtn = wrapper.querySelector('button[title]');
  const username = userBtn ? userBtn.textContent.trim() : null;
  if (!username) {
    return;
  }

  // 6. Whitelist check
  const isWhitelisted = STATE.whitelist.includes(username.toLowerCase());
  if (!isWhitelisted) {
    return;
  }

  // 7. Check if already processed
  const id = getMessageId(node);
  if (processedMessages.has(id)) {
    return;
  }

  // 8. Check if message is truly new (not from page load)
  if (!isNewMessage(node)) {
    return;
  }

  // 9. Check cooldown
  if (!checkCooldown()) {
    return;
  }

  // 10. Parse message text
  let text = '';
  const contentSpan = wrapper.querySelector('span.font-normal');
  if (contentSpan) {
    text = parseMessageWithEmotes(contentSpan);
  } else {
    text = parseMessageWithEmotes(wrapper);
  }
  text = text.trim();

  // 11. Message starts with ! check
  if (!text.startsWith('!')) {
    return;
  }

  // 12. Blacklist check
  if (containsBlacklistedWords(text)) {
    return;
  }

  // 13. Subscriber badge check
  if (!STATE.includeSubscribers && hasSubscriberBadge(wrapper)) {
    return;
  }

  // 14. Additional safety check - prevent rapid processing
  if (processedMessages.has(id)) {
    return;
  }

  // Check for timeout/ban status
  if (isUserTimedOut()) {
    return;
  }
  
  if (isUserBanned()) {
    return;
  }

  // Rate limiting check
  const now = Date.now();
  if (now - lastMessageTime > RATE_LIMIT_WINDOW) {
    messageCount = 0;
    lastMessageTime = now;
  }
  
  if (messageCount >= MAX_MESSAGES_PER_WINDOW) {
    return;
  }
  
  messageCount++;

  // All conditions met! Mark as processed immediately
  processedMessages.add(id);
  if (processedMessages.size > MAX_PROCESSED_MESSAGES) {
    const iterator = processedMessages.values();
    for (let i = 0; i < processedMessages.size - MAX_PROCESSED_MESSAGES; i++) {
      processedMessages.delete(iterator.next().value);
    }
  }
  updateStats('totalProcessed');
  
  // Update last response time
  lastResponseTime = Date.now();
  
  // Determine what message to send
  let messageToSend = text; // Default: echo original message
  
  if (STATE.customMessage && STATE.customMessage.trim()) {
    messageToSend = STATE.customMessage;
  }
  
  // Process message for voice rotation
  messageToSend = processMessage(messageToSend, 'responder');
  
  const delay = 200 + Math.floor(Math.random() * 400);
  
  setTimeout(() => { 
    sendMessage(messageToSend).then(success => {
      if (success) {
        updateStats('totalReplies');
        updateStats('successCount');
      }
    });
  }, delay);
}

// Start observer
function startObserver() {
  if (observerStarted) {
    return;
  }

  // Prefer the chatroom-messages container — drastically reduces mutation
  // noise vs watching the whole document.body. Retry if not yet mounted.
  const root = document.getElementById('chatroom-messages') || document.body;
  if (!root) {
    setTimeout(() => { if (STATE.enabled && !observerStarted) startObserver(); }, 500);
    return;
  }

  // Pre-seed processedMessages with all currently-visible messages so we
  // don't respond to backlog on page load.
  root.querySelectorAll('div[data-index]').forEach(el => {
    try { processedMessages.add(getMessageId(el)); } catch (e) {}
  });
  pageLoadTime = Date.now();

  const obs = new MutationObserver((mutations) => {
    for (const m of mutations) {
      for (const n of m.addedNodes) {
        if (!(n instanceof HTMLElement)) continue;

        // Add a small delay to ensure DOM is fully updated
        setTimeout(() => {
          // Double check extension is still enabled
          if (!STATE.enabled || !observerStarted) return;

          // Direct message nodes often carry data-index
          if (n.hasAttribute && n.hasAttribute('data-index')) handleMessageNode(n);

          // Scan children that look like messages
          n.querySelectorAll('div[data-index]').forEach(el => handleMessageNode(el));

          // Fallback selector
          if (n.querySelector && n.querySelector('button[title]') && n.querySelector('span.font-normal')) {
            handleMessageNode(n);
          }
        }, 50); // 50ms delay
      }
    }
  });

  obs.observe(root, { childList: true, subtree: true });
  observerStarted = true;
  currentObserver = obs;
}

// Stop observer
function stopObserver() {
  if (currentObserver) {
    currentObserver.disconnect();
    currentObserver = null;
  }
  observerStarted = false;
  processedMessages.clear();
}

// Listen for state updates from background or popup
chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
  // Handle ping requests to test connection
  if (msg && msg.type === "PING") {
    sendResponse({ 
      status: 'ready', 
      timestamp: Date.now(),
      contentScriptReady: true,
      enabled: STATE.enabled,
      whitelist: STATE.whitelist
    });
    return true;
  }
  
  // Handle master state changes
  if (msg && msg.type === "MASTER_STATE_CHANGE") {
    if (!msg.enabled) {
      stopObserver();
    } else {
      startObserver();
    }
    sendResponse({status: 'master_state_updated'});
    return true;
  }
  
  if (msg && msg.type === "STATE" && msg.payload) {
    STATE = {
      ...STATE,
      ...msg.payload,
      enabled: msg.payload.enabled !== undefined ? msg.payload.enabled : STATE.enabled,
      whitelist: (msg.payload.whitelist || []).map(s => String(s).toLowerCase().slice(0, 50)),
      blacklistedWords: (msg.payload.blacklistedWords || []).map(s => String(s).toLowerCase().slice(0, 50)),
      channelRestriction: String(msg.payload.channelRestriction || '').slice(0, 100),
      responderInterval: parseInt(msg.payload.responderInterval) || STATE.responderInterval || 30,
    };
    
    // Start/stop observer based on enabled state
    if (STATE.enabled && !observerStarted) {
      startObserver();
    } else if (!STATE.enabled && observerStarted) {
      stopObserver();
    }
  }
  
  if (msg && msg.type === "AUTOSEND_STATUS") {
    if (msg.active === false) {
      clearStatusPill(msg.mode);
    }
    return true;
  }

  if (msg && msg.type === "SEND_REPEATER_MESSAGE") {
    // Track for status pill — next send scheduled roughly intervalMs from now
    if (msg.mode && msg.intervalMs) {
      setStatusPill(msg.mode, Date.now() + msg.intervalMs);
    }
    // Check channel restriction
    if (!isChannelAllowed()) {
      if (sendResponse) {
        sendResponse({ success: false, error: 'Channel restriction: not allowed on this channel' });
      }
      return true;
    }
    
    let processedMessage = processMessage(msg.message, 'repeater');
    
    sendMessage(processedMessage).then(success => {
      if (success) {
        updateStats('totalRepeater');
        updateStats('successCount');
        
        if (sendResponse) {
          sendResponse({ success: true, message: 'Message sent successfully' });
        }
      } else {
        if (sendResponse) {
          sendResponse({ success: false, error: 'Message send failed' });
        }
      }
    }).catch(error => {
      if (sendResponse) {
        sendResponse({ success: false, error: error.toString() });
      }
    });
    return true;
  }
});

// Load initial state and start observer
chrome.storage.local.get(["enabled", "whitelist", "blacklistedWords", "customMessage", "includeSubscribers", "voiceRotationRepeater", "voiceRotationResponder", "voiceMode", "selectedVoices", "customVoices", "channelRestriction", "responderInterval"], (cfg) => {
  try {
    STATE.enabled = Boolean(cfg.enabled);
    STATE.whitelist = Array.isArray(cfg.whitelist)
      ? cfg.whitelist.map(s => String(s).toLowerCase())
      : [];
    STATE.blacklistedWords = Array.isArray(cfg.blacklistedWords)
      ? cfg.blacklistedWords.map(s => String(s).toLowerCase())
      : [];
    STATE.customMessage = String(cfg.customMessage || '');
    STATE.includeSubscribers = Boolean(cfg.includeSubscribers);
    STATE.voiceRotationRepeater = Boolean(cfg.voiceRotationRepeater);
    STATE.voiceRotationResponder = Boolean(cfg.voiceRotationResponder);
    STATE.voiceMode = String(cfg.voiceMode || 'random');
    STATE.selectedVoices = Array.isArray(cfg.selectedVoices) ? cfg.selectedVoices : ['duke', 'trump', 'spongebob'];
    STATE.customVoices = Array.isArray(cfg.customVoices) ? cfg.customVoices : [];
    STATE.channelRestriction = String(cfg.channelRestriction || '');
    STATE.responderInterval = parseInt(cfg.responderInterval) || 30;
    
    // Start observer if enabled
    if (STATE.enabled) {
      startObserver();
    }
    
  } catch (error) {
    STATE.enabled = false;
    STATE.whitelist = [];
    STATE.blacklistedWords = [];
  }
});

// =========================
// Status pill above chat input
// =========================
const PILL_ID = 'kickautosend-status-pill';
let pillState = { mode: null, nextSendAt: 0 };
let pillTicker = null;

function ensurePillElement() {
  let pill = document.getElementById(PILL_ID);
  if (pill) return pill;

  const input = getChatInput();
  if (!input) return null;

  // Anchor container — float the pill above it without affecting layout
  const anchor = input.closest('.relative') || input.parentElement;
  if (!anchor) return null;

  // Ensure anchor is a positioning context
  const computed = getComputedStyle(anchor);
  if (computed.position === 'static') anchor.style.position = 'relative';

  pill = document.createElement('div');
  pill.id = PILL_ID;
  pill.setAttribute('contenteditable', 'false');
  pill.style.cssText = [
    'position:absolute', 'top:50%', 'right:34px', 'transform:translateY(-50%)', 'z-index:9999',
    'display:inline-flex', 'align-items:center', 'gap:4px',
    'padding:1px 6px 1px 8px',
    'font:500 10px/1.4 system-ui,-apple-system,sans-serif',
    'color:#0a0a0a', 'background:#53fc18', 'border-radius:4px',
    'user-select:none', 'pointer-events:auto',
    'box-shadow:0 1px 2px rgba(0,0,0,.3)'
  ].join(';');

  const label = document.createElement('span');
  label.className = 'kas-pill-label';
  label.textContent = '';
  pill.appendChild(label);

  const stopBtn = document.createElement('button');
  stopBtn.type = 'button';
  stopBtn.textContent = '×';
  stopBtn.title = 'Stop';
  stopBtn.style.cssText = [
    'all:unset', 'cursor:pointer', 'padding:0 2px',
    'font:700 12px/1 system-ui', 'color:#0a0a0a'
  ].join(';');
  const stopHandler = (e) => {
    e.preventDefault();
    e.stopPropagation();
    const type = pillState.mode === 'commaflage' ? 'STOP_COMMAFLAGE' : 'STOP_REPEATER';
    chrome.runtime.sendMessage({ type }, () => { void chrome.runtime.lastError; });
    clearStatusPill(pillState.mode);
  };
  stopBtn.addEventListener('mousedown', stopHandler);
  stopBtn.addEventListener('click', stopHandler);
  pill.appendChild(stopBtn);

  anchor.appendChild(pill);
  return pill;
}

function setStatusPill(mode, nextSendAt) {
  if (STATE.showStatusPill === false) { clearStatusPill(); return; }
  pillState.mode = mode;
  pillState.nextSendAt = nextSendAt;
  renderStatusPill();
  if (!pillTicker) {
    pillTicker = setInterval(renderStatusPill, 500);
  }
}

function clearStatusPill(mode) {
  if (mode && pillState.mode && mode !== pillState.mode) return; // different mode stopping — ignore
  pillState = { mode: null, nextSendAt: 0 };
  if (pillTicker) {
    clearInterval(pillTicker);
    pillTicker = null;
  }
  const pill = document.getElementById(PILL_ID);
  if (pill) pill.remove();
}

function renderStatusPill() {
  if (!pillState.mode) return;
  if (STATE.showStatusPill === false) { clearStatusPill(); return; }
  const pill = ensurePillElement();
  if (!pill) return;
  const label = pill.querySelector('.kas-pill-label');
  if (!label) return;

  const remaining = Math.max(0, Math.round((pillState.nextSendAt - Date.now()) / 1000));
  const tag = pillState.mode === 'commaflage' ? 'CF' : 'REP';
  label.textContent = remaining > 0 ? `${tag} ${remaining}s` : `${tag} …`;

  // Auto-hide if we've gone 10s past expected send (SW probably died)
  if (Date.now() - pillState.nextSendAt > 10_000) {
    clearStatusPill(pillState.mode);
  }
}

// =========================
// Toolbar button (next to Kick's Chat/gear buttons)
// =========================
const TOOLBAR_BTN_ID = 'kickautosend-toolbar-btn';

function ensureToolbarButton() {
  if (document.getElementById(TOOLBAR_BTN_ID)) return;
  const sendBtn = document.getElementById('send-message-button');
  if (!sendBtn || !sendBtn.parentElement) return;

  const btn = document.createElement('button');
  btn.id = TOOLBAR_BTN_ID;
  btn.type = 'button';
  btn.title = 'Open KickAutoSend';
  // Match Kick's icon-button sizing (size-8 = 32px)
  btn.style.cssText = [
    'all:unset', 'cursor:pointer', 'display:inline-flex',
    'align-items:center', 'justify-content:center',
    'width:32px', 'height:32px', 'border-radius:4px',
    'color:#53fc18', 'transition:background .15s'
  ].join(';');
  btn.addEventListener('mouseenter', () => btn.style.background = 'rgba(255,255,255,.08)');
  btn.addEventListener('mouseleave', () => btn.style.background = 'transparent');
  const img = document.createElement('img');
  img.src = chrome.runtime.getURL('assets/logo.png');
  img.alt = 'KickAutoSend';
  img.style.cssText = 'width:20px;height:20px;object-fit:contain;pointer-events:none';
  btn.appendChild(img);

  btn.addEventListener('click', (e) => {
    e.preventDefault();
    e.stopPropagation();
    chrome.runtime.sendMessage({ type: 'OPEN_POPUP' }, () => { void chrome.runtime.lastError; });
  });

  sendBtn.parentElement.insertBefore(btn, sendBtn);
}

// Keep the toolbar button alive across Kick's client-side route changes
const toolbarObserver = new MutationObserver(() => ensureToolbarButton());
toolbarObserver.observe(document.body, { childList: true, subtree: true });
ensureToolbarButton();