Search Console│異常を毎週自動検知する｜複数サイト対応のSEO監視ツール

{
  "timeZone": "Asia/Tokyo",
  "dependencies": {},
  "exceptionLogging": "STACKDRIVER",
  "runtimeVersion": "V8",
  "oauthScopes": [
    "https://www.googleapis.com/auth/webmasters.readonly",
    "https://www.googleapis.com/auth/script.external_request",
    "https://www.googleapis.com/auth/spreadsheets"
  ]
}

/**
   * ============================================================
   *  GSC 異常監視ツール  (Google Apps Script)
   * ============================================================
 *  毎週月曜8時に複数サイトの Search Console を分析し、
 *  リライト候補・検索流入の落ち込み・インデックス要確認URLを Slack に通知します。
 *  （候補がゼロの日は通知しません）
 *
 *  検知する項目:
 *   1. クリック数の急落（前週同期間比）
 *   2. 表示回数の急落（前週同期間比）
 *   3. 平均掲載順位の悪化
 *   4. ページ×クエリ別のリライト候補（表示多い / CTR低い / 8〜20位）
 *   5. ページ別の流入落ち込み
 *   6. 順位急落・新規クエリ・消失クエリ
 *   7. モバイルだけ順位が弱いページ
 *   8. 代表URL・落ち込みURLのインデックス状態（URL Inspection API）
 *
 *  ※ Sitemaps APIの contents[].indexed は非推奨で0になりやすいため、
 *     インデックス数の一括判定には使いません。
 *
 * ------------------------------------------------------------
 *  ■ セットアップ手順
 * ------------------------------------------------------------
 *  1. script.google.com で新規プロジェクトを作成
 *  2. このコードを丸ごと貼り付け
 *  3. GCPプロジェクトで「Search Console API」を有効化し、
 *     Apps Scriptのプロジェクト設定でGCPプロジェクト番号を紐付け
 *     （※過去にやった手順と同じ。サービス追加は不要）
 *  4. 下の SITES 配列に監視したいサイトを登録
 *  5. スクリプトプロパティに以下の2つを登録（プロジェクトの設定 > スクリプト プロパティ）
 *       SLACK_BOT_TOKEN : Slackアプリの Bot User OAuth Token（xoxb- で始まる）
 *       SLACK_CHANNEL   : 通知先チャンネル（例: #seo-alert または チャンネルID C0XXXX）
 *     ※ Slackアプリには chat:write 権限を付与し、対象チャンネルにBotを招待しておくこと
 *  6. checkNow を一度手動実行して動作確認＆権限承認
 *  7. setupTrigger を一度実行 → 毎週月曜8時の自動実行が登録される
 *
 *  ※ このスクリプトを動かすGoogleアカウントが、各サイトの
 *    Search Consoleプロパティに「オーナー」または「フルユーザー」
 *    として登録されている必要があります。
 * ============================================================
 */


// ============================================================
//  設定エリア（ここだけ編集すればOK）
// ============================================================

/**
 * 監視対象サイトの配列。サイトを増やすときはここに追加するだけ。
 *
 *  name       : 任意の表示名（Slack通知に出る）
 *  property   : Search Console の「プロパティ」文字列
 *             - ドメインプロパティの場合:  'sc-domain:example.com'
 *             - URLプレフィックス型の場合:  'https://example.com/'  （末尾スラッシュ必須・登録通りに）
 *  sampleUrls : URL Inspection APIで毎日確認する代表URL。未指定ならトップページを自動推定。
 */
const SITES = [
  {
    name: 'モトキデザイン',
    property: 'sc-domain:example.co.jp',
    sampleUrls: ['https://example.co.jp/'],
  },
  {
    name: 'CGメソッド',
    property: 'sc-domain:example.com',
    sampleUrls: ['https://example.com/'],
  },
  // { name: 'サイト3', property: 'https://example.com/', sampleUrls: ['https://example.com/'] },
];

/**
 * Slackの認証情報はスクリプトプロパティから読み込みます。
 *   SLACK_BOT_TOKEN : xoxb- で始まる Bot User OAuth Token
 *   SLACK_CHANNEL   : 通知先チャンネル（#名前 でも チャンネルID でも可）
 * ↑ コードに直書きせず、プロジェクトの「スクリプト プロパティ」に登録すること。
 */

/**
 * 異常判定のしきい値。運用しながら調整してください。
 */
const THRESHOLDS = {
  siteClickDropPct:        30,   // サイト全体のクリック数が前週比 -30% を超えて減ったら通知
  siteImpressionDropPct:   30,   // サイト全体の表示回数が前週比 -30% を超えて減ったら通知
  positionWorsen:          3.0,  // サイト全体の平均掲載順位が前週比で +3.0 以上悪化したら通知
  minClicksToAlert:        20,   // 元のクリック数がこれ未満のサイトは全体急落判定をスキップ
  minImpressionsToAlert:   200,  // 元の表示回数がこれ未満のサイトは全体急落判定をスキップ

  minRewriteImpressions:   300,  // リライト候補に出す最低表示回数
  minNearWinImpressions:   500,  // 4〜20位の伸びしろ候補に出す最低表示回数
  minPagePrevClicks:       10,   // 落ち込み判定に使う前週クリック数
  minPagePrevImpressions:  300,  // 落ち込み判定に使う前週表示回数
  pageDropPct:             40,   // ページ単位でクリック/表示が -40% 以上なら落ち込み候補
  disappearedDropPct:      90,   // 表示が -90% 以上ならインデックス検査対象に優先追加
  minQueryImpressions:     80,   // クエリ単位の分析対象にする最低表示回数
  rankDropPositions:       5.0,  // クエリ順位がこれ以上悪化したら通知候補
  mobilePositionGap:       5.0,  // モバイル順位がPCよりこれ以上悪ければ通知候補
};

const ANALYSIS_OPTIONS = {
  searchType: 'web',
  countryFilter: 'jpn',            // 日本に絞る。全世界を見るなら空文字にする。
  analyticsPageSize: 25000,        // Search Analytics APIの1回あたり最大行数
  pageMaxRows: 50000,              // ページ別データ取得上限
  queryMaxRows: 50000,             // ページ×クエリ取得上限
  deviceMaxRows: 25000,            // ページ×デバイス取得上限
  rewriteLimit: 5,                 // Slackに出すリライト候補数
  declineLimit: 5,                 // Slackに出す落ち込みページ数
  rankDropLimit: 5,                // Slackに出す順位急落クエリ数
  queryDiffLimit: 5,               // Slackに出す新規/消失クエリ数
  deviceGapLimit: 5,               // Slackに出すデバイス差分ページ数
  indexAlertLimit: 5,              // Slackに出すインデックス要確認URL数
  maxUrlInspectionsPerSite: 8,     // URL Inspection APIの1サイトあたり検査数
  inspectIndexTargets: true,
  checkSitemaps: false,            // サイトマップエラー監視が必要ならtrue
};


// ============================================================
//  メイン処理
// ============================================================

/**
 * 全サイトをチェックして、異常があればSlack通知する。
 * トリガーから毎週呼ばれるのはこの関数。
 */
function checkNow() {
  const allAlerts = [];   // { siteName, issues[] } の配列
  const errors = [];      // 取得自体に失敗したサイトのメモ
  const noCandidates = []; // チェック済みだが通知候補がなかったサイト

  SITES.forEach(function (site) {
    try {
      const issues = inspectSite_(site);
      if (issues.length > 0) {
        allAlerts.push({ siteName: site.name, issues: issues });
      } else {
        noCandidates.push(site.name);
      }
    } catch (e) {
      errors.push(site.name + ': ' + e.message);
      Logger.log('【エラー】' + site.name + ' / ' + e.message);
    }
  });

  if (allAlerts.length === 0 && errors.length === 0) {
    Logger.log('分析候補なし。通知は送信しません。チェック対象: ' + SITES.length
      + ' / 候補なし: ' + noCandidates.join(', '));
    return;
  }

  postSlack_(buildSlackMessage_(allAlerts, errors));
  Logger.log('Slackに通知しました。チェック対象: ' + SITES.length
    + ' / 通知対象: ' + allAlerts.length
    + ' / 候補なし: ' + (noCandidates.length > 0 ? noCandidates.join(', ') : 'なし')
    + ' / 取得失敗: ' + errors.length);
}


/**
 * 1サイトを検査し、見つかった異常の配列を返す。
 * 異常がなければ空配列。
 */
function inspectSite_(site) {
  const issues = [];

  // --- 1) サイト全体の前週比チェック ---
  const periods = getComparePeriods_();
  const current  = fetchPerformanceTotals_(site.property, periods.thisStart, periods.thisEnd);
  const previous = fetchPerformanceTotals_(site.property, periods.prevStart, periods.prevEnd);

  // クリック数の急落
  if (previous.clicks >= THRESHOLDS.minClicksToAlert) {
    const drop = pctChange_(previous.clicks, current.clicks);
    if (drop <= -THRESHOLDS.siteClickDropPct) {
      issues.push('? サイト全体のクリック数が急落: '
        + previous.clicks + ' → ' + current.clicks
        + ' （' + drop + '%）');
    }
  }

  // 表示回数の急落
  if (previous.impressions >= THRESHOLDS.minImpressionsToAlert) {
    const drop = pctChange_(previous.impressions, current.impressions);
    if (drop <= -THRESHOLDS.siteImpressionDropPct) {
      issues.push('? サイト全体の表示回数が急落: '
        + previous.impressions + ' → ' + current.impressions
        + ' （' + drop + '%）');
    }
  }

  // 平均掲載順位の悪化（数値が大きい＝順位が下＝悪化）
  if (current.position > 0 && previous.position > 0) {
    const worsen = current.position - previous.position;
    if (worsen >= THRESHOLDS.positionWorsen) {
      issues.push('? 平均掲載順位が悪化: '
        + previous.position.toFixed(1) + '位 → ' + current.position.toFixed(1) + '位'
        + ' （' + (worsen > 0 ? '+' : '') + worsen.toFixed(1) + '）');
    }
  }

  // --- 2) ページ別のGSCデータからリライト候補と落ち込みを分析 ---
  const currentPages = fetchPagePerformance_(site.property, periods.thisStart, periods.thisEnd);
  const previousPages = fetchPagePerformance_(site.property, periods.prevStart, periods.prevEnd);
  const currentPageQueries = fetchPageQueryPerformance_(site.property, periods.thisStart, periods.thisEnd);
  const previousPageQueries = fetchPageQueryPerformance_(site.property, periods.prevStart, periods.prevEnd);
  const topQueryByPage = mergeTopQueryMaps_(
    getTopQueryByPage_(currentPageQueries),
    getTopQueryByPage_(previousPageQueries)
  );
  const pageAnalysis = analyzePages_(currentPages, previousPages, topQueryByPage);
  const queryAnalysis = analyzeQueries_(currentPageQueries, previousPageQueries);
  const currentPageDevices = fetchPageDevicePerformance_(site.property, periods.thisStart, periods.thisEnd);
  const deviceGaps = analyzeDeviceGaps_(currentPageDevices);

  if (queryAnalysis.rewriteCandidates.length > 0) {
    issues.push(formatRewriteCandidates_(queryAnalysis.rewriteCandidates));
  }
  if (pageAnalysis.decliningPages.length > 0) {
    issues.push(formatDecliningPages_(pageAnalysis.decliningPages));
  }
  if (queryAnalysis.rankDrops.length > 0) {
    issues.push(formatRankDrops_(queryAnalysis.rankDrops));
  }
  if (queryAnalysis.newQueries.length > 0 || queryAnalysis.lostQueries.length > 0) {
    issues.push(formatQueryDiffs_(queryAnalysis.newQueries, queryAnalysis.lostQueries));
  }
  if (deviceGaps.length > 0) {
    issues.push(formatDeviceGaps_(deviceGaps));
  }

  // --- 3) インデックス状態がおかしそうなURLをサンプル検査 ---
  let inspectionTargets = [];
  let indexIssues = [];
  if (ANALYSIS_OPTIONS.inspectIndexTargets) {
    inspectionTargets = buildInspectionTargets_(site, currentPages, previousPages, pageAnalysis, queryAnalysis);
    indexIssues = inspectIndexTargets_(site.property, inspectionTargets);
    if (indexIssues.length > 0) {
      issues.push(formatIndexIssues_(indexIssues));
    }
  }

  // --- 4) 必要な時だけサイトマップエラーも見る（通常はオフ） ---
  if (ANALYSIS_OPTIONS.checkSitemaps) {
    const sitemapIssues = inspectSitemaps_(site.property);
    if (sitemapIssues.length > 0) {
      issues.push('?️ サイトマップ要確認\n      ' + sitemapIssues.join('\n      '));
    }
  }

  logSiteAnalysisSummary_(site, periods, current, previous, {
    currentPages: currentPages,
    previousPages: previousPages,
    currentPageQueries: currentPageQueries,
    previousPageQueries: previousPageQueries,
    currentPageDevices: currentPageDevices,
    pageAnalysis: pageAnalysis,
    queryAnalysis: queryAnalysis,
    deviceGaps: deviceGaps,
    inspectionTargets: inspectionTargets,
    indexIssues: indexIssues,
    issueCount: issues.length,
  });

  return issues;
}


// ============================================================
//  Search Console API 呼び出し（UrlFetchApp で直接）
// ============================================================

const SC_API_BASE = 'https://www.googleapis.com/webmasters/v3';
const URL_INSPECTION_API = 'https://searchconsole.googleapis.com/v1/urlInspection/index:inspect';

/**
 * 指定期間の検索パフォーマンス合計（クリック・表示・順位）を取得。
 */
function fetchPerformanceTotals_(property, startDate, endDate) {
  const url = SC_API_BASE + '/sites/'
    + encodeURIComponent(property) + '/searchAnalytics/query';

  const payload = {
    startDate: startDate,
    endDate: endDate,
    dimensions: [],          // 集計なし＝全体合計が1行で返る
    dataState: 'final',
    type: ANALYSIS_OPTIONS.searchType,
    rowLimit: 1,
  };
  const countryFilter = buildCountryFilter_();
  if (countryFilter) {
    payload.dimensionFilterGroups = [countryFilter];
  }

  const res = UrlFetchApp.fetch(url, {
    method: 'post',
    contentType: 'application/json',
    headers: { Authorization: 'Bearer ' + ScriptApp.getOAuthToken() },
    payload: JSON.stringify(payload),
    muteHttpExceptions: true,
  });

  const code = res.getResponseCode();
  if (code !== 200) {
    throw new Error('検索パフォーマンス取得失敗 (HTTP ' + code + '): '
      + extractApiErrorMessage_(res));
  }

  const rows = (JSON.parse(res.getContentText()).rows) || [];
  if (rows.length === 0) {
    return { clicks: 0, impressions: 0, ctr: 0, position: 0 };
  }
  const r = rows[0];
  return {
    clicks:      r.clicks      || 0,
    impressions: r.impressions || 0,
    ctr:         r.ctr         || 0,
    position:    r.position    || 0,
  };
}

/**
 * ページ別の検索パフォーマンスを取得する。
 */
function fetchPagePerformance_(property, startDate, endDate) {
  return fetchSearchAnalyticsRows_(
    property,
    startDate,
    endDate,
    ['page'],
    ANALYSIS_OPTIONS.pageMaxRows
  ).map(function (row) {
    return toPageMetric_(row.keys[0], row);
  }).filter(function (row) {
    return row.page;
  });
}

/**
 * ページ×クエリの検索パフォーマンスを取得する。
 */
function fetchPageQueryPerformance_(property, startDate, endDate) {
  return fetchSearchAnalyticsRows_(
    property,
    startDate,
    endDate,
    ['page', 'query'],
    ANALYSIS_OPTIONS.queryMaxRows
  ).map(function (row) {
    return toPageQueryMetric_(row.keys[0], row.keys[1], row);
  }).filter(function (row) {
    return row.page && row.query;
  });
}

/**
 * ページ×デバイスの検索パフォーマンスを取得する。
 */
function fetchPageDevicePerformance_(property, startDate, endDate) {
  return fetchSearchAnalyticsRows_(
    property,
    startDate,
    endDate,
    ['page', 'device'],
    ANALYSIS_OPTIONS.deviceMaxRows
  ).map(function (row) {
    return {
      page: row.keys[0] || '',
      device: row.keys[1] || '',
      clicks: row.clicks,
      impressions: row.impressions,
      ctr: row.ctr,
      position: row.position,
    };
  }).filter(function (row) {
    return row.page && row.device;
  });
}

/**
 * ページごとの代表クエリを抽出する。
 */
function getTopQueryByPage_(rows) {
  const byPage = {};
  rows.forEach(function (row) {
    const positionBoost = Math.max(1, 25 - Math.min(Number(row.position || 25), 25));
    const score = Number(row.impressions || 0) * positionBoost;
    if (!byPage[row.page] || score > byPage[row.page].score) {
      byPage[row.page] = {
        query: row.query,
        clicks: row.clicks,
        impressions: row.impressions,
        ctr: row.ctr,
        position: row.position,
        score: score,
      };
    }
  });

  return byPage;
}

function mergeTopQueryMaps_(primary, fallback) {
  const merged = {};
  Object.keys(fallback || {}).forEach(function (page) {
    merged[page] = fallback[page];
  });
  Object.keys(primary || {}).forEach(function (page) {
    merged[page] = primary[page];
  });
  return merged;
}

/**
 * Search Analytics APIの汎用呼び出し。
 */
function fetchSearchAnalyticsRows_(property, startDate, endDate, dimensions, rowLimit) {
  const url = SC_API_BASE + '/sites/'
    + encodeURIComponent(property) + '/searchAnalytics/query';
  const rows = [];
  const maxRows = rowLimit || ANALYSIS_OPTIONS.analyticsPageSize;
  const pageSize = Math.min(ANALYSIS_OPTIONS.analyticsPageSize, maxRows);

  for (let startRow = 0; startRow < maxRows; startRow += pageSize) {
    const payload = {
      startDate: startDate,
      endDate: endDate,
      dimensions: dimensions,
      dataState: 'final',
      type: ANALYSIS_OPTIONS.searchType,
      rowLimit: pageSize,
      startRow: startRow,
    };
    const countryFilter = buildCountryFilter_();
    if (countryFilter) {
      payload.dimensionFilterGroups = [countryFilter];
    }

    const res = UrlFetchApp.fetch(url, {
      method: 'post',
      contentType: 'application/json',
      headers: { Authorization: 'Bearer ' + ScriptApp.getOAuthToken() },
      payload: JSON.stringify(payload),
      muteHttpExceptions: true,
    });

    const code = res.getResponseCode();
    if (code !== 200) {
      throw new Error('Search Analytics取得失敗 (HTTP ' + code + '): '
        + extractApiErrorMessage_(res));
    }

    const pageRows = (JSON.parse(res.getContentText()).rows || []).map(function (r) {
      return {
        keys: r.keys || [],
        clicks: Number(r.clicks || 0),
        impressions: Number(r.impressions || 0),
        ctr: Number(r.ctr || 0),
        position: Number(r.position || 0),
      };
    });

    rows.push.apply(rows, pageRows);
    if (pageRows.length < pageSize) break;
  }

  return rows;
}

function buildCountryFilter_() {
  if (!ANALYSIS_OPTIONS.countryFilter) return null;
  return {
    filters: [{
      dimension: 'country',
      operator: 'equals',
      expression: ANALYSIS_OPTIONS.countryFilter,
    }],
  };
}

/**
 * サイトに登録されたサイトマップ一覧を取得。
 * 各要素: { path, submitted, errors, warnings }
 */
function fetchSitemaps_(property) {
  const url = SC_API_BASE + '/sites/'
    + encodeURIComponent(property) + '/sitemaps';

  const res = UrlFetchApp.fetch(url, {
    method: 'get',
    headers: { Authorization: 'Bearer ' + ScriptApp.getOAuthToken() },
    muteHttpExceptions: true,
  });

  const code = res.getResponseCode();
  if (code !== 200) {
    throw new Error('サイトマップ取得失敗 (HTTP ' + code + '): '
      + extractApiErrorMessage_(res));
  }

  const sitemaps = (JSON.parse(res.getContentText()).sitemap) || [];
  return sitemaps.map(function (sm) {
    let submitted = 0;
    (sm.contents || []).forEach(function (c) {
      submitted += Number(c.submitted || 0);
    });
    return {
      path:      sm.path,
      submitted: submitted,
      errors:    Number(sm.errors   || 0),
      warnings:  Number(sm.warnings || 0),
    };
  });
}

/**
 * URL Inspection APIで代表URLのインデックス状態を確認する。
 */
function fetchUrlInspection_(property, inspectionUrl) {
  const res = UrlFetchApp.fetch(URL_INSPECTION_API, {
    method: 'post',
    contentType: 'application/json',
    headers: { Authorization: 'Bearer ' + ScriptApp.getOAuthToken() },
    payload: JSON.stringify({
      inspectionUrl: inspectionUrl,
      siteUrl: property,
      languageCode: 'ja-JP',
    }),
    muteHttpExceptions: true,
  });

  const code = res.getResponseCode();
  if (code !== 200) {
    throw new Error('URL Inspection取得失敗 (HTTP ' + code + '): '
      + extractApiErrorMessage_(res));
  }

  const body = JSON.parse(res.getContentText() || '{}');
  const indexStatus = (((body.inspectionResult || {}).indexStatusResult) || {});
  return {
    url: inspectionUrl,
    verdict: indexStatus.verdict || '',
    coverageState: indexStatus.coverageState || '',
    robotsTxtState: indexStatus.robotsTxtState || '',
    indexingState: indexStatus.indexingState || '',
    pageFetchState: indexStatus.pageFetchState || '',
    lastCrawlTime: indexStatus.lastCrawlTime || '',
    googleCanonical: indexStatus.googleCanonical || '',
    userCanonical: indexStatus.userCanonical || '',
  };
}

function inspectSitemaps_(property) {
  const issues = [];
  fetchSitemaps_(property).forEach(function (sm) {
    if (Number(sm.errors) > 0) {
      issues.push('エラー: ' + sm.path + '（' + sm.errors + '件）');
    }
    if (Number(sm.warnings) > 0) {
      issues.push('警告: ' + sm.path + '（' + sm.warnings + '件）');
    }
  });
  return issues;
}


// ============================================================
//  期間・計算ユーティリティ
// ============================================================

/**
 * 比較する2つの期間を返す。
 * GSCのデータは数日遅れるため、3日前を基準に直近7日と
 * その前の7日を比較する。
 */
function getComparePeriods_() {
  const tz = Session.getScriptTimeZone();
  const fmt = function (d) { return Utilities.formatDate(d, tz, 'yyyy-MM-dd'); };
  const dayMs = 24 * 60 * 60 * 1000;

  const base = new Date();
  base.setTime(base.getTime() - 3 * dayMs);  // 3日前を末尾に

  const thisEnd   = new Date(base.getTime());
  const thisStart = new Date(base.getTime() - 6 * dayMs);
  const prevEnd   = new Date(base.getTime() - 7 * dayMs);
  const prevStart = new Date(base.getTime() - 13 * dayMs);

  return {
    thisStart: fmt(thisStart), thisEnd: fmt(thisEnd),
    prevStart: fmt(prevStart), prevEnd: fmt(prevEnd),
  };
}

/** 変化率（%）。oldVal→newVal。マイナスが減少。 */
function pctChange_(oldVal, newVal) {
  if (oldVal === 0) return 0;
  return Math.round(((newVal - oldVal) / oldVal) * 100);
}

function toPageMetric_(page, row) {
  return {
    page: page || '',
    clicks: Number(row.clicks || 0),
    impressions: Number(row.impressions || 0),
    ctr: Number(row.ctr || 0),
    position: Number(row.position || 0),
  };
}

function toPageQueryMetric_(page, query, row) {
  return {
    page: page || '',
    query: query || '',
    key: makePageQueryKey_(page, query),
    clicks: Number(row.clicks || 0),
    impressions: Number(row.impressions || 0),
    ctr: Number(row.ctr || 0),
    position: Number(row.position || 0),
  };
}

function emptyPageMetric_(page) {
  return { page: page || '', clicks: 0, impressions: 0, ctr: 0, position: 0 };
}

function emptyPageQueryMetric_(page, query) {
  return {
    page: page || '',
    query: query || '',
    key: makePageQueryKey_(page, query),
    clicks: 0,
    impressions: 0,
    ctr: 0,
    position: 0,
  };
}

function mapByPage_(rows) {
  const map = {};
  rows.forEach(function (row) {
    if (row.page) map[row.page] = row;
  });
  return map;
}

function mapByPageQuery_(rows) {
  const map = {};
  rows.forEach(function (row) {
    if (row.key) map[row.key] = row;
  });
  return map;
}

function makePageQueryKey_(page, query) {
  return String(page || '') + '\n' + String(query || '');
}

/**
 * ページ単位のリライト候補と落ち込みページを抽出する。
 */
function analyzePages_(currentPages, previousPages, topQueryByPage) {
  const previousByPage = mapByPage_(previousPages);
  const currentByPage = mapByPage_(currentPages);
  const declineByPage = {};

  currentPages.forEach(function (cur) {
    const prev = previousByPage[cur.page] || emptyPageMetric_(cur.page);
    addDeclineCandidate_(declineByPage, cur, prev, topQueryByPage[cur.page] || null);
  });

  previousPages.forEach(function (prev) {
    const cur = currentByPage[prev.page] || emptyPageMetric_(prev.page);
    addDeclineCandidate_(declineByPage, cur, prev, topQueryByPage[prev.page] || null);
  });

  const decliningPages = Object.keys(declineByPage).map(function (page) {
    return declineByPage[page];
  }).sort(function (a, b) {
    return b.score - a.score;
  }).slice(0, ANALYSIS_OPTIONS.declineLimit);

  return {
    decliningPages: decliningPages,
  };
}

function analyzeQueries_(currentRows, previousRows) {
  const previousByKey = mapByPageQuery_(previousRows);
  const currentByKey = mapByPageQuery_(currentRows);
  const rewriteCandidates = [];
  const rankDrops = [];
  const newQueries = [];
  const lostQueries = [];

  currentRows.forEach(function (cur) {
    const prev = previousByKey[cur.key] || emptyPageQueryMetric_(cur.page, cur.query);
    const ctrPct = cur.ctr * 100;
    const expectedCtr = getExpectedCtrPct_(cur.position);
    const reasons = [];
    let score = 0;

    if (
      cur.impressions >= THRESHOLDS.minRewriteImpressions &&
      cur.position > 0 &&
      cur.position <= 10 &&
      ctrPct < expectedCtr
    ) {
      const lostClicks = Math.max(0, Math.round(cur.impressions * ((expectedCtr - ctrPct) / 100)));
      reasons.push('CTR低め ' + formatPct_(ctrPct) + '（順位目安 ' + formatPct_(expectedCtr) + ' / 推定取りこぼし ' + lostClicks + 'クリック）');
      score += lostClicks * 100 + cur.impressions;
    }

    if (
      cur.impressions >= THRESHOLDS.minNearWinImpressions &&
      cur.position >= 8 &&
      cur.position <= 20
    ) {
      reasons.push('8〜20位で伸びしろあり');
      score += Math.round(cur.impressions * Math.max(1, 21 - cur.position));
    }

    if (reasons.length > 0) {
      rewriteCandidates.push({
        page: cur.page,
        query: cur.query,
        current: cur,
        previous: prev,
        reasons: reasons,
        score: score,
      });
    }

    if (
      prev.impressions >= THRESHOLDS.minQueryImpressions &&
      prev.position > 0 &&
      cur.position > 0 &&
      (cur.position - prev.position) >= THRESHOLDS.rankDropPositions
    ) {
      rankDrops.push({
        page: cur.page,
        query: cur.query,
        current: cur,
        previous: prev,
        positionDrop: cur.position - prev.position,
        score: prev.impressions * (cur.position - prev.position),
      });
    }

    if (
      cur.impressions >= THRESHOLDS.minQueryImpressions &&
      prev.impressions === 0
    ) {
      newQueries.push({
        page: cur.page,
        query: cur.query,
        current: cur,
        score: cur.impressions,
      });
    }
  });

  previousRows.forEach(function (prev) {
    const cur = currentByKey[prev.key] || emptyPageQueryMetric_(prev.page, prev.query);
    if (
      prev.impressions >= THRESHOLDS.minQueryImpressions &&
      cur.impressions === 0
    ) {
      lostQueries.push({
        page: prev.page,
        query: prev.query,
        previous: prev,
        score: prev.impressions,
      });
    }
  });

  return {
    rewriteCandidates: rewriteCandidates.sort(sortByScore_).slice(0, ANALYSIS_OPTIONS.rewriteLimit),
    rankDrops: rankDrops.sort(sortByScore_).slice(0, ANALYSIS_OPTIONS.rankDropLimit),
    newQueries: newQueries.sort(sortByScore_).slice(0, ANALYSIS_OPTIONS.queryDiffLimit),
    lostQueries: lostQueries.sort(sortByScore_).slice(0, ANALYSIS_OPTIONS.queryDiffLimit),
  };
}

function analyzeDeviceGaps_(rows) {
  const byPage = {};
  rows.forEach(function (row) {
    if (!byPage[row.page]) byPage[row.page] = {};
    byPage[row.page][String(row.device).toLowerCase()] = row;
  });

  return Object.keys(byPage).map(function (page) {
    const group = byPage[page];
    const mobile = group.mobile;
    const desktop = group.desktop;
    if (!mobile || !desktop) return null;
    const gap = mobile.position - desktop.position;
    if (
      mobile.impressions < THRESHOLDS.minPagePrevImpressions ||
      gap < THRESHOLDS.mobilePositionGap
    ) {
      return null;
    }
    return {
      page: page,
      mobile: mobile,
      desktop: desktop,
      gap: gap,
      score: mobile.impressions * gap,
    };
  }).filter(function (item) {
    return item !== null;
  }).sort(sortByScore_).slice(0, ANALYSIS_OPTIONS.deviceGapLimit);
}

function sortByScore_(a, b) {
  return b.score - a.score;
}

function addDeclineCandidate_(declineByPage, cur, prev, topQuery) {
  if (!prev || !prev.page) return;
  const clickDrop = pctChange_(prev.clicks, cur.clicks);
  const impressionDrop = pctChange_(prev.impressions, cur.impressions);
  const enoughClicks = prev.clicks >= THRESHOLDS.minPagePrevClicks;
  const enoughImpressions = prev.impressions >= THRESHOLDS.minPagePrevImpressions;
  const isDrop =
    (enoughClicks && clickDrop <= -THRESHOLDS.pageDropPct) ||
    (enoughImpressions && impressionDrop <= -THRESHOLDS.pageDropPct);

  if (!isDrop) return;

  const lostClicks = Math.max(0, prev.clicks - cur.clicks);
  const lostImpressions = Math.max(0, prev.impressions - cur.impressions);
  const score = lostClicks * 30 + lostImpressions;
  const existing = declineByPage[prev.page];
  if (existing && existing.score >= score) return;

  declineByPage[prev.page] = {
    page: prev.page,
    current: cur,
    previous: prev,
    topQuery: topQuery,
    clickDrop: clickDrop,
    impressionDrop: impressionDrop,
    score: score,
    disappeared: enoughImpressions && impressionDrop <= -THRESHOLDS.disappearedDropPct,
  };
}

function getExpectedCtrPct_(position) {
  if (!position || position <= 0) return 0;
  if (position <= 1.5) return 30.0;
  if (position <= 2.5) return 20.0;
  if (position <= 3.5) return 15.0;
  if (position <= 4.5) return 10.0;
  if (position <= 5.5) return 8.0;
  if (position <= 7.5) return 5.0;
  if (position <= 10.5) return 3.0;
  if (position <= 20) return 1.0;
  return 0.5;
}

/**
 * 代表URLの設定がなければ、Search ConsoleプロパティからトップページURLを推定する。
 */
function getSampleUrls_(site) {
  if (site.sampleUrls && site.sampleUrls.length > 0) {
    return site.sampleUrls;
  }
  if (site.property.indexOf('sc-domain:') === 0) {
    return ['https://' + site.property.replace('sc-domain:', '') + '/'];
  }
  if (/^https?:\/\//.test(site.property)) {
    return [site.property];
  }
  return [];
}

function buildInspectionTargets_(site, currentPages, previousPages, pageAnalysis, queryAnalysis) {
  const targets = [];

  getSampleUrls_(site).forEach(function (url) {
    targets.push(url);
  });

  pageAnalysis.decliningPages.forEach(function (item) {
    if (item.disappeared || item.current.impressions === 0) {
      targets.push(item.page);
    }
  });

  queryAnalysis.rewriteCandidates.slice(0, 2).forEach(function (item) {
    targets.push(item.page);
  });

  currentPages.slice().sort(function (a, b) {
    return b.impressions - a.impressions;
  }).slice(0, 2).forEach(function (item) {
    targets.push(item.page);
  });

  return uniqueUrls_(targets).slice(0, ANALYSIS_OPTIONS.maxUrlInspectionsPerSite);
}

function inspectIndexTargets_(property, urls) {
  const issues = [];
  urls.forEach(function (url) {
    if (issues.length >= ANALYSIS_OPTIONS.indexAlertLimit) return;
    try {
      const result = fetchUrlInspection_(property, url);
      const reasons = getIndexIssueReasons_(result);
      if (reasons.length > 0) {
        issues.push({
          url: url,
          reasons: reasons,
          result: result,
        });
      }
    } catch (e) {
      issues.push({
        url: url,
        reasons: ['検査失敗: ' + e.message],
        result: null,
      });
    }
  });
  return issues;
}

function getIndexIssueReasons_(result) {
  const reasons = [];

  if (!result.verdict) {
    reasons.push('判定不明');
  } else if (result.verdict !== 'PASS') {
    reasons.push('判定: ' + result.verdict);
  }

  if (result.coverageState) {
    const state = result.coverageState;
    if (
      /not indexed|excluded|blocked|error|alternate|duplicate|noindex|検出|未登録|除外|ブロック/i.test(state)
    ) {
      reasons.push(state);
    }
  }

  if (result.robotsTxtState && result.robotsTxtState !== 'ALLOWED') {
    reasons.push('robots.txt: ' + result.robotsTxtState);
  }
  if (result.indexingState && result.indexingState !== 'INDEXING_ALLOWED') {
    reasons.push('indexing: ' + result.indexingState);
  }
  if (
    result.pageFetchState &&
    result.pageFetchState !== 'SUCCESSFUL' &&
    result.pageFetchState !== 'PAGE_FETCH_STATE_UNSPECIFIED'
  ) {
    reasons.push('取得: ' + result.pageFetchState);
  }

  if (
    result.googleCanonical &&
    result.userCanonical &&
    normalizeUrlForCompare_(result.googleCanonical) !== normalizeUrlForCompare_(result.userCanonical)
  ) {
    reasons.push('Google正規URLが別: ' + result.googleCanonical);
  }

  return uniqueStrings_(reasons);
}

function uniqueUrls_(urls) {
  const seen = {};
  const out = [];
  urls.forEach(function (url) {
    if (!url || !/^https?:\/\//.test(url)) return;
    const key = normalizeUrlForCompare_(url);
    if (seen[key]) return;
    seen[key] = true;
    out.push(url);
  });
  return out;
}

function uniqueStrings_(values) {
  const seen = {};
  const out = [];
  values.forEach(function (value) {
    if (!value || seen[value]) return;
    seen[value] = true;
    out.push(value);
  });
  return out;
}

function normalizeUrlForCompare_(url) {
  return String(url || '').trim().replace(/#.*$/, '')
    .replace(/^(https?):\/\/([^/?#]+)/i, function (_, scheme, host) {
      return scheme.toLowerCase() + '://' + host.toLowerCase();
    });
}

/**
 * Google APIのJSONエラーから人間が読めるmessageだけを取り出す。
 */
function extractApiErrorMessage_(res) {
  const text = res.getContentText() || '';
  try {
    const body = JSON.parse(text);
    if (body.error && body.error.message) {
      return body.error.message;
    }
  } catch (e) {
    // JSONではない場合は下の短縮テキストを使う。
  }
  return text.slice(0, 300);
}

function formatRewriteCandidates_(candidates) {
  const lines = candidates.slice(0, ANALYSIS_OPTIONS.rewriteLimit).map(function (item, index) {
    const cur = item.current;
    const prev = item.previous;
    const trendText = prev.impressions > 0
      ? '\n         前週比: 表示 ' + formatNumber_(prev.impressions) + ' → ' + formatNumber_(cur.impressions)
        + ' / クリック ' + formatNumber_(prev.clicks) + ' → ' + formatNumber_(cur.clicks)
      : '';

    return (index + 1) + '. ' + item.page
      + '\n         対象クエリ: "' + item.query + '"'
      + '\n         理由: ' + item.reasons.join(' / ')
      + '\n         現在: 表示 ' + formatNumber_(cur.impressions)
      + ' / クリック ' + formatNumber_(cur.clicks)
      + ' / CTR ' + formatPct_(cur.ctr * 100)
      + ' / 順位 ' + formatPosition_(cur.position)
      + trendText
      + '\n         提案: タイトル・導入文・見出しを主クエリの検索意図に寄せて更新';
  });

  return '? リライト候補（優先' + lines.length + '件）\n      ' + lines.join('\n      ');
}

function formatDecliningPages_(items) {
  const lines = items.slice(0, ANALYSIS_OPTIONS.declineLimit).map(function (item, index) {
    const cur = item.current;
    const prev = item.previous;
    const queryText = item.topQuery ? '\n         主クエリ: "' + item.topQuery.query + '"' : '';
    const indexText = item.disappeared ? '\n         メモ: 表示がほぼ消えているのでインデックス検査対象に追加' : '';

    return (index + 1) + '. ' + item.page
      + '\n         表示: ' + formatNumber_(prev.impressions) + ' → ' + formatNumber_(cur.impressions)
      + '（' + formatSignedPct_(item.impressionDrop) + '）'
      + ' / クリック: ' + formatNumber_(prev.clicks) + ' → ' + formatNumber_(cur.clicks)
      + '（' + formatSignedPct_(item.clickDrop) + '）'
      + queryText
      + indexText;
  });

  return '? 落ち込みページ（前週比）\n      ' + lines.join('\n      ');
}

function formatRankDrops_(items) {
  const lines = items.slice(0, ANALYSIS_OPTIONS.rankDropLimit).map(function (item, index) {
    return (index + 1) + '. ' + item.page
      + '\n         クエリ: "' + item.query + '"'
      + '\n         順位: ' + formatPosition_(item.previous.position) + ' → ' + formatPosition_(item.current.position)
      + '（+' + item.positionDrop.toFixed(1) + '）'
      + ' / 表示: ' + formatNumber_(item.previous.impressions) + ' → ' + formatNumber_(item.current.impressions);
  });
  return '? 順位急落クエリ\n      ' + lines.join('\n      ');
}

function formatQueryDiffs_(newQueries, lostQueries) {
  const blocks = [];
  if (newQueries.length > 0) {
    blocks.push('新規クエリ\n      ' + newQueries.slice(0, ANALYSIS_OPTIONS.queryDiffLimit).map(function (item, index) {
      return (index + 1) + '. "' + item.query + '"'
        + ' / 表示 ' + formatNumber_(item.current.impressions)
        + ' / 順位 ' + formatPosition_(item.current.position)
        + '\n         ' + item.page;
    }).join('\n      '));
  }
  if (lostQueries.length > 0) {
    blocks.push('消失クエリ\n      ' + lostQueries.slice(0, ANALYSIS_OPTIONS.queryDiffLimit).map(function (item, index) {
      return (index + 1) + '. "' + item.query + '"'
        + ' / 前週表示 ' + formatNumber_(item.previous.impressions)
        + ' / 前週順位 ' + formatPosition_(item.previous.position)
        + '\n         ' + item.page;
    }).join('\n      '));
  }
  return '? 新規/消失クエリ\n      ' + blocks.join('\n      ');
}

function formatDeviceGaps_(items) {
  const lines = items.slice(0, ANALYSIS_OPTIONS.deviceGapLimit).map(function (item, index) {
    return (index + 1) + '. ' + item.page
      + '\n         PC ' + formatPosition_(item.desktop.position)
      + ' / モバイル ' + formatPosition_(item.mobile.position)
      + '（差 +' + item.gap.toFixed(1) + '）'
      + ' / モバイル表示 ' + formatNumber_(item.mobile.impressions);
  });
  return '? モバイルだけ順位が弱いページ\n      ' + lines.join('\n      ');
}

function formatIndexIssues_(items) {
  const lines = items.slice(0, ANALYSIS_OPTIONS.indexAlertLimit).map(function (item, index) {
    return (index + 1) + '. ' + item.url
      + '\n         理由: ' + item.reasons.join(' / ');
  });
  return '? インデックス要確認URL\n      ' + lines.join('\n      ');
}

function formatNumber_(value) {
  return Math.round(Number(value || 0)).toLocaleString('ja-JP');
}

function formatPct_(value) {
  return Number(value || 0).toFixed(1) + '%';
}

function formatSignedPct_(value) {
  const rounded = Math.round(Number(value || 0));
  return (rounded > 0 ? '+' : '') + rounded + '%';
}

function formatPosition_(value) {
  return Number(value || 0).toFixed(1) + '位';
}

function logSiteAnalysisSummary_(site, periods, current, previous, summary) {
  const limitNotes = [];
  if (summary.currentPages.length >= ANALYSIS_OPTIONS.pageMaxRows) {
    limitNotes.push('当週ページ行');
  }
  if (summary.previousPages.length >= ANALYSIS_OPTIONS.pageMaxRows) {
    limitNotes.push('前週ページ行');
  }
  if (summary.currentPageQueries.length >= ANALYSIS_OPTIONS.queryMaxRows) {
    limitNotes.push('当週ページ×クエリ行');
  }
  if (summary.previousPageQueries.length >= ANALYSIS_OPTIONS.queryMaxRows) {
    limitNotes.push('前週ページ×クエリ行');
  }
  if (summary.currentPageDevices.length >= ANALYSIS_OPTIONS.deviceMaxRows) {
    limitNotes.push('ページ×デバイス行');
  }

  Logger.log('【分析サマリー】' + site.name
    + ' / 期間: ' + periods.thisStart + '〜' + periods.thisEnd
    + ' vs ' + periods.prevStart + '〜' + periods.prevEnd
    + ' / 条件: searchType=' + ANALYSIS_OPTIONS.searchType
    + ', country=' + (ANALYSIS_OPTIONS.countryFilter || 'all')
    + ' / 全体: クリック ' + formatNumber_(previous.clicks) + '→' + formatNumber_(current.clicks)
    + ', 表示 ' + formatNumber_(previous.impressions) + '→' + formatNumber_(current.impressions)
    + ', 順位 ' + formatPosition_(previous.position) + '→' + formatPosition_(current.position)
    + ' / 取得行: ページ ' + summary.currentPages.length + '/' + summary.previousPages.length
    + ', ページ×クエリ ' + summary.currentPageQueries.length + '/' + summary.previousPageQueries.length
    + ', ページ×デバイス ' + summary.currentPageDevices.length
    + ' / 候補: リライト ' + summary.queryAnalysis.rewriteCandidates.length
    + ', 落ち込み ' + summary.pageAnalysis.decliningPages.length
    + ', 順位急落 ' + summary.queryAnalysis.rankDrops.length
    + ', 新規 ' + summary.queryAnalysis.newQueries.length
    + ', 消失 ' + summary.queryAnalysis.lostQueries.length
    + ', モバイル差 ' + summary.deviceGaps.length
    + ', インデックス要確認 ' + summary.indexIssues.length + '/' + summary.inspectionTargets.length
    + ', Slack項目 ' + summary.issueCount
    + (limitNotes.length > 0 ? ' / 注意: ' + limitNotes.join(', ') + 'が取得上限に到達' : ''));
}


// ============================================================
//  Slack 通知
// ============================================================

/**
 * 異常情報からSlack用メッセージ文字列を組み立てる。
 */
function buildSlackMessage_(allAlerts, errors) {
  const tz = Session.getScriptTimeZone();
  const today = Utilities.formatDate(new Date(), tz, 'yyyy/MM/dd');

  let msg = '? *GSC分析レポート* （' + today + '）\n';

  allAlerts.forEach(function (a) {
    msg += '\n*■ ' + a.siteName + '*\n';
    a.issues.forEach(function (issue) {
      msg += '   • ' + issue + '\n';
    });
  });

  if (errors.length > 0) {
    msg += '\n*■ チェックに失敗したサイト*\n';
    errors.forEach(function (e) {
      msg += '   • ' + e + '\n';
    });
  }

  return msg;
}

/** Slackに投稿する（Bot Token / chat.postMessage 方式）。 */
function postSlack_(text) {
  const props = PropertiesService.getScriptProperties();
  const token   = props.getProperty('SLACK_BOT_TOKEN');
  const channel = props.getProperty('SLACK_CHANNEL');

  if (!token) {
    throw new Error('スクリプトプロパティ SLACK_BOT_TOKEN が設定されていません。');
  }
  if (!channel) {
    throw new Error('スクリプトプロパティ SLACK_CHANNEL が設定されていません。');
  }

  const res = UrlFetchApp.fetch('https://slack.com/api/chat.postMessage', {
    method: 'post',
    contentType: 'application/json; charset=utf-8',
    headers: { Authorization: 'Bearer ' + token },
    payload: JSON.stringify({
      channel: channel,
      text: text,
      unfurl_links: false,  // URLのプレビュー展開を抑制
    }),
    muteHttpExceptions: true,
  });

  // Slack APIは HTTP 200 でも body の ok:false でエラーを返すので両方チェック
  const body = JSON.parse(res.getContentText() || '{}');
  if (res.getResponseCode() !== 200 || body.ok !== true) {
    throw new Error('Slack投稿失敗: ' + (body.error || res.getContentText()));
  }
}


// ============================================================
//  トリガー設定 / テスト用
// ============================================================

/**
 * 毎週月曜8時の自動実行トリガーを登録する（最初に一度だけ実行）。
 * 既存の同名トリガーがあれば作り直す。
 */
function setupTrigger() {
  ScriptApp.getProjectTriggers().forEach(function (t) {
    if (t.getHandlerFunction() === 'checkNow') {
      ScriptApp.deleteTrigger(t);
    }
  });
  ScriptApp.newTrigger('checkNow')
    .timeBased()
    .onWeekDay(ScriptApp.WeekDay.MONDAY)
    .atHour(8)
    .create();
  Logger.log('毎週月曜8時のトリガーを登録しました。');
}

/**
 * 通知のテスト用。実際の異常有無に関わらず、
 * いま取得できる数値をSlackに送って配線を確認する。
 */
function testNotify() {
  const lines = [];
  SITES.forEach(function (site) {
    try {
      const p = getComparePeriods_();
      const cur = fetchPerformanceTotals_(site.property, p.thisStart, p.thisEnd);
      lines.push('■ ' + site.name + '\n   今週: クリック ' + cur.clicks
        + ' / 表示 ' + cur.impressions
        + ' / 順位 ' + cur.position.toFixed(1));
    } catch (e) {
      lines.push('■ ' + site.name + '\n   取得エラー: ' + e.message);
    }
  });
  postSlack_('✅ *GSC監視ツール 接続テスト*\n\n' + lines.join('\n'));
  Logger.log('テスト通知を送信しました。');
}