---

(async function () {
  'use strict';

  // ============ КОНФИГ ============
  const DELAY_BETWEEN_ROWS   = 1500;   // пауза между заявками (мс)
  const PANEL_LOAD_TIMEOUT   = 20000;  // максимум ждём загрузки панели
  const COMMENTS_TIMEOUT     = 10000;  // максимум ждём догрузки комментариев
  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 m = (adorn.getAttribute('aria-label') || adorn.textContent || '').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);
    }
    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(400);
    }
  }

  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 extractCommentData(ci) {
    const author = ci.querySelector('.user-display-name')?.textContent.trim() || '';
    const tsRaw  = ci.querySelector('.comment-timestamp')?.textContent.trim() || '';
    const body   = (ci.querySelector('.comment-content')?.innerText || '').trim();
    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));
  }

  async function loadAllComments(panel, { timeout = COMMENTS_TIMEOUT } = {}) {
    await ensureDiscussionExpanded(panel);
    const expected = getExpectedCommentCount(panel);
    if (expected === 0) return [];

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

    let scroller = messagesRoot;
    while (scroller && scroller !== panel) {
      const st = getComputedStyle(scroller);
      if ((st.overflowY === 'auto' || st.overflowY === 'scroll') &&
          scroller.scrollHeight > scroller.clientHeight + 5) break;
      scroller = scroller.parentElement;
    }
    if (scroller === panel) scroller = messagesRoot;

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

    for (let tick = 0; tick < maxTicks; tick++) {
      const count = panel.querySelectorAll('.comment-item').length;

      if (expected != null && count >= expected) break;
      if (expected == null) {
        if (count === lastCount) stableTicks++; else stableTicks = 0;
        if (stableTicks >= 3 && count > 0) break;
        if (stableTicks >= 5 && count === 0) break;
      }

      if (scroller) {
        scroller.scrollTop = scroller.scrollHeight;
        scroller.dispatchEvent(new Event('scroll', { bubbles: true }));
      }
      window.scrollBy(0, 1); window.scrollBy(0, -1);

      lastCount = count;
      await sleep(300);
      if (performance.now() - started > timeout) break;
    }

    return Array.from(panel.querySelectorAll('.comment-item')).map(extractCommentData);
  }

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

  // ============ 5. ОЖИДАНИЕ ЗАГРУЗКИ ПАНЕЛИ ============
  async function waitForPanelLoaded(expectedId, { 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' };
      }

      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) {
    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);
  }

  // ============ 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 = [];

    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);
        const panel = getPanel();
        const { all: comments, latest } = await waitForComments(panel);

        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(); // text -> [report items]
    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);
    }

    // Строки вида "5122818, 5122820 - Согласовано"
    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));
})();