X連投の順番抜けを投稿前に発見｜GASでスレッド候補をdry-run監査

function auditXThreadSequenceFree() {
  const config = {
    sheetName: 'Xスレッド確認',
    headerRow: 1,
    dryRun: true,
    writeSummary: false,
    summarySheetName: 'AuditSummary',
    allowedStatuses: ['下書き', '確認中', '承認済'],
    requiredStatus: '承認済',
    maxRows: 500,
    simpleCharacterLimit: 280
  };

  validateXThreadAuditConfig_(config);

  const spreadsheet = SpreadsheetApp.getActiveSpreadsheet();
  const sheet = spreadsheet.getSheetByName(config.sheetName);
  if (!sheet) {
    throw new Error('対象シート「' + config.sheetName + '」が見つかりません。');
  }

  const lastRow = sheet.getLastRow();
  const lastColumn = sheet.getLastColumn();
  if (lastRow <= config.headerRow) {
    Logger.log('確認対象は0件です。');
    return { checked: 0, ok: 0, warningRows: 0, issueCount: 0 };
  }

  const targetCount = lastRow - config.headerRow;
  if (targetCount > config.maxRows) {
    throw new Error(
      '確認対象が上限の' + config.maxRows + '行を超えています。' +
      'コピー環境で範囲を分けて確認してください。'
    );
  }

  const values = sheet
    .getRange(config.headerRow, 1, targetCount + 1, lastColumn)
    .getValues();

  const headers = values[0].map(function(value) {
    return String(value).trim();
  });
  const requiredHeaders = ['スレッドID', '連番', '承認状態', '本文', '予約日時'];
  const indexes = {};

  requiredHeaders.forEach(function(header) {
    const index = headers.indexOf(header);
    if (index === -1) {
      throw new Error('必須列「' + header + '」がありません。');
    }
    indexes[header] = index;
  });

  const groups = {};
  const issues = [];

  values.slice(1).forEach(function(row, offset) {
    const rowNumber = config.headerRow + offset + 1;
    const threadId = String(row[indexes['スレッドID']] || '').trim();
    const sequenceRaw = row[indexes['連番']];
    const status = String(row[indexes['承認状態']] || '').trim();
    const body = String(row[indexes['本文']] || '');
    const scheduledAt = row[indexes['予約日時']];
    const rowIssues = [];

    if (!threadId) {
      rowIssues.push('THREAD_ID_EMPTY');
    }

    const sequence = Number(sequenceRaw);
    if (!Number.isInteger(sequence) || sequence < 1) {
      rowIssues.push('SEQUENCE_INVALID');
    }

    if (config.allowedStatuses.indexOf(status) === -1) {
      rowIssues.push('STATUS_INVALID');
    } else if (status !== config.requiredStatus) {
      rowIssues.push('NOT_APPROVED');
    }

    if (!body.trim()) {
      rowIssues.push('BODY_EMPTY');
    } else if (Array.from(body).length > config.simpleCharacterLimit) {
      rowIssues.push('BODY_OVER_SIMPLE_LIMIT');
    }

    const scheduledDate = parseXThreadDate_(scheduledAt);
    if (scheduledAt !== '' && scheduledAt != null && !scheduledDate) {
      rowIssues.push('SCHEDULE_INVALID');
    }

    if (threadId && Number.isInteger(sequence) && sequence >= 1) {
      const groupKey = hashXThreadKey_(threadId);
      if (!groups[groupKey]) groups[groupKey] = [];
      groups[groupKey].push({
        row: rowNumber,
        sequence: sequence,
        scheduledAt: scheduledDate
      });
    }

    rowIssues.forEach(function(code) {
      issues.push({ row: rowNumber, code: code });
    });
  });

  Object.keys(groups).forEach(function(groupKey) {
    const rows = groups[groupKey].slice().sort(function(a, b) {
      return a.sequence - b.sequence || a.row - b.row;
    });
    const sequenceRows = {};

    rows.forEach(function(item) {
      if (sequenceRows[item.sequence]) {
        issues.push({ row: item.row, code: 'SEQUENCE_DUPLICATE' });
        issues.push({ row: sequenceRows[item.sequence], code: 'SEQUENCE_DUPLICATE' });
      } else {
        sequenceRows[item.sequence] = item.row;
      }
    });

    if (rows[0] && rows[0].sequence !== 1) {
      issues.push({ row: rows[0].row, code: 'SEQUENCE_MUST_START_AT_ONE' });
    }

    for (let index = 1; index < rows.length; index += 1) {
      const previous = rows[index - 1];
      const current = rows[index];
      if (current.sequence > previous.sequence + 1) {
        issues.push({ row: current.row, code: 'SEQUENCE_GAP_BEFORE_ROW' });
      }
      if (
        previous.scheduledAt && current.scheduledAt &&
        current.scheduledAt.getTime() < previous.scheduledAt.getTime()
      ) {
        issues.push({ row: current.row, code: 'SCHEDULE_REVERSED' });
      }
    }
  });

  const summary = buildXThreadAuditSummary_(targetCount, issues);

  Logger.log('dry-run: ' + config.dryRun);
  Logger.log('確認行数: ' + summary.checked);
  Logger.log('問題なし行数: ' + summary.ok);
  Logger.log('確認対象行数: ' + summary.warningRows);
  Logger.log('指摘件数: ' + summary.issueCount);
  issues.forEach(function(issue) {
    Logger.log('行' + issue.row + ': ' + issue.code);
  });
  Logger.log('投稿本文・スレッドID・アカウント情報はログへ出していません。');

  if (config.writeSummary === true) {
    writeXThreadAuditSummary_(spreadsheet, config, summary);
  }

  return summary;
}

function validateXThreadAuditConfig_(config) {
  if (config.dryRun !== true) {
    throw new Error('安全のためdryRunはtrue固定です。');
  }
  if (!config.sheetName || !Array.isArray(config.allowedStatuses)) {
    throw new Error('シート名または承認状態一覧の設定が不正です。');
  }
  if (config.allowedStatuses.indexOf(config.requiredStatus) === -1) {
    throw new Error('requiredStatusが承認状態一覧にありません。');
  }
  if (!Number.isInteger(config.maxRows) || config.maxRows < 1) {
    throw new Error('maxRowsは1以上の整数にしてください。');
  }
}

function hashXThreadKey_(threadId) {
  const digest = Utilities.computeDigest(
    Utilities.DigestAlgorithm.SHA_256,
    threadId,
    Utilities.Charset.UTF_8
  );
  return digest.map(function(byte) {
    const normalized = byte < 0 ? byte + 256 : byte;
    return ('0' + normalized.toString(16)).slice(-2);
  }).join('');
}

function parseXThreadDate_(value) {
  if (value === '' || value == null) return null;
  if (Object.prototype.toString.call(value) === '[object Date]') {
    return isNaN(value.getTime()) ? null : value;
  }
  if (typeof value !== 'string') return null;
  const text = value.trim();
  if (!/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/.test(text)) return null;
  const parts = text.match(/\d+/g).map(Number);
  const date = new Date(parts[0], parts[1] - 1, parts[2], parts[3], parts[4]);
  if (
    date.getFullYear() !== parts[0] ||
    date.getMonth() !== parts[1] - 1 ||
    date.getDate() !== parts[2] ||
    date.getHours() !== parts[3] ||
    date.getMinutes() !== parts[4]
  ) return null;
  return date;
}

function buildXThreadAuditSummary_(checked, issues) {
  const warningRows = {};
  const countsByCode = {};
  issues.forEach(function(issue) {
    warningRows[issue.row] = true;
    countsByCode[issue.code] = (countsByCode[issue.code] || 0) + 1;
  });
  const warningCount = Object.keys(warningRows).length;
  return {
    checked: checked,
    ok: checked - warningCount,
    warningRows: warningCount,
    issueCount: issues.length,
    countsByCode: countsByCode
  };
}

function writeXThreadAuditSummary_(spreadsheet, config, summary) {
  let summarySheet = spreadsheet.getSheetByName(config.summarySheetName);
  if (!summarySheet) {
    summarySheet = spreadsheet.insertSheet(config.summarySheetName);
  }
  summarySheet.clearContents();
  summarySheet.getRange(1, 1, 5, 2).setValues([
    ['確認日時', new Date()],
    ['確認行数', summary.checked],
    ['問題なし行数', summary.ok],
    ['確認対象行数', summary.warningRows],
    ['指摘件数', summary.issueCount]
  ]);
}