function buildMyWork(data) {
  const login = data.user?.login || '';
  const issues = (data.issues || []).map((item) => ({ ...item, kind: 'issue' }));
  const pulls = (data.pull_requests || []).map((item) => ({ ...item, kind: 'pull' }));
  const priorityLabels = ['p0', 'priority-high', 'critical'];

  const work = issues.concat(pulls).map((item) => {
    const labels = item.labels || [];
    const priorityLabel = labels.find((label) =>
      priorityLabels.includes(String(label).toLowerCase())
    );
    const assigned = (item.assignees || []).includes(login);
    const isReview = (item.work_reasons || []).includes('review_requested');
    return {
      ...item,
      key: (item.repository || 'unknown') + '#' + item.number,
      is_review: isReview,
      is_assigned: assigned,
      has_update: false,
      reason: priorityLabel ? priorityLabel + ' priority' :
        (isReview ? 'Needs your review' : (assigned ? 'Assigned to you' : 'Open work')),
      _priority: priorityLabel ? 0 : (isReview ? 2 : (assigned ? 3 : 4)),
    };
  });

  const byKey = new Map(work.map((item) => [item.kind + ':' + item.key, item]));
  (data.notifications || []).filter((item) => item && item.unread).forEach((update) => {
    const key = (update.repository || 'unknown') + '#' + update.number;
    const subjectKind = String(update.subject_type || '').toLowerCase().includes('pull') ? 'pull' : 'issue';
    const existing = byKey.get(subjectKind + ':' + key);
    if (existing) {
      existing.has_update = true;
      existing.notification_id = update.id;
      existing.url = update.url || existing.url;
      existing.updated_at = update.updated_at || existing.updated_at;
      existing._priority = Math.min(existing._priority, 1);
      return;
    }
    if (!update.url) return;
    const item = {
      ...update,
      key,
      kind: 'update',
      is_review: false,
      is_assigned: false,
      has_update: true,
      notification_id: update.id,
      reason: 'Unread update',
      _priority: 1,
    };
    work.push(item);
    byKey.set(subjectKind + ':' + key, item);
  });

  return work.sort((left, right) =>
    left._priority - right._priority ||
    String(right.updated_at || '').localeCompare(String(left.updated_at || '')) ||
    left.key.localeCompare(right.key)
  ).map(({ _priority, ...item }) => item);
}

function acknowledgeNotification(items, notificationId) {
  return items.flatMap((item) => {
    if (item.notification_id !== notificationId) return [item];
    if (item.kind === 'update') return [];
    const { notification_id, ...acknowledged } = item;
    return [{ ...acknowledged, has_update: false }];
  });
}

function createNotificationAcknowledger({ markRead, onItems, onStatus }) {
  const pending = new Set();
  return {
    async acknowledge(items, notificationId) {
      if (pending.has(notificationId)) return false;
      pending.add(notificationId);
      onItems(acknowledgeNotification(items, notificationId));
      onStatus('Marking update read…');
      try {
        await markRead(notificationId);
        onStatus('Update marked read.');
        return true;
      } catch (_error) {
        onItems(items);
        onStatus('Could not mark update read. Retry.');
        return false;
      } finally {
        pending.delete(notificationId);
      }
    },
  };
}

function notificationIds(items) {
  return Array.from(new Set((items || [])
    .filter((item) => item && item.has_update && Number.isInteger(item.notification_id))
    .map((item) => item.notification_id)));
}

function createBulkNotificationAcknowledger({ markRead, onItems, onStatus }) {
  let pending = false;
  return {
    async acknowledge(items, requestedIds) {
      if (pending) return false;
      const ids = Array.from(new Set((requestedIds || []).filter(Number.isInteger)));
      if (!ids.length) return false;
      pending = true;
      onStatus('Marking ' + ids.length + ' updates read…');
      try {
        const result = await markRead(ids);
        const marked = (result.marked || []).filter(Number.isInteger);
        const failed = (result.failed || []).filter(Number.isInteger);
        const updated = marked.reduce(
          (current, notificationId) => acknowledgeNotification(current, notificationId),
          items
        );
        onItems(updated);
        onStatus(failed.length ?
          marked.length + ' marked read · ' + failed.length + ' could not be updated — retry.' :
          marked.length + ' updates marked read.');
        return { marked, failed };
      } catch (_error) {
        onStatus('Could not mark updates read. Retry.');
        return false;
      } finally {
        pending = false;
      }
    },
  };
}

function createNotificationPager({ load, onNotifications, onPagination, onStatus }) {
  let pagination = { page: 1, total: 0, has_more: false };
  let pending = false;
  return {
    reset(next) {
      pagination = { ...pagination, ...(next || {}) };
      onPagination(pagination);
    },
    async loadMore(existing) {
      if (pending || !pagination.has_more) return false;
      pending = true;
      onStatus('Loading older updates…');
      try {
        const result = await load(pagination.page + 1);
        const byId = new Map((existing || [])
          .filter(item => item && Number.isInteger(item.id))
          .map(item => [item.id, item]));
        (result.items || []).forEach(item => {
          if (item && Number.isInteger(item.id) && !byId.has(item.id)) byId.set(item.id, item);
        });
        pagination = {
          page: result.page,
          total: result.total,
          has_more: result.has_more === true,
        };
        const loaded = Math.min(pagination.total, pagination.page * 50);
        onNotifications(Array.from(byId.values()));
        onPagination(pagination);
        onStatus(loaded + ' of ' + pagination.total + ' unread updates loaded.');
        return true;
      } catch (_error) {
        onStatus('Could not load older updates. Retry.');
        return false;
      } finally {
        pending = false;
      }
    },
  };
}

function createWorkPager({ load, onItems, onPagination, onStatus }) {
  let pagination = {};
  const pending = new Set();
  const labels = {
    issue: 'issues',
    pull: 'pull requests',
    review: 'review requests',
  };
  return {
    reset(next) {
      Object.entries(next || {}).forEach(([stream, value]) => {
        const current = pagination[stream];
        pagination[stream] = current && current.page > 1 ?
          { ...value, page: current.page, has_more: current.page * 50 < value.total } :
          { ...value };
      });
      onPagination({ ...pagination });
    },
    async loadMore(stream, existing) {
      const page = pagination[stream];
      if (pending.has(stream) || !page?.has_more) return false;
      pending.add(stream);
      const label = labels[stream] || 'work';
      onStatus('Loading older ' + label + '…');
      try {
        const result = await load(stream, page.page + 1);
        const merged = new Map((existing || [])
          .filter(item => item && Number.isInteger(item.id))
          .map(item => [item.id, { ...item }]));
        (result.items || []).forEach(item => {
          if (!item || !Number.isInteger(item.id)) return;
          const current = merged.get(item.id);
          if (!current) {
            merged.set(item.id, { ...item });
            return;
          }
          const reasons = Array.from(new Set(
            (current.work_reasons || []).concat(item.work_reasons || [])
          ));
          merged.set(item.id, {
            ...current, ...item, ...(reasons.length ? { work_reasons: reasons } : {}),
          });
        });
        pagination[stream] = {
          page: result.page, total: result.total, has_more: result.has_more === true,
        };
        onItems(stream, Array.from(merged.values()));
        onPagination({ ...pagination });
        onStatus(Math.min(result.total, result.page * 50) + ' of ' + result.total + ' ' + label + ' loaded.');
        return true;
      } catch (_error) {
        onStatus('Could not load older ' + label + '. Retry.');
        return false;
      } finally {
        pending.delete(stream);
      }
    },
  };
}

function createNotificationReader({ load, markRead, onOpen, onDetail, onItems, onStatus, onClose }) {
  let selected = null;
  let loadVersion = 0;
  let marking = false;

  async function open(item) {
    selected = item;
    const version = ++loadVersion;
    onOpen(item);
    onStatus('Loading update…');
    try {
      const detail = await load(item.notification_id);
      if (selected !== item || version !== loadVersion) return false;
      onDetail(detail);
      onStatus('Update ready.');
      return true;
    } catch (_error) {
      if (selected === item && version === loadVersion) {
        onStatus('Could not load update. Retry or open it in Gitea.');
      }
      return false;
    }
  }

  return {
    open,
    async markReadAndNext(items) {
      if (!selected || marking) return false;
      const current = selected;
      marking = true;
      onStatus('Marking update read…');
      try {
        await markRead(current.notification_id);
        const updated = acknowledgeNotification(items, current.notification_id);
        onItems(updated);
        const currentIndex = items.indexOf(current);
        const remaining = items.slice(currentIndex + 1).concat(items.slice(0, currentIndex));
        const next = remaining.find(item =>
          item && item.has_update && Number.isInteger(item.notification_id)
        );
        if (next) await open(next);
        else {
          selected = null;
          onClose();
          onStatus('Inbox cleared.');
        }
        return { items: updated, next: next || null };
      } catch (_error) {
        onStatus('Could not mark update read. Retry.');
        return false;
      } finally {
        marking = false;
      }
    },
  };
}

function createNotificationReplier({
  post, storage, onStatus,
  createOperationId = () => globalThis.crypto?.randomUUID?.() || String(Date.now()) + '-' + Math.random(),
}) {
  let pending = false;
  const keyFor = item => 'stackchain.update-reply.v1.' + item.notification_id;
  const operationKeyFor = item => keyFor(item) + ':operation';
  return {
    loadDraft(item) {
      try { return storage.getItem(keyFor(item)) || ''; }
      catch (_error) { return ''; }
    },
    saveDraft(item, body) {
      try {
        if ((storage.getItem(keyFor(item)) || '') !== body) storage.removeItem(operationKeyFor(item));
        storage.setItem(keyFor(item), body);
      }
      catch (_error) { /* Keep the editable textarea as the fallback. */ }
    },
    async submit(item, body) {
      if (pending) return false;
      pending = true;
      this.saveDraft(item, body);
      let operationId;
      try {
        operationId = storage.getItem(operationKeyFor(item)) || String(createOperationId()).slice(0, 128);
        storage.setItem(operationKeyFor(item), operationId);
      } catch (_error) { operationId = String(createOperationId()).slice(0, 128); }
      onStatus('Sending reply…');
      try {
        const result = await post(item.notification_id, body, operationId);
        try { storage.removeItem(keyFor(item)); }
        catch (_error) { /* The posted reply is still authoritative. */ }
        try { storage.removeItem(operationKeyFor(item)); }
        catch (_error) { /* A confirmed result no longer needs replay identity. */ }
        onStatus('Reply posted. You can mark this update read when ready.');
        return result;
      } catch (_error) {
        onStatus('Could not send reply. Your draft is safe; retry.');
        return false;
      } finally {
        pending = false;
      }
    },
  };
}

function filterMyWork(items, selectedFilter) {
  if (selectedFilter === 'all') return items;
  if (selectedFilter === 'review') return items.filter((item) => item.is_review);
  if (selectedFilter === 'update') return items.filter((item) => item.has_update);
  return items.filter((item) => item.kind === selectedFilter);
}

function replaceIssueLabels(data, repository, number, labels) {
  return {
    ...data,
    issues: (data.issues || []).map(item =>
      item.repository === repository && item.number === number ? { ...item, labels: [...labels] } : item
    ),
  };
}

function removeIssue(data, repository, number) {
  return {
    ...data,
    issues: (data.issues || []).filter(item =>
      item.repository !== repository || item.number !== number
    ),
  };
}

function summarizeMyWork(items) {
  const updates = items.filter((item) => item.has_update).length;
  const reviews = items.filter((item) => item.is_review).length;
  const assigned = items.filter((item) => item.is_assigned).length;
  const updateLabel = updates + ' unread update' + (updates === 1 ? '' : 's');
  const reviewLabel = reviews + ' review' + (reviews === 1 ? '' : 's');
  const assignedLabel = assigned + ' assigned';
  return (updates ? updateLabel + ' · ' : '') + reviewLabel + ' · ' + assignedLabel;
}

function countMyWork(items) {
  return {
    all: items.length,
    issue: items.filter((item) => item.kind === 'issue').length,
    pull: items.filter((item) => item.kind === 'pull' && !item.is_review).length,
    review: items.filter((item) => item.is_review).length,
    update: items.filter((item) => item.has_update).length,
  };
}

if (typeof module !== 'undefined' && module.exports) {
  buildMyWork.filterMyWork = filterMyWork;
  buildMyWork.replaceIssueLabels = replaceIssueLabels;
  buildMyWork.removeIssue = removeIssue;
  buildMyWork.summarizeMyWork = summarizeMyWork;
  buildMyWork.countMyWork = countMyWork;
  buildMyWork.acknowledgeNotification = acknowledgeNotification;
  buildMyWork.createNotificationAcknowledger = createNotificationAcknowledger;
  buildMyWork.notificationIds = notificationIds;
  buildMyWork.createBulkNotificationAcknowledger = createBulkNotificationAcknowledger;
  buildMyWork.createNotificationPager = createNotificationPager;
  buildMyWork.createWorkPager = createWorkPager;
  buildMyWork.createNotificationReader = createNotificationReader;
  buildMyWork.createNotificationReplier = createNotificationReplier;
  module.exports = buildMyWork;
}