background.js

// Background Service Worker para TARV Stream Detector
let detectedStreams = new Map();

// Inicializar quando a extensão for instalada
chrome.runtime.onInstalled.addListener(() => {
  console.log('TARV Stream Detector installed');
});

// Monitorar requisições de rede para detectar streams de mídia
chrome.webRequest.onCompleted.addListener(
  (details) => {
    const url = details.url;

    // Verificar se a URL contém extensões de mídia que nos interessam
    if (isMediaStream(url)) {
      const streamData = {
        url: url,
        timestamp: Date.now(),
        tabId: details.tabId,
        type: getStreamType(url),
        title: `Stream detectado em ${new Date().toLocaleTimeString()}`
      };

      // Armazenar o stream detectado
      detectedStreams.set(url, streamData);

      // Salvar no storage do Chrome
      saveStreamToStorage(streamData);

      // Atualizar badge da extensão
      updateBadge(details.tabId);

      console.log('Stream detectado:', url);
    }
  },
  {
    urls: ["<all_urls>"],
    types: ["xmlhttprequest", "other", "media"]
  }
);

// Função para verificar se é um stream de mídia
function isMediaStream(url) {
  const mediaExtensions = ['.m3u8', '.mpd'];
  const lowerUrl = url.toLowerCase();

  return mediaExtensions.some(ext =>
    lowerUrl.includes(ext) ||
    lowerUrl.includes(ext + '?') ||
    lowerUrl.includes(ext + '#')
  );
}

// Função para determinar o tipo de stream
function getStreamType(url) {
  const lowerUrl = url.toLowerCase();
  if (lowerUrl.includes('.m3u8')) {
    return 'HLS';
  } else if (lowerUrl.includes('.mpd')) {
    return 'MPEG-DASH';
  }
  return 'Unknown';
}

// Salvar stream no storage
async function saveStreamToStorage(streamData) {
  try {
    const result = await chrome.storage.local.get(['detectedStreams']);
    const streams = result.detectedStreams || [];

    // Evitar duplicatas
    const exists = streams.some(stream => stream.url === streamData.url);
    if (!exists) {
      streams.push(streamData);

      // Manter apenas os últimos 50 streams
      if (streams.length > 50) {
        streams.splice(0, streams.length - 50);
      }

      await chrome.storage.local.set({ detectedStreams: streams });
    }
  } catch (error) {
    console.error('Erro ao salvar stream:', error);
  }
}

// Atualizar badge da extensão
async function updateBadge(tabId) {
  try {
    const result = await chrome.storage.local.get(['detectedStreams']);
    const streams = result.detectedStreams || [];
    const count = streams.length;

    chrome.action.setBadgeText({
      text: count > 0 ? count.toString() : '',
      tabId: tabId
    });

    chrome.action.setBadgeBackgroundColor({
      color: '#4CAF50',
      tabId: tabId
    });
  } catch (error) {
    console.error('Erro ao atualizar badge:', error);
  }
}

// Listener para mensagens do popup
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
  if (request.action === 'getStreams') {
    chrome.storage.local.get(['detectedStreams'], (result) => {
      sendResponse(result.detectedStreams || []);
    });
    return true; // Indica resposta assíncrona
  } else if (request.action === 'clearStreams') {
    chrome.storage.local.set({ detectedStreams: [] }, () => {
      sendResponse({ success: true });
    });
    return true;
  }
});

// Limpar dados antigos periodicamente (streams com mais de 24 horas)
setInterval(async () => {
  try {
    const result = await chrome.storage.local.get(['detectedStreams']);
    const streams = result.detectedStreams || [];
    const now = Date.now();
    const oneDayMs = 24 * 60 * 60 * 1000;

    const filteredStreams = streams.filter(stream =>
      (now - stream.timestamp) < oneDayMs
    );

    if (filteredStreams.length !== streams.length) {
      await chrome.storage.local.set({ detectedStreams: filteredStreams });
    }
  } catch (error) {
    console.error('Erro ao limpar streams antigos:', error);
  }
}, 60 * 60 * 1000); // Executar a cada hora