background.js

const XENO_CANTO_API_BASE = "https://www.xeno-canto.org/api/3/recordings";
const API_KEY = "";

const CACHE_KEY = 'species-data-cache';
const ONE_DAY = 24 * 60 * 60 * 1000;

self.importScripts('sw-indexedDB.js');
const idb = new ServiceWorkerIDB();

chrome.runtime.onInstalled.addListener(() => {
  chrome.sidePanel
    .setPanelBehavior({ openPanelOnActionClick: true })
    .catch((error) => {});
  checkAndUpdateData();
});

chrome.runtime.onStartup.addListener(() => {
  checkAndUpdateData();
});

chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
  if (request.action === 'searchRecordings') {
    handleSearchRequest(request.query)
      .then(response => {
        sendResponse({ success: true, data: response });
      })
      .catch(error => {
        sendResponse({
          success: false,
          error: error.message || 'Unknown error occurred'
        });
      });
    return true;
  }

  if (request.action === 'getCachedData') {
    getCacheData().then(data => {
      sendResponse({ success: true, data });
    }).catch(error => {
      sendResponse({ success: false, error: error.message });
    });
    return true;
  }
});

async function handleSearchRequest(query) {
  try {
    const apiUrl = `${XENO_CANTO_API_BASE}?key=${API_KEY}&query=sp:"${encodeURIComponent(query)}"`;

    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), 50000);

    const response = await fetch(apiUrl, {
      signal: controller.signal,
      headers: {
        'User-Agent': 'Chrome Extension - Xeno-Canto Player'
      }
    });

    clearTimeout(timeoutId);

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json();

    if (!data || typeof data !== 'object') {
      throw new Error('Invalid response format');
    }

    return data;
  } catch (error) {
    if (error.name === 'AbortError') {
      throw new Error('Request timeout');
    }
    throw error;
  }
}

chrome.runtime.onUpdateAvailable.addListener(() => {});

async function checkAndUpdateData() {
  try {
    const cacheData = await getCacheData();
    const now = Date.now();

    const needsUpdate = !cacheData ||
                       !cacheData.lastUpdate ||
                       (now - cacheData.lastUpdate) > ONE_DAY ||
                       !cacheData.speciesData;

    if (needsUpdate) {
      await downloadAndCacheData();
    }
  } catch (error) {
  }
}

async function getCacheData() {
  try {
    const data = await idb.get(CACHE_KEY);
    return data;
  } catch (error) {
    return null;
  }
}

async function downloadAndCacheData() {
  try {
    const response = await fetchWithTimeout("https://ebird.siansiansu.com/species.json", 30000);

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const speciesData = await response.json();

    if (!Array.isArray(speciesData)) {
      throw new Error('Invalid data format received');
    }

    const cacheData = {
      speciesData,
      lastUpdate: Date.now(),
      dataSource: 'remote',
      version: '1.0'
    };

    await idb.put(CACHE_KEY, cacheData);

  } catch (error) {
  }
}

function fetchWithTimeout(url, timeout = 15000) {
  return Promise.race([
    fetch(url),
    new Promise((_, reject) =>
      setTimeout(() => reject(new Error("Request timed out")), timeout)
    )
  ]);
}