background.js

// TrendScope Background Service Worker
// Orchestrates README fetching and prompt building

// Import prompt builder
importScripts('prompt-builder.js');

// Listen for messages from content script and popup
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
  if (message.type === 'REPOS_SCRAPED') {
    handleReposScraped(message.payload);
    sendResponse({ success: true });
  } else if (message.type === 'START_ENRICHMENT') {
    startEnrichment().then(() => sendResponse({ success: true }));
    return true; // Async response
  } else if (message.type === 'BUILD_PROMPT') {
    buildAndStorePrompt().then(() => sendResponse({ success: true }));
    return true; // Async response
  } else if (message.type === 'GET_STATUS') {
    getStatus().then(status => sendResponse(status));
    return true; // Async response
  }
  return false;
});

/**
 * Handle scraped repos from content script
 */
async function handleReposScraped(payload) {
  const { repos, period } = payload;
  // Clear old prompt and stats when new repos are scraped
  await chrome.storage.local.set({
    repos: repos,
    trendingPeriod: period,
    lastRun: new Date().toISOString(),
    state: 'scraped',
    error: null,
    prompt: null,
    promptStats: null,
    enrichmentProgress: null
  });
}

/**
 * Get settings with defaults
 */
async function getSettings() {
  const data = await chrome.storage.local.get(['settings']);
  return {
    githubToken: '',
    readmeMaxChars: 3000,
    maxRepos: 25,
    ...data.settings
  };
}

/**
 * Start enrichment process - fetch READMEs and metadata for each repo
 */
async function startEnrichment() {
  const data = await chrome.storage.local.get(['repos', 'trendingPeriod']);
  const settings = await getSettings();

  if (!data.repos || data.repos.length === 0) {
    await chrome.storage.local.set({
      state: 'error',
      error: 'No repos to enrich. Scrape the trending page first.'
    });
    return;
  }

  // Limit repos to maxRepos setting
  let repos = data.repos.slice(0, settings.maxRepos);

  await chrome.storage.local.set({
    state: 'enriching',
    enrichmentProgress: { current: 0, total: repos.length, currentRepo: '' }
  });

  // Build headers for GitHub API
  const headers = {
    'Accept': 'application/vnd.github.v3+json',
    'User-Agent': 'TrendScope-Chrome-Extension'
  };

  if (settings.githubToken) {
    headers['Authorization'] = `token ${settings.githubToken}`;
  }

  // Enrich each repo sequentially with delay
  for (let i = 0; i < repos.length; i++) {
    const repo = repos[i];

    // Update progress
    await chrome.storage.local.set({
      enrichmentProgress: {
        current: i + 1,
        total: repos.length,
        currentRepo: repo.fullName
      }
    });

    try {
      // Fetch repo metadata
      const metaResult = await fetchRepoMetadata(repo.owner, repo.name, headers);

      if (metaResult.rateLimited) {
        // Stop enrichment on rate limit
        await chrome.storage.local.set({
          repos: repos,
          state: 'error',
          error: `Rate limited by GitHub API. ${i} of ${repos.length} repos enriched. Wait an hour or add a GitHub token in settings.`
        });
        return;
      }

      if (metaResult.data) {
        repo.forks = metaResult.data.forks_count;
        repo.openIssues = metaResult.data.open_issues_count;
        repo.topics = metaResult.data.topics || [];
        repo.license = metaResult.data.license?.spdx_id || null;
        repo.createdAt = metaResult.data.created_at;
      }

      // Fetch README
      const readmeResult = await fetchReadme(repo.owner, repo.name, headers, settings.readmeMaxChars);

      if (readmeResult.rateLimited) {
        await chrome.storage.local.set({
          repos: repos,
          state: 'error',
          error: `Rate limited by GitHub API. ${i} of ${repos.length} repos enriched. Wait an hour or add a GitHub token in settings.`
        });
        return;
      }

      repo.readme = readmeResult.content;
      repo.readmeStatus = readmeResult.status;
      repo.fetchedAt = new Date().toISOString();

    } catch (err) {
      // Log but continue - don't let one repo fail the whole process
      console.error(`TrendScope: Error enriching ${repo.fullName}:`, err);
      repo.readmeStatus = 'error';
      repo.fetchedAt = new Date().toISOString();
    }

    // Update repos in storage after each one
    await chrome.storage.local.set({ repos: repos });

    // Delay between requests to respect rate limits (1 second)
    if (i < repos.length - 1) {
      await sleep(1000);
    }
  }

  // All repos enriched - build prompt
  await buildAndStorePrompt();
}

/**
 * Fetch repo metadata from GitHub API
 */
async function fetchRepoMetadata(owner, name, headers) {
  try {
    const response = await fetch(
      `https://api.github.com/repos/${owner}/${name}`,
      { headers }
    );

    if (response.status === 403) {
      const remaining = response.headers.get('X-RateLimit-Remaining');
      if (remaining === '0') {
        return { rateLimited: true, data: null };
      }
    }

    if (response.status === 404) {
      return { rateLimited: false, data: null };
    }

    if (!response.ok) {
      return { rateLimited: false, data: null };
    }

    const data = await response.json();
    return { rateLimited: false, data };

  } catch (err) {
    console.error('TrendScope: Metadata fetch error:', err);
    return { rateLimited: false, data: null };
  }
}

/**
 * Fetch README from GitHub API
 */
async function fetchReadme(owner, name, headers, maxChars) {
  try {
    const response = await fetch(
      `https://api.github.com/repos/${owner}/${name}/readme`,
      { headers }
    );

    if (response.status === 403) {
      const remaining = response.headers.get('X-RateLimit-Remaining');
      if (remaining === '0') {
        return { rateLimited: true, content: '', status: 'error' };
      }
    }

    if (response.status === 404) {
      return { rateLimited: false, content: '', status: 'unavailable' };
    }

    if (!response.ok) {
      return { rateLimited: false, content: '', status: 'error' };
    }

    const data = await response.json();

    // Decode base64 content
    let content = '';
    if (data.content && data.encoding === 'base64') {
      try {
        content = decodeBase64(data.content);
      } catch (e) {
        console.error('TrendScope: Base64 decode error:', e);
        return { rateLimited: false, content: '', status: 'error' };
      }
    }

    // Truncate if necessary
    let status = 'ok';
    if (content.length > maxChars) {
      content = content.substring(0, maxChars) + `\n\n[README truncated at ${maxChars} characters]`;
      status = 'truncated';
    }

    return { rateLimited: false, content, status };

  } catch (err) {
    console.error('TrendScope: README fetch error:', err);
    return { rateLimited: false, content: '', status: 'error' };
  }
}

/**
 * Decode base64 string to UTF-8 text
 * Handles multi-line base64 from GitHub API
 */
function decodeBase64(base64String) {
  // Remove newlines that GitHub adds
  const cleaned = base64String.replace(/\n/g, '');

  // Decode base64 to binary string
  const binaryString = atob(cleaned);

  // Convert binary string to Uint8Array
  const bytes = new Uint8Array(binaryString.length);
  for (let i = 0; i < binaryString.length; i++) {
    bytes[i] = binaryString.charCodeAt(i);
  }

  // Decode UTF-8
  const decoder = new TextDecoder('utf-8');
  return decoder.decode(bytes);
}

/**
 * Build prompt from enriched repos and store it
 */
async function buildAndStorePrompt() {
  const data = await chrome.storage.local.get(['repos', 'trendingPeriod']);
  const settings = await getSettings();

  if (!data.repos || data.repos.length === 0) {
    await chrome.storage.local.set({
      state: 'error',
      error: 'No repos available to build prompt.'
    });
    return;
  }

  // Use the prompt builder
  const result = buildPrompt(data.repos, data.trendingPeriod || 'weekly');

  // Check if prompt is too large and needs README truncation
  let finalResult = result;
  if (result.stats.estimatedTokens > 150000) {
    // Reduce README size and rebuild
    const reducedRepos = data.repos.map(repo => {
      if (repo.readme && repo.readme.length > 2000) {
        return {
          ...repo,
          readme: repo.readme.substring(0, 2000) + '\n\n[README truncated at 2000 characters due to size limits]',
          readmeStatus: 'truncated'
        };
      }
      return repo;
    });
    finalResult = buildPrompt(reducedRepos, data.trendingPeriod || 'weekly');

    // If still too large, reduce further
    if (finalResult.stats.estimatedTokens > 150000) {
      const furtherReducedRepos = reducedRepos.map(repo => {
        if (repo.readme && repo.readme.length > 1500) {
          return {
            ...repo,
            readme: repo.readme.substring(0, 1500) + '\n\n[README truncated at 1500 characters due to size limits]',
            readmeStatus: 'truncated'
          };
        }
        return repo;
      });
      finalResult = buildPrompt(furtherReducedRepos, data.trendingPeriod || 'weekly');
    }
  }

  await chrome.storage.local.set({
    prompt: finalResult.prompt,
    promptStats: finalResult.stats,
    state: 'ready'
  });
}

/**
 * Get current status for popup
 */
async function getStatus() {
  const data = await chrome.storage.local.get([
    'state',
    'repos',
    'prompt',
    'promptStats',
    'enrichmentProgress',
    'lastRun',
    'error',
    'trendingPeriod'
  ]);

  return {
    type: 'STATUS',
    payload: {
      state: data.state || 'idle',
      repoCount: data.repos?.length || 0,
      hasPrompt: !!data.prompt,
      promptStats: data.promptStats || null,
      progress: data.enrichmentProgress || null,
      lastRun: data.lastRun || null,
      error: data.error || null,
      period: data.trendingPeriod || 'weekly'
    }
  };
}

/**
 * Sleep helper
 */
function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}