คู่มือสร้าง “ผู้ช่วย AI ประจำทีม” ในกลุ่ม LINE

const APP = {
  timezone: 'Asia/Bangkok',
  replyPrefixes: ['น้องเจน', '@น้องเจน', '/assistant'],
  maxRowsForAI: 200
};

function doGet() {
  return jsonOutput_({ ok: true, service: 'LINE AI Team Assistant' });
}

function doPost(e) {
  try {
    const cfg = getConfig_();

    // ตัวป้องกันพื้นฐานสำหรับต้นแบบ ไม่ใช่ตัวแทนการตรวจ X-Line-Signature
    if (!e || !e.parameter || e.parameter.key !== cfg.webhookSecret) {
      return jsonOutput_({ ok: false, error: 'unauthorized' });
    }

    const body = JSON.parse(e.postData.contents || '{}');
    const events = body.events || [];

    events.forEach(function(event) {
      try {
        processEvent_(event, cfg);
      } catch (err) {
        logEvent_(event, '', 'ERROR: ' + err.message);
      }
    });

    return jsonOutput_({ ok: true });
  } catch (err) {
    console.error(err.stack || err);
    return jsonOutput_({ ok: false, error: err.message });
  }
}

function processEvent_(event, cfg) {
  const source = event.source || {};
  const sourceId = source.groupId || source.roomId || source.userId || '';

  if (event.type === 'join') {
    logEvent_(event, '[BOT JOINED]', 'OK');
    if (event.replyToken) {
      replyLine_(event.replyToken,
        'สวัสดีค่ะ ฉันคือผู้ช่วยตารางเวร\nเรียกฉันด้วย “น้องเจน” แล้วตามด้วยคำถามได้เลย', cfg);
    }
    return;
  }

  if (event.type !== 'message' || !event.message || event.message.type !== 'text') {
    return;
  }

  const originalText = String(event.message.text || '').trim();
  logEvent_(event, originalText, 'RECEIVED');

  // ในกลุ่มให้ตอบเฉพาะเมื่อถูกเรียก ป้องกันบอตตอบทุกข้อความ
  if (source.type === 'group' || source.type === 'room') {
    if (!shouldRespond_(originalText)) return;
  }

  const question = cleanPrefix_(originalText);
  if (!question) {
    replyLine_(event.replyToken,
      'ลองถามว่า “น้องเจน พรุ่งนี้ใครอยู่เวรเช้า?”', cfg);
    return;
  }

  const schedule = readSchedule_();
  const context = scheduleToText_(schedule.slice(0, APP.maxRowsForAI));
  const prompt = buildPrompt_(question, context);

  let answer;
  if (cfg.aiProvider === 'openai') {
    answer = callOpenAI_(prompt, cfg);
  } else {
    answer = callGemini_(prompt, cfg);
  }

  replyLine_(event.replyToken, answer, cfg);
  logEvent_(event, originalText, 'REPLIED via ' + cfg.aiProvider);

  // sourceId ที่บันทึกใน Logs คือ Group ID สำหรับตั้งแจ้งเตือนอัตโนมัติ
  console.log('Source ID: ' + sourceId);
}

function shouldRespond_(text) {
  const normalized = String(text || '').trim().toLowerCase();
  return APP.replyPrefixes.some(function(prefix) {
    return normalized.indexOf(prefix.toLowerCase()) === 0;
  });
}

function cleanPrefix_(text) {
  let result = String(text || '').trim();
  APP.replyPrefixes.forEach(function(prefix) {
    if (result.toLowerCase().indexOf(prefix.toLowerCase()) === 0) {
      result = result.substring(prefix.length).trim();
    }
  });
  return result;
}

function readSchedule_() {
  const cfg = getConfig_();
  const sheet = SpreadsheetApp.openById(cfg.sheetId).getSheetByName(cfg.sheetName);
  if (!sheet) throw new Error('ไม่พบชีตชื่อ ' + cfg.sheetName);

  const values = sheet.getDataRange().getValues();
  if (values.length < 2) return [];

  return values.slice(1).filter(function(row) {
    const active = row[4];
    return row[0] && active !== false && String(active).toUpperCase() !== 'FALSE';
  }).map(function(row) {
    return {
      date: formatDateValue_(row[0]),
      shift: String(row[1] || ''),
      person: String(row[2] || ''),
      notes: String(row[3] || '')
    };
  });
}

function formatDateValue_(value) {
  if (value instanceof Date) {
    return Utilities.formatDate(value, APP.timezone, 'yyyy-MM-dd');
  }
  return String(value || '').trim();
}

function scheduleToText_(rows) {
  if (!rows.length) return 'ไม่พบข้อมูลตารางเวร';
  return rows.map(function(r) {
    return [r.date, r.shift, r.person, r.notes].join(' | ');
  }).join('\n');
}

function buildPrompt_(question, context) {
  const now = Utilities.formatDate(new Date(), APP.timezone, 'yyyy-MM-dd HH:mm');
  return [
    'คุณคือผู้ช่วยตารางเวรของทีม ตอบภาษาไทยแบบสั้น ชัด และสุภาพ',
    'เวลาปัจจุบันในประเทศไทย: ' + now,
    'กติกา:',
    '1) ใช้เฉพาะข้อมูลตารางเวรที่ให้มาเท่านั้น',
    '2) ห้ามเดาชื่อ วันที่ หรือกะที่ไม่มีในข้อมูล',
    '3) หากไม่พบ ให้ตอบว่า “ไม่พบข้อมูลในตารางเวร กรุณาตรวจสอบกับผู้ดูแล”',
    '4) แปลงคำว่า วันนี้/พรุ่งนี้/สัปดาห์นี้ จากเวลาปัจจุบันข้างต้น',
    '5) ไม่ต้องบอกว่าคุณเป็น AI และไม่ต้องอธิบายวิธีคิด',
    '',
    'คำถาม: ' + question,
    '',
    'ข้อมูลตารางเวร (Date | Shift | Person | Notes):',
    context
  ].join('\n');
}

function callGemini_(prompt, cfg) {
  const url = 'https://generativelanguage.googleapis.com/v1beta/models/' +
    encodeURIComponent(cfg.geminiModel) + ':generateContent';

  const response = UrlFetchApp.fetch(url, {
    method: 'post',
    contentType: 'application/json',
    headers: { 'x-goog-api-key': cfg.geminiApiKey },
    payload: JSON.stringify({
      contents: [{ role: 'user', parts: [{ text: prompt }] }],
      generationConfig: { temperature: 0.1, maxOutputTokens: 500 }
    }),
    muteHttpExceptions: true
  });

  ensureSuccess_(response, 'Gemini');
  const data = JSON.parse(response.getContentText());
  const parts = (((data.candidates || [])[0] || {}).content || {}).parts || [];
  const text = parts.map(function(p) { return p.text || ''; }).join('').trim();
  if (!text) throw new Error('Gemini ไม่ส่งข้อความกลับ');
  return text;
}

function callOpenAI_(prompt, cfg) {
  const response = UrlFetchApp.fetch('https://api.openai.com/v1/responses', {
    method: 'post',
    contentType: 'application/json',
    headers: { Authorization: 'Bearer ' + cfg.openaiApiKey },
    payload: JSON.stringify({
      model: cfg.openaiModel,
      instructions: 'ตอบจากข้อมูลที่ได้รับเท่านั้น ห้ามแต่งข้อมูล',
      input: prompt,
      max_output_tokens: 500
    }),
    muteHttpExceptions: true
  });

  ensureSuccess_(response, 'OpenAI');
  const data = JSON.parse(response.getContentText());
  if (data.output_text) return String(data.output_text).trim();

  const texts = [];
  (data.output || []).forEach(function(item) {
    (item.content || []).forEach(function(part) {
      if (part.type === 'output_text' && part.text) texts.push(part.text);
    });
  });
  if (!texts.length) throw new Error('OpenAI ไม่ส่งข้อความกลับ');
  return texts.join('\n').trim();
}

function ensureSuccess_(response, serviceName) {
  const code = response.getResponseCode();
  if (code < 200 || code >= 300) {
    throw new Error(serviceName + ' API ' + code + ': ' +
      response.getContentText().substring(0, 500));
  }
}

function replyLine_(replyToken, text, cfg) {
  if (!replyToken) return;
  const safeText = String(text || 'ไม่พบคำตอบ').substring(0, 4500);
  const response = UrlFetchApp.fetch('https://api.line.me/v2/bot/message/reply', {
    method: 'post',
    contentType: 'application/json',
    headers: { Authorization: 'Bearer ' + cfg.lineToken },
    payload: JSON.stringify({
      replyToken: replyToken,
      messages: [{ type: 'text', text: safeText }]
    }),
    muteHttpExceptions: true
  });
  ensureSuccess_(response, 'LINE Reply');
}

function pushLine_(to, text, cfg) {
  const response = UrlFetchApp.fetch('https://api.line.me/v2/bot/message/push', {
    method: 'post',
    contentType: 'application/json',
    headers: { Authorization: 'Bearer ' + cfg.lineToken },
    payload: JSON.stringify({
      to: to,
      messages: [{ type: 'text', text: String(text).substring(0, 4500) }]
    }),
    muteHttpExceptions: true
  });
  ensureSuccess_(response, 'LINE Push');
}

function sendWeeklyDutyReminder() {
  const cfg = getConfig_();
  if (!cfg.groupId) throw new Error('ยังไม่ได้ตั้ง GROUP_ID ใน Script Properties');

  const today = startOfDay_(new Date());
  const end = new Date(today.getTime() + 6 * 24 * 60 * 60 * 1000);
  const rows = readSchedule_().filter(function(r) {
    const d = parseIsoDate_(r.date);
    return d && d >= today && d <= end;
  });

  const title = '📅 ตารางเวร 7 วันข้างหน้า';
  const detail = rows.length ? rows.map(function(r) {
    return '• ' + r.date + ' | ' + r.shift + ' | ' + r.person +
      (r.notes ? ' (' + r.notes + ')' : '');
  }).join('\n') : 'ไม่พบข้อมูลตารางเวรในช่วงนี้';

  pushLine_(cfg.groupId, title + '\n' + detail, cfg);
}

function startOfDay_(date) {
  const iso = Utilities.formatDate(date, APP.timezone, 'yyyy-MM-dd');
  return parseIsoDate_(iso);
}

function parseIsoDate_(iso) {
  const m = String(iso).match(/^(\d{4})-(\d{2})-(\d{2})$/);
  if (!m) return null;
  return new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]));
}

function logEvent_(event, message, status) {
  try {
    const cfg = getConfig_();
    const ss = SpreadsheetApp.openById(cfg.sheetId);
    let sheet = ss.getSheetByName('Logs');
    if (!sheet) {
      sheet = ss.insertSheet('Logs');
      sheet.appendRow(['Timestamp','SourceType','SourceID','UserID','Message','Status']);
    }
    const source = event.source || {};
    sheet.appendRow([
      new Date(), source.type || '',
      source.groupId || source.roomId || source.userId || '',
      source.userId || '', message || '', status || ''
    ]);
  } catch (err) {
    console.error('Log error: ' + err.message);
  }
}

function getConfig_() {
  const p = PropertiesService.getScriptProperties().getProperties();
  const required = ['LINE_CHANNEL_ACCESS_TOKEN','SHEET_ID','WEBHOOK_SECRET','AI_PROVIDER'];
  required.forEach(function(key) {
    if (!p[key]) throw new Error('ขาด Script Property: ' + key);
  });

  const provider = String(p.AI_PROVIDER).toLowerCase();
  if (provider === 'gemini' && !p.GEMINI_API_KEY) {
    throw new Error('ขาด Script Property: GEMINI_API_KEY');
  }
  if (provider === 'openai' && !p.OPENAI_API_KEY) {
    throw new Error('ขาด Script Property: OPENAI_API_KEY');
  }

  return {
    lineToken: p.LINE_CHANNEL_ACCESS_TOKEN,
    sheetId: p.SHEET_ID,
    sheetName: p.SHEET_NAME || 'Schedule',
    webhookSecret: p.WEBHOOK_SECRET,
    aiProvider: provider,
    geminiApiKey: p.GEMINI_API_KEY || '',
    geminiModel: p.GEMINI_MODEL || 'gemini-3.7-flash',
    openaiApiKey: p.OPENAI_API_KEY || '',
    openaiModel: p.OPENAI_MODEL || 'gpt-5-mini',
    groupId: p.GROUP_ID || ''
  };
}

function jsonOutput_(data) {
  return ContentService.createTextOutput(JSON.stringify(data))
    .setMimeType(ContentService.MimeType.JSON);
}

https://script.google.com/macros/s/DEPLOYMENT_ID/exec?key=ค่าจาก_WEBHOOK_SECRET