---

(async function () {
  'use strict';

  // ============ КОНФИГ ============
  const DELAY_BETWEEN_ROWS   = 1500;   // пауза между заявками (мс)
  const PANEL_LOAD_TIMEOUT   = 20000;  // максимум ждём загрузки панели
  const COMMENTS_TIMEOUT     = 15000;  // максимум ждём догрузки комментариев
  const SCROLL_STEP          = 300;    // шаг скролла при сборе списка
  const SCROLL_WAIT          = 600;    // ожидание после скролла
  const MAX_IDLE_SCROLLS     = 3;      // шагов без новых строк — стоп
  const MAX_SCROLL_ITER      = 500;    // защита от бесконечного цикла

  // ============ УТИЛИТЫ ============
  const sleep = (ms) => new Promise(r => setTimeout(r, ms));

  function log(...args) {
    console.log('%c[TFS-Report]', 'color:#0a0;font-weight:bold', ...args);
  }
  function warn(...args) {
    console.warn('%c[TFS-Report]', 'color:#c80;font-weight:bold', ...args);
  }

  function waitFor(selector, { root = document, timeout = 10000 } = {}) {
    return new Promise((resolve, reject) => {
      const found = root.querySelector(selector);
      if (found) return resolve(found);
      const obs = new MutationObserver(() => {
        const el = root.querySelector(selector);
        if (el) { obs.disconnect(); clearTimeout(timer); resolve(el); }
      });
      obs.observe(root, { childList: true, subtree: true });
      const timer = setTimeout(() => {
        obs.disconnect();
        reject(new Error('timeout waiting for: ' + selector));
      }, timeout);
    });
  }

  function waitForCondition(checkFn, { timeout = 10000, label = '', pollMs = 300 } = {}) {
    return new Promise((resolve, reject) => {
      let done = false;
      let lastDiag = '';

      const check = () => {
        try {
          const v = checkFn();
          if (v === true || (v && v.ok)) return { ok: true, value: v };
          if (v && typeof v === 'object' && v.diag) lastDiag = v.diag;
        } catch (e) {
          lastDiag = 'exception: ' + e.message;
        }
        return { ok: false };
      };

      const tryResolve = () => {
        if (done) return;
        const r = check();
        if (r.ok) { done = true; cleanup(); resolve(r.value); }
      };

      const obs = new MutationObserver(tryResolve);
      obs.observe(document.body, {
        childList: true, subtree: true, characterData: true, attributes: true
      });

      const poll = setInterval(tryResolve, pollMs);

      function cleanup() {
        obs.disconnect();
        clearInterval(poll);
        clearTimeout(timer);
      }

      const timer = setTimeout(() => {
        if (done) return;
        done = true;
        cleanup();
        reject(new Error(`timeout: ${label}${lastDiag ? ` (lastDiag="${lastDiag}")` : ''}`));
      }, timeout);

      tryResolve();
    });
  }

  // ============ 1. СКРОЛЛ-КОНТЕЙНЕР СПИСКА ============
  function ancestors(el, depth = 8) {
    const arr = [];
    let p = el;
    for (let i = 0; i < depth && p; i++) { p = p.parentElement; if (p) arr.push(p); }
    return arr;
  }

  function getScroller() {
    const spacer = document.querySelector('.grid-content-spacer');
    if (!spacer) {
      warn('grid-content-spacer не найден');
      return document.scrollingElement;
    }

    for (const el of [spacer, spacer.parentElement, ...ancestors(spacer, 8)]) {
      if (!el || el === document.body || el === document.documentElement) continue;
      const st = getComputedStyle(el);
      if ((st.overflowY === 'auto' || st.overflowY === 'scroll') &&
          el.scrollHeight > el.clientHeight + 5) return el;
    }

    let el = spacer.parentElement;
    while (el && el !== document.body) {
      if (el.scrollHeight > el.clientHeight + 5) return el;
      el = el.parentElement;
    }
    return spacer.parentElement || document.scrollingElement;
  }

  async function scrollToTop(scroller) {
    if (!scroller) return;
    scroller.scrollTop = 0;
    scroller.dispatchEvent(new Event('scroll', { bubbles: true }));
    await sleep(SCROLL_WAIT);
  }

  // ============ 2. СБОР СПИСКА ЗАЯВОК ============
  function readVisibleRows() {
    const result = [];
    document.querySelectorAll('.grid-row').forEach(row => {
      const a = row.querySelector('a.work-item-title-link');
      if (!a) return;
      const m = (a.getAttribute('href') || '').match(/\/edit\/(\d+)/);
      if (!m) return;
      result.push({
        id: m[1],
        title: a.textContent.trim(),
        href: a.getAttribute('href')
      });
    });
    return result;
  }

  async function collectAllRows(scroller) {
    log('Сбор списка заявок...');
    const map = new Map();
    let idle = 0;
    let iter = 0;

    await scrollToTop(scroller);

    while (iter++ < MAX_SCROLL_ITER) {
      const before = map.size;
      readVisibleRows().forEach(r => { if (!map.has(r.id)) map.set(r.id, r); });
      if (map.size > before) idle = 0;

      const atBottom = !scroller ||
        scroller.scrollTop + scroller.clientHeight >= scroller.scrollHeight - 10;

      if (atBottom) {
        idle++;
        if (idle >= MAX_IDLE_SCROLLS) break;
        scroller.scrollTop = scroller.scrollTop + 5;
        scroller.dispatchEvent(new Event('scroll', { bubbles: true }));
        await sleep(SCROLL_WAIT);
        continue;
      }

      scroller.scrollTop = Math.min(scroller.scrollTop + SCROLL_STEP, scroller.scrollHeight);
      scroller.dispatchEvent(new Event('scroll', { bubbles: true }));
      await sleep(SCROLL_WAIT);
    }

    readVisibleRows().forEach(r => { if (!map.has(r.id)) map.set(r.id, r); });
    log(`Найдено заявок: ${map.size}`);
    return Array.from(map.values());
  }

  // ============ 3. ЧТЕНИЕ ПОЛЕЙ ПАНЕЛИ ============
  const findInput = (panel, aria) => panel.querySelector(`input[aria-label="${aria}"]`);
  const getPanel = () => document.querySelector('.rightPane');

  function readInputOrDisplay(panel, aria, displaySelector) {
    const v = findInput(panel, aria)?.value?.trim();
    if (v) return v;
    return panel.querySelector(displaySelector)?.textContent?.trim() || '';
  }

  function getTitle(panel) {
    const v = findInput(panel, 'Поле заголовка')?.value?.trim()
           || panel.querySelector('#witc_221_txt')?.value?.trim();
    if (v) return v;
    return panel.querySelector('.workitem-info-bar .caption')?.textContent?.trim() || '';
  }

  const getState = (panel) => readInputOrDisplay(panel, 'Поле состояния', '.workitem-state-value');

  const getAssignedTo = (panel) =>
    panel.querySelector('.work-item-form-assignedTo .identity-picker-resolved-name')?.textContent?.trim() || '';

  function getArea(panel) {
    const inp = findInput(panel, 'Путь области') || panel.querySelector('#witc_225_txt');
    return inp?.value?.trim() || '';
  }

  function getIteration(panel) {
    const inp = findInput(panel, 'Путь итерации') || panel.querySelector('#witc_229_txt');
    return inp?.value?.trim() || '';
  }

  function getChangedBy(panel) {
    for (const el of panel.querySelectorAll('.freshness-indicator')) {
      const t = el.textContent.trim();
      if (t && el.offsetParent !== null) return t;
    }
    return '';
  }

  // ============ 4. КОММЕНТАРИИ ============

  function getExpectedCommentCount(panel) {
    const adorn = panel.querySelector('.discussion-adornment-control');
    if (adorn) {
      const s = (adorn.getAttribute('aria-label') || '') + ' ' + (adorn.textContent || '');
      const m = s.match(/(\d+)/);
      if (m) return parseInt(m[1], 10);
    }
    const badge = panel.querySelector('.discussion-adornment-container .text');
    if (badge) {
      const m = badge.textContent.match(/(\d+)/);
      if (m) return parseInt(m[1], 10);
    }
    const tabCount = panel.querySelector('.work-item-form-tab .link-count, .work-item-form-tab .attachment-count');
    if (tabCount) {
      const m = tabCount.textContent.match(/(\d+)/);
      if (m) return parseInt(m[1], 10);
    }
    return null;
  }

  async function ensureDiscussionExpanded(panel) {
    const header = Array.from(panel.querySelectorAll('.tfs-collapsible-header'))
      .find(h => /Обсуждени/i.test(h.textContent));
    if (!header) return;

    const content = header.parentElement?.querySelector('.tfs-collapsible-content');
    if (content && content.style.display === 'none') {
      (header.querySelector('.headerlabel') || header).click();
      await sleep(500);
    }

    const discTab = Array.from(panel.querySelectorAll('.work-item-form-tab'))
      .find(t => /обсужд|discussion/i.test(t.getAttribute('aria-labelledby') || t.textContent || ''));
    if (discTab && !discTab.classList.contains('selected-tab')) {
      const discVisible = content && content.offsetParent !== null;
      if (!discVisible) {
        discTab.click();
        await sleep(500);
      }
    }
  }

  function parseRelativeTime(s) {
    if (!s) return Infinity;
    const m = s.toLowerCase().match(/(\d+)\s*(сек|мин|ч|дн|час|день|недел)/);
    if (!m) return Infinity;
    const n = parseInt(m[1], 10);
    const u = m[2];
    if (/сек/.test(u)) return n;
    if (/мин/.test(u)) return n * 60;
    if (/ч|час/.test(u)) return n * 3600;
    if (/дн|день/.test(u)) return n * 86400;
    if (/недел/.test(u)) return n * 604800;
    return Infinity;
  }

  function extractCommentBody(ci) {
    const content = ci.querySelector('.comment-content');
    if (content) {
      const inner = content.querySelector('.rooster-editor, .lean-rooster');
      const txt = (inner ? inner.innerText : content.innerText || '').trim();
      if (txt) return txt;
    }
    const rooster = ci.querySelector('.rooster-editor, .lean-rooster');
    if (rooster) {
      const txt = (rooster.innerText || '').trim();
      if (txt) return txt;
    }
    const clone = ci.cloneNode(true);
    clone.querySelectorAll('.comment-header, .comment-toolbar, .comment-timestamp, .user-display-name')
      .forEach(n => n.remove());
    return (clone.innerText || '').trim();
  }

  function extractCommentData(ci) {
    const author = ci.querySelector('.user-display-name')?.textContent.trim() || '';
    const tsRaw  = ci.querySelector('.comment-timestamp')?.textContent.trim() || '';
    const body   = extractCommentBody(ci);
    const idAttr = ci.querySelector('[data-comment-id]')?.getAttribute('data-comment-id');
    const id     = idAttr ? parseInt(idAttr, 10) : null;
    return { id, author, tsRaw, ts: parseRelativeTime(tsRaw), body };
  }

  function pickLatest(comments) {
    if (!comments.length) return null;
    const withId = comments.filter(c => c.id != null);
    if (withId.length) return withId.reduce((a, b) => (b.id > a.id ? b : a));
    return comments.reduce((a, b) => (b.ts < a.ts ? b : a));
  }

  function findDiscussionScroller(panel) {
    const roots = [
      panel.querySelector('.discussion-messages'),
      panel.querySelector('.discussion-messages-container'),
      panel.querySelector('.discussion-control'),
      panel.querySelector('.witform-layout-scrollable-frame')
    ].filter(Boolean);

    for (const root of roots) {
      let el = root;
      while (el && el !== document.body) {
        const st = getComputedStyle(el);
        if ((st.overflowY === 'auto' || st.overflowY === 'scroll') &&
            el.scrollHeight > el.clientHeight + 2) {
          return el;
        }
        el = el.parentElement;
      }
    }
    return null;
  }

  async function scrollDiscussionToBottom(scroller, { step = 200, pause = 120 } = {}) {
    if (!scroller) return;
    let stable = 0;
    for (let i = 0; i < 50; i++) {
      const before = scroller.scrollHeight;
      scroller.scrollTop = Math.min(scroller.scrollTop + step, scroller.scrollHeight);
      scroller.dispatchEvent(new Event('scroll', { bubbles: true }));
      await sleep(pause);

      if (scroller.scrollHeight === before) stable++; else stable = 0;

      const atBottom = scroller.scrollTop + scroller.clientHeight >= scroller.scrollHeight - 5;
      if (atBottom && stable >= 2) break;
    }
    scroller.scrollTop = scroller.scrollHeight;
    scroller.dispatchEvent(new Event('scroll', { bubbles: true }));
    await sleep(300);
  }

  async function loadAllComments(panel, { timeout = COMMENTS_TIMEOUT, previousCommentIds = [] } = {}) {
    await ensureDiscussionExpanded(panel);
    const expected = getExpectedCommentCount(panel);
    const prevSet = new Set(previousCommentIds.map(String));

    // Если ожидаемое = 0 — ждём, пока «чужие» комментарии уйдут из DOM
    if (expected === 0) {
      for (let t = 0; t < 15; t++) {
        const hasStale = Array.from(panel.querySelectorAll('.comment-item [data-comment-id]'))
          .some(el => prevSet.has(el.getAttribute('data-comment-id')));
        if (!hasStale && panel.querySelectorAll('.comment-item').length === 0) break;
        await sleep(200);
      }
      return [];
    }

    const messagesRoot =
      panel.querySelector('.discussion-messages') ||
      panel.querySelector('.discussion-messages-container') ||
      panel.querySelector('.discussion-control');
    if (!messagesRoot) return [];

    const scroller = findDiscussionScroller(panel) || messagesRoot;

    const started = performance.now();
    const maxTicks = Math.ceil(timeout / 300);
    let lastCount = -1;
    let stableTicks = 0;
    let lastHeight = -1;
    let heightStableTicks = 0;

    for (let tick = 0; tick < maxTicks; tick++) {
      const items = Array.from(panel.querySelectorAll('.comment-item'));
      const count = items.length;
      const curHeight = scroller.scrollHeight;

      const bodies = items.map(extractCommentBody);
      const emptyBodies = bodies.filter(b => !b).length;

      const hasStale = Array.from(panel.querySelectorAll('.comment-item [data-comment-id]'))
        .some(el => prevSet.has(el.getAttribute('data-comment-id')));

      const countOk = expected != null
        ? count >= expected
        : (count > 0 && stableTicks >= 3);

      if (countOk && emptyBodies === 0 && !hasStale) break;

      // диагностика раз в 3 тика
      if (tick % 3 === 0) {
        log(`   [tick ${tick}] expected=${expected}, count=${count}, empty=${emptyBodies}, stale=${hasStale}, h=${curHeight}`);
      }

      await scrollDiscussionToBottom(scroller, { step: 200, pause: 120 });

      if (count === lastCount) stableTicks++; else stableTicks = 0;
      if (curHeight === lastHeight) heightStableTicks++; else heightStableTicks = 0;
      lastCount = count;
      lastHeight = curHeight;

      if (performance.now() - started > timeout) break;
    }

    const all = Array.from(panel.querySelectorAll('.comment-item')).map(extractCommentData);

    if (expected != null && all.length < expected) {
      warn(`   ⚠ Собрано ${all.length} из ${expected} комментариев (timeout)`);
    }
    const empty = all.filter(c => !c.body).length;
    if (empty) warn(`   ⚠ ${empty} комментариев с пустым текстом`);

    return all;
  }

  async function waitForComments(panel, opts = {}) {
    const all = await loadAllComments(panel, opts);
    return { all, latest: pickLatest(all) };
  }

  // ============ 5. ОЖИДАНИЕ ЗАГРУЗКИ ПАНЕЛИ ============
  async function waitForPanelLoaded(expectedId, previousCommentIds = [], { timeout = PANEL_LOAD_TIMEOUT } = {}) {
    await waitFor('.rightPane', { timeout });
    const started = performance.now();

    await waitForCondition(() => {
      const panel = document.querySelector('.rightPane');
      if (!panel) return { ok: false, diag: 'no panel' };

      const caption = panel.querySelector('.workitem-info-bar .caption');
      if (!caption) return { ok: false, diag: 'no caption' };
      const m = caption.textContent.match(/(\d{4,})/);
      if (!m) return { ok: false, diag: 'caption without id' };
      if (expectedId && m[1] !== String(expectedId)) {
        return { ok: false, diag: `caption id ${m[1]} != ${expectedId}` };
      }

      const stateText =
        (findInput(panel, 'Поле состояния')?.value || '').trim() ||
        (panel.querySelector('#witc_223_txt')?.value || '').trim() ||
        (panel.querySelector('.workitem-state-value')?.textContent || '').trim();
      if (!stateText) return { ok: false, diag: 'state empty' };

      if (panel.querySelectorAll('.work-item-form-tab').length < 3) {
        return { ok: false, diag: 'tabs < 3' };
      }
      if (!panel.querySelector('.work-item-form-tab.selected-tab')) {
        return { ok: false, diag: 'no active tab' };
      }
      if (!panel.querySelector('.discussion-control, .discussion-messages-container')) {
        return { ok: false, diag: 'no discussion' };
      }

      // Ключевая проверка: не остались ли комментарии предыдущей заявки
      if (previousCommentIds.length) {
        const prevSet = new Set(previousCommentIds.map(String));
        const currentIds = Array.from(panel.querySelectorAll('.comment-item [data-comment-id]'))
          .map(el => el.getAttribute('data-comment-id'));
        const stale = currentIds.filter(id => prevSet.has(id));
        if (stale.length) {
          return { ok: false, diag: `stale comments from prev work item (${stale.length})` };
        }
      }

      return { ok: true };
    }, { timeout, label: 'panel fields ready' });

    log(`Панель загружена за ${Math.round(performance.now() - started)} мс (id=${expectedId})`);
  }

  // ============ 6. ОТКРЫТИЕ ЗАЯВКИ ============
  async function findRowLink(itemId, scroller) {
    const sel = `a.work-item-title-link[href*="/edit/${itemId}"]`;
    let link = document.querySelector(sel);
    if (link) return link;

    if (scroller) {
      scroller.scrollTop = 0;
      scroller.dispatchEvent(new Event('scroll', { bubbles: true }));
      await sleep(300);
      for (let pos = 0; pos <= scroller.scrollHeight; pos += SCROLL_STEP) {
        scroller.scrollTop = pos;
        scroller.dispatchEvent(new Event('scroll', { bubbles: true }));
        await sleep(250);
        link = document.querySelector(sel);
        if (link) return link;
      }
    }
    return null;
  }

  async function openWorkItem(item, scroller, previousCommentIds = []) {
    const link = await findRowLink(item.id, scroller);
    if (!link) throw new Error(`Не найдена строка для заявки ${item.id}`);

    link.scrollIntoView({ block: 'center' });
    await sleep(200);

    const opts = { bubbles: true, cancelable: true, view: window, button: 0 };
    link.dispatchEvent(new MouseEvent('mousedown', opts));
    link.dispatchEvent(new MouseEvent('mouseup', opts));
    link.dispatchEvent(new MouseEvent('click', opts));

    await waitForPanelLoaded(item.id, previousCommentIds);
  }

  // ============ 7. ГЛАВНЫЙ ЦИКЛ ============
  async function main() {
    const scroller = getScroller() || document.scrollingElement;
    log('Скролл-контейнер:', scroller);

    await scrollToTop(scroller);

    const items = await collectAllRows(scroller);
    if (!items.length) { warn('Заявок не найдено'); return; }

    const report = [];
    let previousCommentIds = [];   // id комментариев предыдущей заявки

    for (let i = 0; i < items.length; i++) {
      const it = items[i];
      log(`(${i + 1}/${items.length}) Открываю ${it.id} — ${it.title}`);

      try {
        await openWorkItem(it, scroller, previousCommentIds);
        const panel = getPanel();
        const { all: comments, latest } = await waitForComments(panel, {
          previousCommentIds
        });

        // обновляем «предыдущие» id комментариев
        previousCommentIds = comments.map(c => c.id).filter(Boolean).map(String);

        const data = {
          id: it.id,
          title: getTitle(panel),
          state: getState(panel),
          assignedTo: getAssignedTo(panel),
          area: getArea(panel),
          iteration: getIteration(panel),
          changedBy: getChangedBy(panel),
          commentsCount: comments.length,
          latestComment: latest ? latest.body : '',
          latestAuthor: latest ? latest.author : '',
          latestTime: latest ? latest.tsRaw : '',
          comments
        };

        report.push(data);
        log(`   ✓ ${data.state || '?'} | ${data.assignedTo || '?'} | комм.: ${data.commentsCount}, свежий: "${data.latestComment.slice(0, 60)}"`);
      } catch (e) {
        warn(`   ✗ Ошибка ${it.id}: ${e.message}`);
        report.push({ id: it.id, title: it.title, error: e.message });
      }

      await sleep(DELAY_BETWEEN_ROWS);
    }

    // ============ ВЫГРУЗКА ============

    console.table(report.map(r => ({
      id: r.id,
      title: r.title,
      state: r.state,
      assignedTo: r.assignedTo,
      'комм. всего': r.commentsCount ?? '—',
      'последний': r.latestComment ? r.latestComment.slice(0, 100) : '—',
      error: r.error || ''
    })));

    // Группировка по одинаковому тексту последнего комментария
    const grouped = new Map();
    const noComment = [];
    const errored = [];

    for (const r of report) {
      if (r.error) { errored.push(r); continue; }
      const text = (r.latestComment || '').trim();
      if (!text) { noComment.push(r); continue; }
      if (!grouped.has(text)) grouped.set(text, []);
      grouped.get(text).push(r);
    }

    const groupedLines = [];
    for (const [text, items] of grouped) {
      items.sort((a, b) => a.id.localeCompare(b.id, undefined, { numeric: true }));
      const ids = items.map(x => x.id).join(', ');
      groupedLines.push(`${ids} - ${text}`);
    }

    console.log('%c=== Сгруппированные комментарии ===', 'color:#0a0;font-weight:bold');
    if (groupedLines.length) {
      groupedLines.forEach(line => console.log(line));
    } else {
      console.log('(нет заявок с комментариями)');
    }

    if (noComment.length) {
      console.log('%c--- Без комментариев ---', 'color:#888;font-weight:bold');
      console.log(noComment.map(r => r.id).join(', '));
    }
    if (errored.length) {
      console.log('%c--- Ошибки ---', 'color:#c00;font-weight:bold');
      errored.forEach(r => console.log(`${r.id} — ${r.error}`));
    }

    window.__tfsReport    = report;
    window.__tfsGrouped   = groupedLines;
    window.__tfsNoComment = noComment.map(r => r.id);
    window.__tfsErrored   = errored;

    // JSON
    const blobJson = new Blob([JSON.stringify(report, null, 2)], { type: 'application/json' });
    const aJson = document.createElement('a');
    aJson.href = URL.createObjectURL(blobJson);
    aJson.download = `tfs_report_${Date.now()}.json`;
    document.body.appendChild(aJson);
    aJson.click();
    aJson.remove();

    // TXT с группировкой
    const txt = groupedLines.join('\n')
      + (noComment.length ? `\n\nБез комментариев:\n${noComment.map(r => r.id).join(', ')}` : '')
      + (errored.length ? `\n\nОшибки:\n${errored.map(r => `${r.id} — ${r.error}`).join('\n')}` : '');

    const blobTxt = new Blob(['\ufeff' + txt], { type: 'text/plain;charset=utf-8' });
    const aTxt = document.createElement('a');
    aTxt.href = URL.createObjectURL(blobTxt);
    aTxt.download = `tfs_grouped_${Date.now()}.txt`;
    document.body.appendChild(aTxt);
    aTxt.click();
    aTxt.remove();

    // CSV
    const csvEsc = (s) => `"${String(s ?? '').replace(/"/g, '""').replace(/\r?\n/g, ' ')}"`;
    const csv = [
      ['id', 'title', 'state', 'assignedTo', 'area', 'iteration', 'changedBy',
       'commentsCount', 'latestComment', 'latestAuthor', 'latestTime', 'error']
        .map(csvEsc).join(';'),
      ...report.map(r => [
        r.id, r.title, r.state, r.assignedTo, r.area, r.iteration, r.changedBy,
        r.commentsCount ?? '',
        r.latestComment ?? '',
        r.latestAuthor ?? '',
        r.latestTime ?? '',
        r.error || ''
      ].map(csvEsc).join(';'))
    ].join('\r\n');

    const blobCsv = new Blob(['\ufeff' + csv], { type: 'text/csv;charset=utf-8' });
    const aCsv = document.createElement('a');
    aCsv.href = URL.createObjectURL(blobCsv);
    aCsv.download = `tfs_report_${Date.now()}.csv`;
    document.body.appendChild(aCsv);
    aCsv.click();
    aCsv.remove();

    log('Готово. window.__tfsReport, window.__tfsGrouped');
  }

  main().catch(e => console.error('[TFS-Report] FATAL:', e));
})();