background.js

const SETTINGS_KEY = 'settings'
const GUARD_KEY_PREFIX = 'guard:tab:'

const defaultSettings = {
  seekStepSeconds: 10,
  rateStep: 0.25,
  minRate: 0.25,
  maxRate: 4,
  volumeStep: 0.05,
}

function clamp(value, min, max) {
  return Math.min(max, Math.max(min, value))
}

function getPageKey(pageUrl) {
  try {
    const u = new URL(pageUrl)
    return `${u.origin}${u.pathname}`
  } catch {
    return String(pageUrl || '')
  }
}

function marksKeyForPage(pageKey) {
  return `marks:${pageKey}`
}

async function getSettings() {
  const result = await chrome.storage.local.get(SETTINGS_KEY)
  return {...defaultSettings, ...(result[SETTINGS_KEY] || {})}
}

async function setSettings(next) {
  await chrome.storage.local.set({[SETTINGS_KEY]: next})
}

function guardKeyForTab(tabId) {
  return `${GUARD_KEY_PREFIX}${tabId}`
}

async function getGuardEnabledForTab(tabId) {
  try {
    const key = guardKeyForTab(tabId)
    const result = await chrome.storage.session.get(key)
    return Boolean(result && result[key])
  } catch {
    return false
  }
}

async function setGuardEnabledForTab(tabId, enabled) {
  try {
    const key = guardKeyForTab(tabId)
    await chrome.storage.session.set({[key]: Boolean(enabled)})
    return true
  } catch {
    return false
  }
}

async function broadcastGuardToTab(tabId, enabled) {
  try {
    await chrome.scripting.executeScript({
      target: {tabId, allFrames: true},
      func: value => {
        try {
          globalThis.postMessage(
            {
              source: 'video-plugin',
              type: 'SET_GUARD_ENABLED',
              enabled: Boolean(value),
            },
            '*',
          )
        } catch {}
      },
      args: [Boolean(enabled)],
    })
  } catch {}
  try {
    await chrome.tabs.sendMessage(tabId, {
      type: 'GUARD_SET',
      enabled: Boolean(enabled),
    })
  } catch {}
}

async function getMarks(pageKey) {
  const key = marksKeyForPage(pageKey)
  const result = await chrome.storage.local.get(key)
  const marks = result[key]
  return Array.isArray(marks) ? marks : []
}

async function setMarks(pageKey, marks) {
  const key = marksKeyForPage(pageKey)
  await chrome.storage.local.set({[key]: marks})
}

function pickBestFrameResult(results) {
  const candidates = results.map(r => r && r.result).filter(r => r && r.ok)
  if (!candidates.length) return null
  const playing = candidates.filter(c => c.status && c.status.isPlaying)
  if (playing.length)
    return playing.sort(
      (a, b) => (b.status.area || 0) - (a.status.area || 0),
    )[0]
  const hasVideo = candidates.filter(c => c.status && c.status.hasVideo)
  if (hasVideo.length)
    return hasVideo.sort(
      (a, b) => (b.status.area || 0) - (a.status.area || 0),
    )[0]
  return candidates[0]
}

async function runInAllFrames(tabId, fn, args) {
  try {
    return await chrome.scripting.executeScript({
      target: {tabId, allFrames: true},
      func: fn,
      args,
    })
  } catch {
    return []
  }
}

async function ensureContentScript(tabId) {
  try {
    await chrome.scripting.executeScript({
      target: {tabId, allFrames: true},
      files: ['contentScript.js'],
    })
    return true
  } catch {
    return false
  }
}

async function getActiveTab() {
  const [tab] = await chrome.tabs.query({active: true, currentWindow: true})
  return tab || null
}

async function getTabById(tabId) {
  try {
    return await chrome.tabs.get(tabId)
  } catch {
    return null
  }
}

async function resolveTargetTab(msgTabId, sender) {
  if (msgTabId) return await getTabById(msgTabId)
  if (sender && sender.tab && sender.tab.id)
    return await getTabById(sender.tab.id)
  return await getActiveTab()
}

async function getStatusForTab(tabId, pageUrl) {
  const pageKey = getPageKey(pageUrl)
  const marks = await getMarks(pageKey)
  let results = await runInAllFrames(
    tabId,
    payload => {
      const api = globalThis.__videoPlugin
      if (!api || typeof api.getStatus !== 'function') return {ok: false}
      return api.getStatus(payload)
    },
    [{pageUrl, marks}],
  )
  let best = pickBestFrameResult(results)
  if (!best) {
    const injected = await ensureContentScript(tabId)
    if (injected) {
      results = await runInAllFrames(
        tabId,
        payload => {
          const api = globalThis.__videoPlugin
          if (!api || typeof api.getStatus !== 'function') return {ok: false}
          return api.getStatus(payload)
        },
        [{pageUrl, marks}],
      )
      best = pickBestFrameResult(results)
    }
  }
  if (!best) return {ok: false, status: null, marks}
  return {ok: true, status: best.status || null, marks}
}

async function dispatchActionToTab(tabId, pageUrl, action, payload) {
  const pageKey = getPageKey(pageUrl)
  const marks = await getMarks(pageKey)
  const settings = await getSettings()

  let results = await runInAllFrames(
    tabId,
    actionPayload => {
      const api = globalThis.__videoPlugin
      if (!api || typeof api.performAction !== 'function') return {ok: false}
      return api.performAction(actionPayload)
    },
    [{action, payload, pageUrl, marks, settings}],
  )

  let best = pickBestFrameResult(results)
  if (!best) {
    const injected = await ensureContentScript(tabId)
    if (injected) {
      results = await runInAllFrames(
        tabId,
        actionPayload => {
          const api = globalThis.__videoPlugin
          if (!api || typeof api.performAction !== 'function')
            return {ok: false}
          return api.performAction(actionPayload)
        },
        [{action, payload, pageUrl, marks, settings}],
      )
      best = pickBestFrameResult(results)
    }
  }
  if (!best) return {ok: false, status: null, marks}

  if (
    best.effect &&
    best.effect.type === 'ADD_MARK' &&
    typeof best.effect.time === 'number'
  ) {
    const id =
      (globalThis.crypto && crypto.randomUUID && crypto.randomUUID()) ||
      `${Date.now()}-${Math.random()}`
    const next = [
      ...marks,
      {
        id,
        time: best.effect.time,
        title: best.effect.title || '',
        createdAt: Date.now(),
      },
    ].sort((a, b) => a.time - b.time)
    await setMarks(pageKey, next)
  }

  if (best.effect && best.effect.type === 'DELETE_MARK' && best.effect.id) {
    const next = marks.filter(m => m.id !== best.effect.id)
    await setMarks(pageKey, next)
  }

  const updatedMarks = await getMarks(pageKey)
  const statusResult = await getStatusForTab(tabId, pageUrl)
  return {ok: true, status: statusResult.status, marks: updatedMarks}
}

chrome.runtime.onInstalled.addListener(async () => {
  try {
    await chrome.scripting.unregisterContentScripts({ids: ['mainWorldGuard']})
  } catch {}

  try {
    await chrome.scripting.registerContentScripts([
      {
        id: 'mainWorldGuard',
        js: ['mainWorldGuard.js'],
        matches: ['http://*/*', 'https://*/*'],
        runAt: 'document_start',
        allFrames: true,
        matchAboutBlank: true,
        world: 'MAIN',
      },
    ])
  } catch {}

  const current = await getSettings()
  await setSettings(current)
})

chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
  ;(async () => {
    if (!msg || typeof msg !== 'object') return sendResponse({ok: false})

    if (msg.type === 'GET_GUARD_STATE') {
      const tab = await resolveTargetTab(msg.tabId, sender)
      if (!tab || !tab.id) return sendResponse({ok: false})
      return sendResponse({
        ok: true,
        enabled: await getGuardEnabledForTab(tab.id),
      })
    }

    if (msg.type === 'SET_GUARD_STATE') {
      const tab = await resolveTargetTab(msg.tabId, sender)
      if (!tab || !tab.id) return sendResponse({ok: false})
      const enabled = Boolean(msg.enabled)
      await setGuardEnabledForTab(tab.id, enabled)
      await broadcastGuardToTab(tab.id, enabled)
      return sendResponse({ok: true, enabled})
    }

    if (msg.type === 'GET_SETTINGS') {
      return sendResponse({
        ok: true,
        settings: await getSettings(),
      })
    }

    if (msg.type === 'GET_STATUS') {
      const tab = await resolveTargetTab(msg.tabId, sender)
      if (!tab || !tab.id || !tab.url) return sendResponse({ok: false})
      const data = await getStatusForTab(tab.id, tab.url)
      return sendResponse({
        ok: true,
        ...data,
        pageUrl: tab.url,
        settings: await getSettings(),
      })
    }

    if (msg.type === 'DO_ACTION') {
      const tab = await resolveTargetTab(msg.tabId, sender)
      if (!tab || !tab.id || !tab.url) return sendResponse({ok: false})
      const data = await dispatchActionToTab(
        tab.id,
        tab.url,
        msg.action,
        msg.payload || {},
      )
      return sendResponse({
        ok: true,
        ...data,
        pageUrl: tab.url,
        settings: await getSettings(),
      })
    }

    if (msg.type === 'SET_SETTINGS') {
      const next = {...defaultSettings, ...(msg.settings || {})}
      await setSettings(next)
      return sendResponse({ok: true, settings: next})
    }

    if (msg.type === 'DELETE_MARK') {
      const tab = await resolveTargetTab(msg.tabId, sender)
      if (!tab || !tab.id || !tab.url) return sendResponse({ok: false})
      const pageKey = getPageKey(tab.url)
      const marks = await getMarks(pageKey)
      const next = marks.filter(m => m.id !== msg.id)
      await setMarks(pageKey, next)
      const status = await getStatusForTab(tab.id, tab.url)
      return sendResponse({ok: true, marks: next, status: status.status})
    }

    return sendResponse({ok: false})
  })()
  return true
})