const BASE = new URL('./', self.location.href).pathname;
importScripts(BASE + 'static/background-issue-sync.js');
const CACHE = 'stackchain-dashboard-shell-v97';
const OFFLINE_LEASE_URL = new URL(BASE + '__offline-session-lease', self.location.origin).href;
const OUTAGE_STATUSES = new Set([500, 502, 503, 504]);
const NAVIGATION_TIMEOUT_MS = self.__STACKCHAIN_NAVIGATION_TIMEOUT_MS || 4000;
const PUSH_ACTION_TIMEOUT_MS = self.__STACKCHAIN_PUSH_ACTION_TIMEOUT_MS || 8000;
const SHELL = [
  BASE,
  BASE + 'manifest.webmanifest',
  BASE + 'static/dashboard.css',
  BASE + 'static/dashboard.js',
  BASE + 'static/icons/stackchain-192.png',
  BASE + 'static/icons/stackchain-512.png',
  BASE + 'static/session.js',
  BASE + 'static/feature-loader.js',
  BASE + 'static/security-center.js',
  BASE + 'static/markdown.js',
  BASE + 'static/commands.js',
  BASE + 'static/search-preview.js',
  BASE + 'static/widgets.js',
  BASE + 'static/drafts.js',
  BASE + 'static/unfiled-captures.js',
  BASE + 'static/draft-filing-session.js',
  BASE + 'static/draft-capacity-dialog.js',
  BASE + 'static/outbox-coordinator.js',
  BASE + 'static/issue-outbox.js',
  BASE + 'static/authored-outbox.js',
  BASE + 'static/offline-issue-close.js',
  BASE + 'static/offline-issue-blocker.js',
  BASE + 'static/notification-read-outbox.js',
  BASE + 'static/offline-work.js',
  BASE + 'static/offline-today.js',
  BASE + 'static/my-work.js',
  BASE + 'static/notification-undo.js',
  BASE + 'static/card-planning.js',
  BASE + 'static/work-selection.js',
  BASE + 'static/today-work.js',
  BASE + 'static/today-timer.js',
  BASE + 'static/today-recap.js',
  BASE + 'static/today-completion.js',
  BASE + 'static/today-readiness.js',
  BASE + 'static/comment-next.js',
  BASE + 'static/update-reply-read-next.js',
  BASE + 'static/plan-today.js',
  BASE + 'static/plan-today-readiness.js',
  BASE + 'static/plan-today-preview.js',
  BASE + 'static/today-sync.js',
  BASE + 'static/today-rollover.js',
  BASE + 'static/update-ownership.js',
  BASE + 'static/update-follow-up.js',
  BASE + 'static/later-work.js',
  BASE + 'static/later-sync.js',
  BASE + 'static/later-and-start.js',
  BASE + 'static/detail-defer.js',
  BASE + 'static/later-picker.js',
  BASE + 'static/pick-work.js',
  BASE + 'static/conversation.js',
  BASE + 'static/comment-actions.js',
  BASE + 'static/issue-attachment.js',
  BASE + 'static/issue-sheet.js',
  BASE + 'static/create-issue-sheet.js',
  BASE + 'static/create-and-start.js',
  BASE + 'static/assign-and-start.js',
  BASE + 'static/queue-today.js',
  BASE + 'static/pull-sheet.js',
  BASE + 'static/review-sheet.js',
  BASE + 'static/work-route.js',
  BASE + 'static/task-overlay-history.js',
  BASE + 'static/context-poller.js',
  BASE + 'static/mobile-task-dock.js',
  BASE + 'static/mobile-work-entry.js',
  BASE + 'static/mobile-queue-launcher.js',
  BASE + 'static/mobile-launch.js',
  BASE + 'static/install-app.js',
  BASE + 'static/mobile-device-setup.js',
  BASE + 'static/mobile-search-viewport.js',
  BASE + 'static/mobile-composer-viewport.js',
  BASE + 'static/mention-composer.js',
  BASE + 'static/push-notifications.js',
  BASE + 'static/background-issue-sync.js',
];
const OPTIONAL_FEATURES = [
];

async function fetchNavigation(request) {
  const controller = new AbortController();
  let timeout;
  const deadline = new Promise((resolve, reject) => {
    timeout = setTimeout(() => {
      controller.abort();
      reject(new Error('Dashboard navigation timed out.'));
    }, NAVIGATION_TIMEOUT_MS);
  });
  try {
    return await Promise.race([
      fetch(request, { signal: controller.signal }),
      deadline,
    ]);
  } finally {
    clearTimeout(timeout);
  }
}

async function sessionCsrf(signal) {
  const response = await fetch(new URL(BASE + 'api/v1/session', self.location.origin), {
    headers: { Accept: 'application/json' },
    signal,
  });
  if (!response.ok) return '';
  const payload = await response.json().catch(() => ({}));
  return typeof payload.csrf_token === 'string' ? payload.csrf_token : '';
}

let batchedCsrf = null;
let batchedCsrfController = null;
async function withSessionCsrf(work) {
  batchedCsrfController = new AbortController();
  batchedCsrf = sessionCsrf(batchedCsrfController.signal);
  try {
    return await work();
  } finally {
    batchedCsrfController.abort();
    batchedCsrf = null;
    batchedCsrfController = null;
  }
}

async function deletePrivateDatabase(name) {
  if (!indexedDB) return;
  await new Promise((resolve, reject) => {
    let request;
    try { request = indexedDB.deleteDatabase(name); }
    catch (error) { reject(error); return; }
    request.onsuccess = () => resolve();
    request.onerror = () => reject(request.error || new Error('IndexedDB deletion failed.'));
    request.onblocked = () => reject(new Error('IndexedDB deletion was blocked.'));
  });
}

async function purgeRevokedSessionData() {
  await issueSync.purge();
  await deletePrivateDatabase('stackchain-unfiled-captures-v1');
  const keys = await caches.keys();
  await Promise.all(
    keys.filter(key => key.startsWith('stackchain-dashboard-')).map(key => caches.delete(key))
  );
  const clients = await self.clients.matchAll({ type: 'window', includeUncontrolled: true });
  clients.forEach(client => client.postMessage?.({ type: 'stackchain-session-revoked' }));
}

async function notifyIdleSession() {
  const clients = await self.clients.matchAll({ type: 'window', includeUncontrolled: true });
  clients.forEach(client => client.postMessage?.({ type: 'stackchain-session-idle' }));
}

async function storeOfflineLease(expiresAt, idleExpiresAt) {
  if (
    !Number.isInteger(expiresAt) || expiresAt <= 0
    || !Number.isInteger(idleExpiresAt) || idleExpiresAt <= 0
  ) return;
  const cache = await caches.open(CACHE);
  await cache.put(OFFLINE_LEASE_URL, new Response(
    JSON.stringify({ expires_at: expiresAt, idle_expires_at: idleExpiresAt }),
    { headers: { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' } },
  ));
}

async function offlineLeaseState(cache) {
  const response = await cache.match(OFFLINE_LEASE_URL);
  const payload = await response?.json?.().catch(() => ({})) || {};
  const current = Math.floor(Date.now() / 1000);
  if (!Number.isInteger(payload.expires_at) || payload.expires_at <= current) return 'expired';
  if (!Number.isInteger(payload.idle_expires_at) || payload.idle_expires_at <= current) return 'idle';
  return 'valid';
}

async function expiredOfflineResponse() {
  await issueSync.purge();
  await deletePrivateDatabase('stackchain-unfiled-captures-v1');
  const keys = await caches.keys();
  await Promise.all(
    keys.filter(key => key.startsWith('stackchain-dashboard-')).map(key => caches.delete(key))
  );
  const clients = await self.clients.matchAll({ type: 'window', includeUncontrolled: true });
  clients.forEach(client => client.postMessage?.({ type: 'stackchain-session-expired' }));
  return new Response(
    'Your Stackchain session expired. Reconnect and sign in.',
    { status: 401, headers: { 'Content-Type': 'text/plain; charset=utf-8', 'Cache-Control': 'no-store' } },
  );
}

async function idleOfflineResponse() {
  await notifyIdleSession();
  return new Response(
    'Your Stackchain session is locked. Reconnect and sign in.',
    { status: 401, headers: { 'Content-Type': 'text/plain; charset=utf-8', 'Cache-Control': 'no-store' } },
  );
}

async function cachedShellWithValidLease(cache) {
  const state = await offlineLeaseState(cache);
  if (state === 'expired') return expiredOfflineResponse();
  if (state === 'idle') return idleOfflineResponse();
  return cache.match(BASE);
}

async function fetchJson(url, options = {}) {
  const requestOptions = { ...options };
  const method = String(options.method || 'GET').toUpperCase();
  if (!['GET', 'HEAD', 'OPTIONS'].includes(method)) {
    const headers = new Headers(options.headers || {});
    const cancelBatchedCsrf = () => batchedCsrfController?.abort();
    if (batchedCsrf && options.signal) {
      if (options.signal.aborted) cancelBatchedCsrf();
      else options.signal.addEventListener('abort', cancelBatchedCsrf, { once: true });
    }
    let csrf;
    try {
      csrf = await (batchedCsrf || sessionCsrf(options.signal));
    } finally {
      options.signal?.removeEventListener('abort', cancelBatchedCsrf);
    }
    if (options.signal?.aborted) throw new Error('Background request aborted.');
    if (csrf) headers.set('X-CSRF-Token', csrf);
    requestOptions.headers = headers;
  }
  const response = await fetch(new URL(url, self.location.origin), requestOptions);
  const payload = await response.json().catch(() => ({}));
  if (!response.ok) {
    const code = payload.code || payload.detail?.code;
    if (response.status === 401 && code === 'session_revoked') {
      await purgeRevokedSessionData();
    }
    if (response.status === 401 && code === 'session_idle') {
      await notifyIdleSession();
    }
    const error = new Error(payload.error || payload.detail?.message || payload.detail || 'Background issue delivery failed.');
    error.status = response.status;
    error.code = code;
    throw error;
  }
  return payload;
}

const issueSync = self.__issueSync || createBackgroundIssueSync({
  store: createIssueSyncStore(), fetchJson, base: BASE, batch: withSessionCsrf,
});

async function flushAndNotify() {
  const result = await issueSync.flush();
  if (!result?.login || !result.receipts?.length ||
      !await issueSync.getReceiptPreference?.(result.login)) return;
  for (const receipt of result.receipts) {
    const needsAttention = receipt.status === 'attention';
    const needsAuthorization = receipt.status === 'authorization';
    const title = needsAuthorization ? 'Queued review needs authorization' : needsAttention
      ? 'Queued work needs attention'
      : receipt.kind === 'issue' ? 'Queued issue created' : 'Queued message sent';
    await self.registration.showNotification(title, {
      body: needsAuthorization ? 'Tap to authorize it in the Delivery center.' :
        needsAttention ? 'Tap to review it in Drafts.' : 'Tap to open it in Stackchain.',
      tag: 'stackchain-delivery-' + receipt.id,
      data: { route: receipt.route },
    });
  }
}

self.addEventListener('install', event => {
  event.waitUntil(caches.open(CACHE).then(cache => cache.addAll(SHELL)).then(() => self.skipWaiting()));
});

self.addEventListener('activate', event => {
  event.waitUntil((async () => {
    const keys = await caches.keys();
    await Promise.all(
      keys.filter(key => key.startsWith('stackchain-dashboard-') && key !== CACHE)
        .map(key => caches.delete(key))
    );
    const cache = await caches.open(CACHE);
    await Promise.allSettled(OPTIONAL_FEATURES.map(asset => cache.add(asset)));
    await self.clients.claim();
  })());
});

self.addEventListener('sync', event => {
  if (event.tag === 'stackchain-issue-outbox-v1') event.waitUntil(flushAndNotify());
});

self.addEventListener('message', event => {
  if (event.data?.type === 'stackchain-resume-outbox') event.waitUntil((async () => {
    await issueSync.resume();
    await flushAndNotify();
  })());
  if (event.data?.type === 'stackchain-session-lease') {
    event.waitUntil(storeOfflineLease(event.data.expiresAt, event.data.idleExpiresAt));
  }
  if (event.data?.type === 'stackchain-purge-outbox') event.waitUntil((async () => {
    try {
      await issueSync.purge();
      await deletePrivateDatabase('stackchain-unfiled-captures-v1');
      event.ports?.[0]?.postMessage({ ok: true });
    } catch (error) {
      event.ports?.[0]?.postMessage({ ok: false, error: String(error?.message || 'Outbox purge failed.') });
    }
  })());
});

self.addEventListener('push', event => {
  let payload;
  try { payload = event.data?.json?.() || {}; }
  catch (_error) { return; }
  const route = String(payload.route || '');
  const tag = String(payload.tag || '');
  const notificationId = Number(payload.notification_id);
  const updateCount = Number(payload.update_count);
  if (
    route === '#/my-work/updates'
    && tag === 'stackchain-update-digest'
    && Number.isSafeInteger(updateCount)
    && updateCount > 0
    && updateCount <= 50
  ) {
    event.waitUntil(self.registration.showNotification(updateCount + ' new work updates', {
      body: 'Tap to review them in Stackchain.',
      tag,
      data: {route},
    }));
    return;
  }
  if (!/^#\/my-work\/update\/\d+$/.test(route) || !/^stackchain-update-\d+$/.test(tag)) return;
  const options = {
    body: 'Tap to review it in Stackchain.',
    tag,
    data: {route},
  };
  if (
    Number.isSafeInteger(notificationId) && notificationId > 0
    && route === '#/my-work/update/' + notificationId
    && tag === 'stackchain-update-' + notificationId
  ) {
    options.actions = [
      { action: 'mark-read', title: 'Mark read' },
      { action: 'tomorrow', title: 'Tomorrow' },
    ];
    options.data.notificationId = notificationId;
  }
  event.waitUntil(self.registration.showNotification('New work update', options));
});

async function openWorkRoute(route) {
  const target = new URL(BASE + route, self.location.origin).href;
  const windows = await self.clients.matchAll({ type: 'window', includeUncontrolled: true });
  const client = windows.find(candidate => candidate.url.startsWith(self.location.origin + BASE));
  if (!client) return self.clients.openWindow(target);
  if (client.navigate) await client.navigate(target);
  return client.focus();
}

self.addEventListener('notificationclick', event => {
  const route = String(event.notification.data?.route || '');
  if (event.action === 'tomorrow') {
    const notificationId = Number(event.notification.data?.notificationId);
    if (
      !Number.isSafeInteger(notificationId) || notificationId <= 0
      || route !== '#/my-work/update/' + notificationId
      || event.notification.tag !== 'stackchain-update-' + notificationId
    ) return;
    event.waitUntil((async () => {
      const controller = new AbortController();
      const timeout = setTimeout(() => controller.abort(), PUSH_ACTION_TIMEOUT_MS);
      try {
        const wake = new Date(self.__STACKCHAIN_NOW?.() || Date.now());
        wake.setDate(wake.getDate() + 1);
        wake.setHours(9, 0, 0, 0);
        await fetchJson(BASE + 'api/v1/notifications/' + notificationId + '/later', {
          method: 'PATCH',
          headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
          body: JSON.stringify({ wake_at: wake.toISOString() }),
          signal: controller.signal,
        });
        event.notification.close();
      } catch (_error) {
        await openWorkRoute(route);
        event.notification.close();
      } finally {
        clearTimeout(timeout);
      }
    })());
    return;
  }
  if (event.action === 'mark-read') {
    const notificationId = Number(event.notification.data?.notificationId);
    if (
      !Number.isSafeInteger(notificationId) || notificationId <= 0
      || route !== '#/my-work/update/' + notificationId
    ) return;
    event.waitUntil((async () => {
      const controller = new AbortController();
      const timeout = setTimeout(() => controller.abort(), PUSH_ACTION_TIMEOUT_MS);
      try {
        await fetchJson(BASE + 'api/v1/notifications/' + notificationId + '/read', {
          method: 'PATCH', headers: { Accept: 'application/json' }, signal: controller.signal,
        });
        event.notification.close();
      } catch (_error) {
        await openWorkRoute(route);
        event.notification.close();
      } finally {
        clearTimeout(timeout);
      }
    })());
    return;
  }
  event.notification.close();
  if (!route.startsWith('#/my-work/')) return;
  event.waitUntil(openWorkRoute(route));
});

self.addEventListener('fetch', event => {
  const request = event.request;
  if (request.method !== 'GET' || request.url.includes('/api/')) return;
  const url = new URL(request.url);
  if (url.origin !== self.location.origin || !url.pathname.startsWith(BASE)) return;
  if (request.mode === 'navigate') {
    event.respondWith(
      fetchNavigation(request).then(async response => {
        const cache = await caches.open(CACHE);
        const responseUrl = new URL(response.url || request.url);
        const isDashboardShell = responseUrl.origin === self.location.origin && responseUrl.pathname === BASE;
        if (response.ok && !response.redirected && isDashboardShell) {
          await cache.put(BASE, response.clone());
        } else if (OUTAGE_STATUSES.has(response.status)) {
          const cached = await cachedShellWithValidLease(cache);
          if (cached) return cached;
        }
        return response;
      }).catch(async () => {
        const cache = await caches.open(CACHE);
        const cached = await cachedShellWithValidLease(cache);
        return cached || new Response(
          'Stackchain is offline and the dashboard is not cached yet. Reconnect and try again.',
          { status: 504, headers: { 'Content-Type': 'text/plain; charset=utf-8' } },
        );
      })
    );
    return;
  }
  if (url.origin === self.location.origin && SHELL.includes(url.pathname)) {
    event.respondWith(caches.match(request).then(cached => cached || fetch(request)));
    return;
  }
  if (url.origin === self.location.origin && OPTIONAL_FEATURES.includes(url.pathname)) {
    event.respondWith(caches.match(request).then(cached => cached || fetch(request)));
  }
});