const COMMAND_GET_PAGE_SPEED = '/command pagespeed';

const CHATWORK_API_TOKEN = PropertiesService.getScriptProperties().getProperty('CHATWORK_API_TOKEN');
const CHATWORK_API_BASE_URL = 'https://api.chatwork.com/v2';

const PAGE_SPEED_INSIGHTS_API_KEY = PropertiesService.getScriptProperties().getProperty('PAGESPEED_INSIGHTS_API_KEY');
const PAGE_SPEED_INSIGHTS_API_BASE_URL = 'https://www.googleapis.com/pagespeedonline/v5/runPagespeed';

/**
 * Webhook受信時の処理を行う
 * @param {Object} e - イベント オブジェクト
 * @see {@link https://developers.google.com/apps-script/guides/web?hl=ja#request_parameters | ウェブアプリ  |  Apps Script  |  Google for Developers}
 */
function doPost(e) {
  const contentsJson = JSON.parse(e.postData.contents);
  const message = contentsJson.webhook_event.body;

  if (!message.startsWith(COMMAND_GET_PAGE_SPEED)) {
    return;
  }

  const pageSpeedInsights = new PageSpeedInsightsApiClient(PAGE_SPEED_INSIGHTS_API_KEY, PAGE_SPEED_INSIGHTS_API_BASE_URL);

  const chatworkPostRoomId = PropertiesService.getScriptProperties().getProperty('CHATWORK_ROOM_ID_MYCHAT');
  const chatwork = new ChatworkApiClient(CHATWORK_API_TOKEN, CHATWORK_API_BASE_URL);

  const speedTestUrls = message.split('\n').filter((line) => !line.includes(COMMAND_GET_PAGE_SPEED));

  const pageSpeedInsightsStrategy = ['desktop', 'mobile'];

  try {
    const postMessage = speedTestUrls.map((speedTestUrl) => {
      const pageSpeedInsightsResultText = pageSpeedInsightsStrategy.map((strategy) => {
        try {
          if (!UrlUtils.isValidUrl(speedTestUrl)) {
            throw new Error(`Invalid URL: ${speedTestUrl}`);
          }
          const pageSpeedJson = pageSpeedInsights.fetchResult(speedTestUrl, strategy, 'lighthouseResult.audits,lighthouseResult.categories.performance.score');
          const audit = PageSpeedResultFormatter.getAudits(pageSpeedJson);
          const performance = PageSpeedResultFormatter.getPerformance(pageSpeedJson);

          let contents = [`・${strategy}`, performance, audit].join('\n');
          let postMessage = ChatworkMessageFormatter.wrapWithCodeTags(contents);
          return postMessage;
        } catch (error) {
          let contents = [`・${strategy}`, error.message].join('\n');
          return ChatworkMessageFormatter.wrapWithCodeTags(contents);
        }
      }).join('\n');
      const urlText = `テストページURL: ${speedTestUrl}`;

      let postMessage = ChatworkMessageFormatter.wrapWithInfoTags(
        `PageSpeed Insights`,
        [urlText, pageSpeedInsightsResultText].join('\n')
      );
      return postMessage;
    }).join('\n');

    chatwork.postMessage(chatworkPostRoomId, postMessage);
  } catch (error) {
    const errorMessage = ChatworkMessageFormatter.wrapWithCodeTags(`Error - ${error.message}`);
    chatwork.postMessage(chatworkPostRoomId, errorMessage);
  }
}

class PageSpeedInsightsApiClient {
  /**
   * @param {string} apiKey
   * @param {string} baseUrl
   */
  constructor(apiKey, baseUrl) {
    this.apiKey = apiKey;
    this.baseUrl = baseUrl;
  }

  /**
   * 診断結果を取得
   *
   * @param {string} speedTestUrl - パフォーマンスを計測したいページのURL
   * @param {string} strategy - 使用する分析戦略（デスクトップまたはモバイル）。デスクトップがデフォルト
   * @param {string} fields - 取得したいフィールド
   *   lighthouseResult.auditsについてはこれより下の階層を指定できないので注意
   * @returns {Object} PageSpeed Insights APIのレスポンスボディをJSON形式に変換したもの
   * @see {@link https://developers.google.com/speed/docs/insights/v5/reference/pagespeedapi/runpagespeed | Pagespeedapi: runpagespeed}
   */
  fetchResult(speedTestUrl, strategy = '', fields = '') {
    let params = {
      url: speedTestUrl,
      key: this.apiKey
    };

    if (strategy === 'desktop' || strategy === 'mobile') {
      params.strategy = strategy;
    }

    if (fields !== '') {
      params.fields = fields;
    }

    const apiUrl = UrlUtils.appendQueryToUrl(this.baseUrl, params);
    const options = {
      'method': 'get',
      'headers': {
        'Content-Type': 'application/json'
      }
    };

    try {
      const response = UrlFetchApp.fetch(apiUrl, options);
      if (response.getResponseCode() !== 200) {
        throw new Error(`PageSpeed Insights API request failed: status code ${response.getResponseCode()}`);
      }
      const responseBody = response.getContentText();
      const responseBodyJson = JSON.parse(responseBody);
      return responseBodyJson;
    } catch (error) {
      console.error("PageSpeed Insights API failed:", error);
      throw error;
    }
  }
}

class PageSpeedResultFormatter {
  /**
   * @param {Object} responseBodyJson
   * @return {string} 指標の評価まとめ
   */
  static getAudits(responseBodyJson) {
    const audits = responseBodyJson.lighthouseResult.audits;
    if (!audits) {
      throw new Error("Invalid Argument");
    }

    const metrics = [
      { text: "First Contentful Paint   : ", auditsKey: "first-contentful-paint", },
      { text: "Total Blocking Time      : ", auditsKey: "total-blocking-time", },
      { text: "Speed Index              : ", auditsKey: "speed-index", },
      { text: "Largest Contentful Paint : ", auditsKey: "largest-contentful-paint", },
      { text: "Cumulative Layout Shift  : ", auditsKey: "cumulative-layout-shift", },
    ];

    const results = metrics.map((metric) => {
      const scoreInt = Math.floor(parseFloat(audits[metric.auditsKey].score) * 100);
      const metricIcon = this.getMetricIcon(scoreInt);

      let metricText = `${metricIcon}${metric.text}${audits[metric.auditsKey].displayValue}`;
      return metricText;
    });

    return results.join('\n')
  }

  /**
   * @param {Object} responseBodyJson
   * @return {string} パフォーマンス
   */
  static getPerformance(responseBodyJson) {
    const categories = responseBodyJson.lighthouseResult.categories;
    if (!categories) {
      throw new Error("Invalid Argument");
    }

    const scoreInt = Math.floor(parseFloat(categories.performance.score) * 100);
    const metricIcon = this.getMetricIcon(scoreInt);
    const performance = `${metricIcon}Performance              : ${scoreInt}`;
    return performance;
  }

  /**
   * PageSpeed Insights の指標の評価値と対応するアイコンを返す
   *
   * @param {number} scoreInt - 指標の評価値
   * @returns {string} アイコン
   */
  static getMetricIcon(scoreInt) {
    return scoreInt < 50 ? '🔺' : scoreInt < 90 ? '🟨' : '🟢';
  }
}

class ChatworkApiClient {
  /**
   * @param {string} apiToken
   * @param {string} baseUrl
   */
  constructor(apiToken, baseUrl) {
    this.apiToken = apiToken;
    this.baseUrl = baseUrl;
  }

  /**
   * チャットにメッセージを投稿する
   *
   * @param {string} roomId - メッセージを投稿するルームのID
   * @param {string} message - 投稿するメッセージ内容
   * @param {number} [selfUnread=0] - 自分の未読フラグ（0: 既読、1: 未読）
   * @returns {void}
   * @see {@link https://developer.chatwork.com/reference/post-rooms-room_id-messages | チャットにメッセージを投稿する}
   */
  postMessage(roomId, message, selfUnread = 0) {
    const endpointUrl = this.baseUrl + "/rooms/" + roomId + "/messages";

    const options = {
      method: "POST",
      headers: {
        'X-ChatWorkToken': this.apiToken
      },
      payload: {
        body: message,
        self_unread: selfUnread.toString()
      }
    };

    try {
      const response = UrlFetchApp.fetch(endpointUrl, options);
      if (response.getResponseCode() !== 200) {
        throw new Error(`Chatwork API request failed: status code ${response.getResponseCode()}`);
      }
    } catch (error) {
      console.error("Chatwork API post message failed:", error);
      throw error;
    }
  }
}

class ChatworkMessageFormatter {
  /**
   * メッセージをcodeタグで囲む
   *
   * @param {string} message - メッセージ
   * @returns {string} 整形後の文字列
   */
  static wrapWithCodeTags(message) {
    return `[code]${message}[/code]`;
  }

  /**
   * メッセージをinfoタグ、titleタグで整形する
   *
   * @param {string} message - メッセージ
   * @returns {string} 整形後の文字列
   */
  static wrapWithInfoTags(title = '', info) {
    let message = '';
    if (title !== '') {
      message += `[title]${title}[/title]`;
    }
    message += `${info}`;
    return `[info]${message}[/info]`;
  }
}

class UrlUtils {
  /**
   * @param {string} baseUrl - ベースURL
   * @param {Object} queryObject - クエリパラメータ生成用
   * @return {string} URL
   */
  static appendQueryToUrl(baseUrl, queryObject) {
    const queryString = Object.entries(queryObject)
      .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
      .join('&');

    return `${baseUrl}?${queryString}`;
  }

  /**
   * @param {string} url - 検証するURL
   * @return {boolean}
   */
  static isValidUrl(url) {
    try {
      const response = UrlFetchApp.fetch(url, { muteHttpExceptions: true });
      const responseCode = response.getResponseCode();
      return responseCode >= 200 && responseCode < 300;
    } catch (error) {
      return false;
    }
  }
}

"lighthouseResult": {
..........
	"audits": {
		"network-requests": {
..........
		},
		"non-composited-animations": {
..........
		},
..........
	},
}